@magic/types 0.1.23 → 0.1.25

package/src/{lib.mjs → lib.js}

@@ -1,4 +1,5 @@
-import * as fns from './fns.mjs'
+import * as fns from './fns.js'
+import * as deep from './deep/index.js'
 
 export const is = {
   count: fns.getLength,
@@ -42,10 +43,10 @@ export const is = {
   thenable: fns.isPromise,
   then: fns.isPromise,
 
-  // isArguments: fns.isArguments,
-  // isArgs: fns.isArguments,
-  // arguments: fns.isArguments,
-  // args: fns.isArguments,
+  isArguments: fns.isArguments,
+  isArgs: fns.isArguments,
+  arguments: fns.isArguments,
+  args: fns.isArguments,
 
   isUUID: fns.isUUID,
   uuid: fns.isUUID,
@@ -57,16 +58,11 @@ export const is = {
   isTypes: fns.isTypes,
   test: fns.isTypes,
   types: fns.isTypes,
+  is: fns.isTypes,
 
   isEmpty: fns.isEmpty,
   empty: fns.isEmpty,
 
-  isEqual: fns.isEqual,
-  isEq: fns.isEqual,
-  equal: fns.isEqual,
-  eq: fns.isEqual,
-  is: fns.isEqual,
-
   isNot: fns.isNot,
   not: fns.isNot,
   isNeq: fns.isNot,
@@ -109,7 +105,6 @@ export const is = {
   isGeneratorFunction: fns.isGeneratorFunction,
   isGeneratorFn: fns.isGeneratorFunction,
   isGeneratorFunc: fns.isGeneratorFunction,
-  isGeneratorFn: fns.isGeneratorFunction,
   generator: fns.isGeneratorFunction,
   isGenerator: fns.isGeneratorFunction,
   generatorFn: fns.isGeneratorFunction,
@@ -271,13 +266,17 @@ export const is = {
 
   isModule: fns.isModule,
   module: fns.isModule,
+  ...deep,
 }
 
-// assign ln as properties of the getLength function
-const ln = {
+// count, length, len and ln are functions that return the length,
+// but they also have comparison methods attached as properties.
+// This creates enhanced length functions with comparison capabilities.
+
+// Create enhanced length functions with comparison methods
+const lengthFunctions = {
   eq: fns.isLengthEqual,
   equal: fns.isLengthEqual,
-  greater: fns.isLengthGreater,
   gt: fns.isLengthGreater,
   bigger: fns.isLengthGreater,
   biggerequal: fns.isLengthGreaterOrEqual,
@@ -285,7 +284,6 @@ const ln = {
   greaterequal: fns.isLengthGreaterOrEqual,
   gte: fns.isLengthGreaterOrEqual,
   gteq: fns.isLengthGreaterOrEqual,
-
   lower: fns.isLengthSmaller,
   smaller: fns.isLengthSmaller,
   lt: fns.isLengthSmaller,
@@ -295,14 +293,10 @@ const ln = {
   lteq: fns.isLengthSmallerOrEqual,
 }
 
-// count, length, len and ln are functions, returning the length.
-// the code below assigns all keys in the ln object to each of those functions,
-// allowing users of this library to call is.length.equal and other subfunctions.
-
-const applyLenKey = (k, fn) => key => (is[key][k] = fn)
-
-const applyLenKeys = ([k, fn]) => ['count', 'length', 'len', 'ln'].forEach(applyLenKey(k, fn))
+// Replace the original length functions with enhanced versions
+is.ln = fns.getLength
+Object.assign(is.ln, lengthFunctions)
 
-Object.entries(ln).forEach(applyLenKeys)
+is.length = is.len = is.count = is.ln
 
 export default is

package/types/deep/different.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function different(a: unknown, b: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+export function different(a: unknown): (c: unknown) => boolean
+export default different

package/types/deep/equal.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function equal(a: unknown, b: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+export function equal(a: unknown): (c: unknown) => boolean
+export default equal

package/types/deep/index.d.ts

@@ -0,0 +1,100 @@
+export const isDeepEqual: {
+  /**
+   * @overload
+   * @param {unknown} a
+   * @param {unknown} b
+   * @returns {boolean}
+   */
+  (a: unknown, b: unknown): boolean
+  /**
+   * @overload
+   * @param {unknown} a
+   * @returns {(c: unknown) => boolean}
+   */
+  (a: unknown): (c: unknown) => boolean
+}
+export const deepEqual: {
+  /**
+   * @overload
+   * @param {unknown} a
+   * @param {unknown} b
+   * @returns {boolean}
+   */
+  (a: unknown, b: unknown): boolean
+  /**
+   * @overload
+   * @param {unknown} a
+   * @returns {(c: unknown) => boolean}
+   */
+  (a: unknown): (c: unknown) => boolean
+}
+export const deepEq: {
+  /**
+   * @overload
+   * @param {unknown} a
+   * @param {unknown} b
+   * @returns {boolean}
+   */
+  (a: unknown, b: unknown): boolean
+  /**
+   * @overload
+   * @param {unknown} a
+   * @returns {(c: unknown) => boolean}
+   */
+  (a: unknown): (c: unknown) => boolean
+}
+export const isDeepDifferent: {
+  /**
+   * @overload
+   * @param {unknown} a
+   * @param {unknown} b
+   * @returns {boolean}
+   */
+  (a: unknown, b: unknown): boolean
+  /**
+   * @overload
+   * @param {unknown} a
+   * @returns {(c: unknown) => boolean}
+   */
+  (a: unknown): (c: unknown) => boolean
+}
+export const deepDifferent: {
+  /**
+   * @overload
+   * @param {unknown} a
+   * @param {unknown} b
+   * @returns {boolean}
+   */
+  (a: unknown, b: unknown): boolean
+  /**
+   * @overload
+   * @param {unknown} a
+   * @returns {(c: unknown) => boolean}
+   */
+  (a: unknown): (c: unknown) => boolean
+}
+export const deepDiff: {
+  /**
+   * @overload
+   * @param {unknown} a
+   * @param {unknown} b
+   * @returns {boolean}
+   */
+  (a: unknown, b: unknown): boolean
+  /**
+   * @overload
+   * @param {unknown} a
+   * @returns {(c: unknown) => boolean}
+   */
+  (a: unknown): (c: unknown) => boolean
+}
+export namespace deep {
+  export { different as isDifferent }
+  export { different }
+  export { different as diff }
+  export { equal as isEqual }
+  export { equal }
+  export { equal as eq }
+}
+import { different } from './different'
+import { equal } from './equal'

package/types/fns.d.ts

@@ -0,0 +1,178 @@
+export function isArray(e: unknown): e is unknown[]
+export function isBoolean(e: unknown): e is boolean
+export function isDefined(e: unknown): e is NonNullable<unknown>
+export function isUndefined(e: unknown): e is undefined
+export function isFunction(e: unknown): e is Function
+export function isAsyncFunction(e: unknown): e is (...args: unknown[]) => Promise<unknown>
+export function isGeneratorFunction(e: unknown): e is GeneratorFunction
+export function isNumber(e: unknown): e is number
+export function isInteger(e: unknown): e is number
+export function isFloat(e: unknown): e is number
+export function isObject(e: unknown): e is object
+export function isObjectNative(e: unknown): e is Record<string, unknown>
+export function isMergeableObject(e: unknown): e is Record<string, unknown>
+/**
+ * Alias for isMergeableObject
+ * @type {(e: unknown) => e is Record<string, unknown>}
+ */
+export const isMergeable: (e: unknown) => e is Record<string, unknown>
+export function isString(e: unknown): e is string
+export function isRGBValue(e: unknown): e is {
+  r: number
+  g: number
+  b: number
+}
+export function isRGBObject(e: unknown): e is {
+  r: number
+  g: number
+  b: number
+}
+export function isRGBAValue(e: unknown): e is {
+  r: number
+  g: number
+  b: number
+  a: number
+}
+export function isRGBAObject(e: unknown): e is {
+  r: number
+  g: number
+  b: number
+  a: number
+}
+export const hexRegex: RegExp
+export function isHexColor(e: unknown): boolean
+export function isHexColor3(e: unknown): boolean
+export function isHexColor4(e: unknown): boolean
+export function isHexColor6(e: unknown): boolean
+export function isHexColor8(e: unknown): boolean
+export function isHexAlphaColor(e: unknown): boolean
+export function isHexAlphaColor4(e: unknown): boolean
+export function isHexAlphaColor8(e: unknown): boolean
+export function isColor(e: unknown): boolean
+export function isTruthy(e: unknown): boolean
+export function isFalsy(e: unknown): boolean
+export function getLength(arg: unknown): number
+export function compareCount(len: unknown, e: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function isLengthEqual(a: unknown, b: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+export function isLengthEqual(a: unknown): (c: unknown) => boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function isLengthGreater(a: unknown, b: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+export function isLengthGreater(a: unknown): (c: unknown) => boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function isLengthGreaterOrEqual(a: unknown, b: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+export function isLengthGreaterOrEqual(a: unknown): (c: unknown) => boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function isLengthSmaller(a: unknown, b: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+export function isLengthSmaller(a: unknown): (c: unknown) => boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @param {unknown} b
+ * @returns {boolean}
+ */
+export function isLengthSmallerOrEqual(a: unknown, b: unknown): boolean
+/**
+ * @overload
+ * @param {unknown} a
+ * @returns {(c: unknown) => boolean}
+ */
+export function isLengthSmallerOrEqual(a: unknown): (c: unknown) => boolean
+export function isEmpty(e: unknown): boolean
+export function isIterable(e: unknown): e is Iterable<unknown>
+export function isEmail(e: unknown): e is string
+export function isNull(e: unknown): e is null
+export function isUndefinedOrNull(e: unknown): e is null | undefined
+export function isBuffer(e: unknown): e is Buffer
+export function isPromise(e: unknown): e is Promise<unknown>
+/**
+ * Alias for isPromise
+ * @type {(e: unknown) => e is Promise<unknown>}
+ */
+export const isThenable: (e: unknown) => e is Promise<unknown>
+export function isArguments(e: unknown): e is IArguments
+export function isUUID(e: unknown): boolean
+export function isType(e: unknown, ...types: string[]): boolean
+export function isTypes(e: unknown, ...types: string[]): boolean
+export function isNot(e: unknown, ...types: string[]): boolean
+export function isSameType(a: unknown, b: unknown): boolean
+export function isComparable(a: unknown): a is string | number | boolean
+export function isEvery<T>(arr: T | T[], t: ((v: T) => boolean) | string): boolean
+export function isSome<T>(arr: T | T[], t: ((v: T) => boolean) | string): boolean
+export function isNone<T>(arr: T | T[], t: ((v: T) => boolean) | string): boolean
+export function isInstanceOf(e: unknown, t: new (...args: any[]) => any): boolean
+export function isError(e: unknown): e is Error
+export function isDate(e: unknown): e is Date
+export function isRegExp(e: unknown): e is RegExp
+export function isMap(a: unknown): a is Map<unknown, unknown>
+export function isSet(a: unknown): a is Set<unknown>
+export function isWeakMap(a: unknown): a is WeakMap<any, unknown>
+export function isWeakSet(a: unknown): a is WeakSet<any>
+export function isUpperCase(s: unknown): s is string
+export function isLowerCase(s: unknown): s is string
+export function isOwnProp<K extends string | number | symbol>(
+  o: unknown,
+  k: K,
+): o is Record<K, unknown>
+export function isOwnProperty<K extends string | number | symbol>(
+  o: unknown,
+  k: K,
+): o is Record<K, unknown>
+export function isModule(s: unknown): s is ModuleLike
+/**
+ * Check if a string is upper or lower case depending on mode
+ * @type {((s: unknown, c?: 'up' | 'down') => boolean) & {
+ *   upper: (s: unknown) => boolean,
+ *   lower: (s: unknown) => boolean
+ * }}
+ */
+export const isCase: ((s: unknown, c?: 'up' | 'down') => boolean) & {
+  upper: (s: unknown) => boolean
+  lower: (s: unknown) => boolean
+}
+/**
+ * A type representing a Module-like object
+ */
+export type ModuleLike = object & {
+  [Symbol.toStringTag]: 'Module'
+}