The toolkit-use npm package has added some shared utility methods

export const isUndef = (v: any) => {
  return v === undefined || v === null
}

export const isDef = (v: any) => {
  return v !== undefined && v !== null
}

export const isTrue = (v: any) => {
  return v === true
}

export const isFalse = (v: any) => {
  return v === false
}

export const isPrimitive = (v: any) => {
  return (
    typeof v === 'string' ||
    typeof v === 'number' ||
    typeof v === 'symbol' ||
    typeof v === 'boolean'
  )
}

export const isObject = (obj: any) => {
  return obj !== null && typeof obj === 'object'  // Note the 'null' in the typeof check
}

export const isPromise = (val: any) => {
  return (
    isDef(val) &&
    typeof val.then === 'function' &&
    typeof val.catch === 'function'
  )
}

const _toString = Object.prototype.toString
export const toRawType = (val: any) => {
  return _toString.call(val).slice(8, -1)
}

const hasOwnProperty = Object.prototype.hasOwnProperty
export const  hasOwn = (obj: any, key: any) => {
  return hasOwnProperty.call(obj, key)
}

export const toNumber = (val: any) => {
  const n = parseFloat(val);
  return isNaN(n) ? val : n
}

/**
 * @param {any} obj The object to inspect.
 * @returns {boolean} True if the argument appears to be a plain object.
 */
export function isPlainObject(obj) {
  if (typeof obj !== 'object' || obj === null) return false

  let proto = Object.getPrototypeOf(obj)
  // 1. edge case Object.create(null)
  if (proto === null) return true
  let baseProto = proto
  while (Object.getPrototypeOf(baseProto) !== null) {
    baseProto = Object.getPrototypeOf(baseProto)
  }
  // 2. Compare the first and last prototypes in the prototype chain
  return proto === baseProto
}

export const toString = (val: any) => {
  return val == null
    ? ''
    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
      ? JSON.stringify(val, null, 2)  // For arrays or objects
      : String(val)
}

export function toArray (list, start) {
  start = start || 0;
  var i = list.length - start;
  var ret = new Array(i);
  while (i--) {
    ret[i] = list[i + start];
  }
  return ret
}

export function extend (to, _from) {
  for (var key in _from) {
    to[key] = _from[key];
  }
  return to
}

export function toObject (arr) {
  var res = {};
  for (var i = 0; i < arr.length; i++) {
    if (arr[i]) {
      extend(res, arr[i]);
    }
  }
  return res
}

export function cached (fn) {
  var cache = Object.create(null);
  return (function cachedFn (str) {
    var hit = cache[str];  // Cache lookup
    return hit || (cache[str] = fn(str))
  })
}

export const capitalize = cached(function (str) {
  return str.charAt(0).toUpperCase() + str.slice(1)
});

export const hyphenate = cached(function (str) {
  return str.replace(hyphenateRE, '-$1').toLowerCase()
});

export const camelize = cached(function (str) {
  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
});

export function makeMap (
  str,
  expectsLowerCase
) {
  var map = Object.create(null);
  var list = str.split(',');
  for (var i = 0; i < list.length; i++) {
    map[list[i]] = true;
  }
  return expectsLowerCase
    ? function (val) { return map[val.toLowerCase()]; }
    : function (val) { return map[val]; }
}

export function looseEqual (a, b) {
  // Return true if a and b are strictly equal
  if (a === b) { return true }
  var isObjectA = isObject(a);
  var isObjectB = isObject(b);
  // Check if both are objects (reference types)
  if (isObjectA && isObjectB) {
    try {
      var isArrayA = Array.isArray(a);
      var isArrayB = Array.isArray(b);
      if (isArrayA && isArrayB) {
        // If both are arrays, compare their lengths and recursively check each item, return false if they differ
        return a.length === b.length && a.every(function (e, i) {
          return looseEqual(e, b[i])
        })
      } else if (a instanceof Date && b instanceof Date) {
        // If both are Date objects, compare them using their timestamps
        return a.getTime() === b.getTime()
      } else if (!isArrayA && !isArrayB) {
        // If both are objects, compare their property values recursively if their lengths match, return false if they differ
        var keysA = Object.keys(a);
        var keysB = Object.keys(b);
        return keysA.length === keysB.length && keysA.every(function (key) {
          return looseEqual(a[key], b[key])
        })
      } else {
        /* istanbul ignore next */
        return false
      }
    } catch (e) {
      /* istanbul ignore next */
      return false
    }
  } else if  (!isObjectA && !isObjectB) {
    // If both are not objects (primitive types), convert them to strings and compare
    return String(a) === String(b)
  } else {
    return false
  }
}

export function remove (arr, item) {
  if (arr.length) {
    var index = arr.indexOf(item);
    if (index > -1) {
      return arr.splice(index, 1)
    }
  }
}

export function once (fn) {
  var called = false;
  return function () {
    if (!called) {
      called = true;
      fn.apply(this, arguments);
    }
  }
}

export function looseCompareArrays(a, b) {
    // If the lengths differ, return false
    if (a.length !== b.length)
        return false;
    let equal = true;
    // If the lengths are the same, compare each item in the arrays
    for (let i = 0; equal && i < a.length; i++) {
        equal = looseEqual(a[i], b[i]);
    }
    return equal;
}

export const def = (obj, key, value) => {
  Object.defineProperty(obj, key, {
      configurable: true,  // Configurable
      enumerable: false,  // Not enumerable
      value
  });
};

export const objectToString = Object.prototype.toString;

export const toTypeString = (value) => objectToString.call(value);

export const isArray = Array.isArray;

export const isMap = (val) => toTypeString(val) === '[object Map]';

export const isSet = (val) => toTypeString(val) === '[object Set]';

export const isDate = (val) => val instanceof Date;

export const isFunction = (val) => typeof val === 'function';

export const isString = (val) => typeof val === 'string';

export const isSymbol = (val) => typeof val === 'symbol';

export const isIntegerKey = (key) => isString(key) && key !== 'NaN' && key[0] !== '-' && '' + parseInt(key, 10) === key;

export const invokeArrayFns = (fns, arg) => {
  for (let i = 0; i < fns.length; i++) {
      fns[i](arg);
  }
};

export const hasChanged = (value, oldValue) => !Object.is(value, oldValue)
}