type-plus 6.2.0 → 6.4.0

package/cjs/predicates/index.d.ts

@@ -1,10 +1,8 @@
 export * from './CanAssign.js';
-export type { Equal, IsEqual, IsNotEqual, NotEqual } from './Equal.js';
 export type { Extendable, IsExtend, IsNotExtend, NotExtendable } from './Extends.js';
 export type { If } from './If.js';
 export type { IsEmptyObject } from './IsEmptyObject.js';
 export * from './isType.js';
 export type { And, Not, Or, Xor } from './logical.js';
 export type IsLiteral<T extends number | string, Then = true, Else = false> = number extends T ? Else : string extends T ? Else : Then;
-export type IsBoolean<T, Then = true, Else = false> = boolean extends T ? Then : Else;
 //# sourceMappingURL=index.d.ts.map

package/cjs/predicates/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../ts/predicates/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,YAAY,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAA;AACtE,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACpF,YAAY,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AACjC,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,YAAY,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAErD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,MAAM,SAAS,CAAC,GAC3F,IAAI,GACJ,MAAM,SAAS,CAAC,GAChB,IAAI,GACJ,IAAI,CAAA;AAEP,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,SAAS,CAAC,GAAG,IAAI,GAAG,IAAI,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../ts/predicates/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACpF,YAAY,EAAE,EAAE,EAAE,MAAM,SAAS,CAAA;AACjC,YAAY,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACvD,cAAc,aAAa,CAAA;AAC3B,YAAY,EAAE,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,MAAM,cAAc,CAAA;AAErD,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,MAAM,SAAS,CAAC,GAC3F,IAAI,GACJ,MAAM,SAAS,CAAC,GAChB,IAAI,GACJ,IAAI,CAAA"}

package/cjs/predicates/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/predicates/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA8B;AAK9B,8CAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../ts/predicates/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,iDAA8B;AAI9B,8CAA2B"}

package/cjs/predicates/isType.d.ts

@@ -1,4 +1,4 @@
-import type { Equal } from './Equal.js';
+import type { Equal } from '../equal/equal.js';
 /**
  * Is the subject of type T
  */

package/cjs/predicates/isType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isType.d.ts","sourceRoot":"","sources":["../../ts/predicates/isType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAEvC;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,CAAA;AACnD;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,IAAI,CAAC,CAAA;yBAAvE,MAAM;;;;;;AAYtB;;GAEG;AACH,iBAAS,OAAO,CAAC,CAAC,SAAS,KAAK,KAAK,OAAO,CAAA;AAC5C;;GAEG;AACH,iBAAS,OAAO,CAAC,OAAO,EAAE,KAAK,GAAG,OAAO,IAAI,KAAK,CAAA"}
+{"version":3,"file":"isType.d.ts","sourceRoot":"","sources":["../../ts/predicates/isType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAE9C;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,OAAO,IAAI,CAAC,CAAA;AACnD;;GAEG;AACH,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,EAAE,CAAC,KAAK,OAAO,GAAG,OAAO,IAAI,CAAC,CAAA;yBAAvE,MAAM;;;;;;AAatB;;GAEG;AACH,iBAAS,OAAO,CAAC,CAAC,SAAS,KAAK,KAAK,OAAO,CAAA;AAC5C;;GAEG;AACH,iBAAS,OAAO,CAAC,OAAO,EAAE,KAAK,GAAG,OAAO,IAAI,KAAK,CAAA"}

package/cjs/predicates/isType.js

@@ -19,7 +19,8 @@ isType.never = isNever;
  * Are types A and B equals/not equals.
  * Easier to use than `isType.t<>()` and `isType.f<>()`,
  * when doing type level only equality comparison as you don't have to import `Equal<>`.
+ *
+ * @deprecated use `type.equal()` instead
  */
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 isType.equal = function () { };
 //# sourceMappingURL=isType.js.map

package/cjs/predicates/isType.js.map

@@ -1 +1 @@
-{"version":3,"file":"isType.js","sourceRoot":"","sources":["../../ts/predicates/isType.ts"],"names":[],"mappings":";;;AAUA,SAAgB,MAAM,CAAC,OAAgB,EAAE,SAAmC;IAC3E,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AAC/C,CAAC;AAFD,wBAEC;AAED,MAAM,CAAC,CAAC,GAAG,UAA0B,OAAW;IAC/C,OAAO,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,IAAI,CAAA;AACjD,CAAC,CAAA;AACD,MAAM,CAAC,CAAC,GAAG,UAA2B,OAAW;IAChD,OAAO,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,CAAA;AAClD,CAAC,CAAA;AAUD,SAAS,OAAO,CAAC,OAAiB;IACjC,OAAO,IAAI,CAAA;AACZ,CAAC;AAED,MAAM,CAAC,KAAK,GAAG,OAAO,CAAA;AAEtB;;;;GAIG;AACH,6DAA6D;AAC7D,MAAM,CAAC,KAAK,GAAG,cAA0C,CAAC,CAAA"}
+{"version":3,"file":"isType.js","sourceRoot":"","sources":["../../ts/predicates/isType.ts"],"names":[],"mappings":";;;AAUA,SAAgB,MAAM,CAAC,OAAgB,EAAE,SAAmC;IAC3E,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,IAAI,CAAA;AAC/C,CAAC;AAFD,wBAEC;AAED,MAAM,CAAC,CAAC,GAAG,UAA0B,OAAW;IAC/C,OAAO,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,IAAI,CAAA;AACjD,CAAC,CAAA;AAED,MAAM,CAAC,CAAC,GAAG,UAA2B,OAAW;IAChD,OAAO,OAAO,KAAK,SAAS,IAAI,OAAO,KAAK,KAAK,CAAA;AAClD,CAAC,CAAA;AAUD,SAAS,OAAO,CAAC,OAAiB;IACjC,OAAO,IAAI,CAAA;AACZ,CAAC;AAED,MAAM,CAAC,KAAK,GAAG,OAAO,CAAA;AAEtB;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,GAAG,cAA0C,CAAC,CAAA"}

package/cjs/primitive.d.ts

@@ -0,0 +1,2 @@
+export type PrimitiveTypes = boolean | number | string | object | symbol | bigint | Function | undefined | null;
+//# sourceMappingURL=primitive.d.ts.map

package/cjs/primitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive.d.ts","sourceRoot":"","sources":["../ts/primitive.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GACvB,OAAO,GACP,MAAM,GACN,MAAM,GACN,MAAM,GACN,MAAM,GACN,MAAM,GACN,QAAQ,GACR,SAAS,GACT,IAAI,CAAA"}

package/cjs/primitive.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=primitive.js.map

package/cjs/primitive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"primitive.js","sourceRoot":"","sources":["../ts/primitive.ts"],"names":[],"mappings":""}

package/cjs/string/strict_string_type.d.ts

@@ -0,0 +1,66 @@
+import type { IsAny } from '../any/any_type.js';
+/**
+ * Check if the type `T` is exactly `string`.
+ *
+ * ```
+ * import type { StrictStringType } from 'type-plus'
+ *
+ * type R = StrictStringType<string> // string
+*
+* type R = StrictStringType<''> // never
+* type R = StrictStringType<'1'> // never
+* type R = StrictStringType<string | boolean> // never
+* type R = StrictStringType<never> // never
+* type R = StrictStringType<unknown> // never
+ * ```
+ */
+export type StrictStringType<T, Then = T, Else = never> = IsAny<T, Else, [T, string] extends [string, T] ? Then : Else>;
+/**
+ * Is the type `T` exactly `string`.
+ *
+ * ```
+ * import type { IsStrictString } from 'type-plus'
+ *
+ * type R = IsStrictString<string> // true
+ *
+ * type R = IsStrictString<''> // false
+ * type R = IsStrictString<'a'> // false
+ * type R = IsStrictString<string | boolean> // false
+ * type R = IsStrictString<never> // false
+ * type R = IsStrictString<unknown> // false
+ * ```
+ */
+export type IsStrictString<T, Then = true, Else = false> = StrictStringType<T, Then, Else>;
+/**
+ * Check if the type `T` is not exactly `string`.
+ *
+ * ```
+ * import type { NotStrictStringType } from 'type-plus'
+ *
+ * type R = NotStrictStringType<string> // never
+ *
+ * type R = NotStrictStringType<''> // ''
+ * type R = NotStrictStringType<'a'> // 'a'
+ * type R = NotStrictStringType<string | boolean> // string | boolean
+ * type R = NotStrictStringType<never> // never
+ * type R = NotStrictStringType<unknown> // unknown
+ * ```
+ */
+export type NotStrictStringType<T, Then = T, Else = never> = StrictStringType<T, Else, Then>;
+/**
+ * Is the type `T` not exactly `string`.
+ *
+ * ```
+ * import type { IsNotStrictString } from 'type-plus'
+ *
+ * type R = IsNotStrictString<string> // false
+ *
+ * type R = IsNotStrictString<''> // true
+ * type R = IsNotStrictString<'a'> // true
+ * type R = IsNotStrictString<string | boolean> // true
+ * type R = IsNotStrictString<never> // true
+ * type R = IsNotStrictString<unknown> // true
+ * ```
+ */
+export type IsNotStrictString<T, Then = true, Else = false> = StrictStringType<T, Else, Then>;
+//# sourceMappingURL=strict_string_type.d.ts.map

package/cjs/string/strict_string_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict_string_type.d.ts","sourceRoot":"","sources":["../../ts/string/strict_string_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAE/C;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,KAAK,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AAEvH;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE1F;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5F;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/cjs/string/strict_string_type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=strict_string_type.js.map

package/cjs/string/strict_string_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"strict_string_type.js","sourceRoot":"","sources":["../../ts/string/strict_string_type.ts"],"names":[],"mappings":""}

package/cjs/string/string_type.d.ts

@@ -0,0 +1,66 @@
+import type { IsAnyOrNever } from '../any/any_or_never.js';
+/**
+ * Check if the type `T` is `string` or string literals.
+ *
+ * ```
+ * import type { StringType } from 'type-plus'
+ *
+ * type R = StringType<string> // string
+ * type R = StringType<''> // ''
+ * type R = StringType<'1'> // '1'
+ *
+ * type R = StringType<string | boolean> // never
+ * type R = StringType<never> // never
+ * type R = StringType<unknown> // never
+ * ```
+ */
+export type StringType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [T] extends [string] ? Then : Else>;
+/**
+ * Is the type `T` `string` or string literals.
+ *
+ * ```
+ * import type { IsString } from 'type-plus'
+ *
+ * type R = IsString<string> // true
+ * type R = IsString<''> // true
+ * type R = IsString<'a'> // true
+ *
+ * type R = IsString<string | boolean> // false
+ * type R = IsString<never> // false
+ * type R = IsString<unknown> // false
+ * ```
+ */
+export type IsString<T, Then = true, Else = false> = StringType<T, Then, Else>;
+/**
+ * Check if the type `T` is not `string` nor string literals.
+ *
+ * ```
+ * import type { NotStringType } from 'type-plus'
+ *
+ * type R = NotStringType<string> // never
+ * type R = NotStringType<''> // ''
+ * type R = NotStringType<'a'> // 'a'
+ *
+ * type R = NotStringType<string | boolean> // string | boolean
+ * type R = NotStringType<never> // never
+ * type R = NotStringType<unknown> // unknown
+ * ```
+ */
+export type NotStringType<T, Then = T, Else = never> = StringType<T, Else, Then>;
+/**
+ * Is the type `T` not `string` nor string literals.
+ *
+ * ```
+ * import type { IsNotString } from 'type-plus'
+ *
+ * type R = IsNotString<string> // false
+ * type R = IsNotString<''> // false
+ * type R = IsNotString<'a'> // false
+ *
+ * type R = IsNotString<string | boolean> // true
+ * type R = IsNotString<never> // true
+ * type R = IsNotString<unknown> // true
+ * ```
+ */
+export type IsNotString<T, Then = true, Else = false> = StringType<T, Else, Then>;
+//# sourceMappingURL=string_type.d.ts.map

package/cjs/string/string_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_type.d.ts","sourceRoot":"","sources":["../../ts/string/string_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAE1D;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AAE7G;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE9E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/cjs/string/string_type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=string_type.js.map

package/cjs/string/string_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_type.js","sourceRoot":"","sources":["../../ts/string/string_type.ts"],"names":[],"mappings":""}

package/cjs/symbol/symbol_type.d.ts

@@ -0,0 +1,60 @@
+import type { IsAnyOrNever } from '../any/any_or_never.js';
+/**
+ * Check if the type `T` is exactly `symbol`.
+ *
+ * ```
+ * import type { SymbolType } from 'type-plus'
+ *
+ * type R = SymbolType<symbol> // symbol
+ *
+ * type R = SymbolType<never> // never
+ * type R = SymbolType<unknown> // never
+ * type R = SymbolType<symbol | boolean> // never
+ * ```
+ */
+export type SymbolType<T, Then = T, Else = never> = IsAnyOrNever<T, Else, [
+    T
+] extends [symbol] ? Then : Else>;
+/**
+ * Is the type `T` exactly `symbol`.
+ *
+ * ```
+ * import type { IsSymbol } from 'type-plus'
+ *
+ * type R = IsSymbol<symbol> // true
+ *
+ * type R = IsSymbol<never> // false
+ * type R = IsSymbol<unknown> // false
+ * type R = IsSymbol<symbol | boolean> // false
+ * ```
+ */
+export type IsSymbol<T, Then = true, Else = false> = SymbolType<T, Then, Else>;
+/**
+ * Check if the type `T` is not `symbol`.
+ *
+ * ```
+ * import type { NotSymbolType } from 'type-plus'
+ *
+ * type R = NotSymbolType<symbol> // never
+ *
+ * type R = NotSymbolType<never> // never
+ * type R = NotSymbolType<unknown> // unknown
+ * type R = NotSymbolType<symbol | boolean> // symbol | boolean
+ * ```
+ */
+export type NotSymbolType<T, Then = T, Else = never> = SymbolType<T, Else, Then>;
+/**
+ * Is the type `T` not `symbol`.
+ *
+ * ```
+ * import type { IsNotSymbol } from 'type-plus'
+ *
+ * type R = IsNotSymbol<symbol> // false
+ *
+ * type R = IsNotSymbol<never> // true
+ * type R = IsNotSymbol<unknown> // true
+ * type R = IsNotSymbol<symbol | boolean> // true
+ * ```
+ */
+export type IsNotSymbol<T, Then = true, Else = false> = SymbolType<T, Else, Then>;
+//# sourceMappingURL=symbol_type.d.ts.map

package/cjs/symbol/symbol_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol_type.d.ts","sourceRoot":"","sources":["../../ts/symbol/symbol_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAA;AAE1D;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,YAAY,CAC/D,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;CAAC,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,GAAG,IAAI,CAClC,CAAA;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE9E;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAEhF;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,UAAU,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/cjs/symbol/symbol_type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=symbol_type.js.map

package/cjs/symbol/symbol_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbol_type.js","sourceRoot":"","sources":["../../ts/symbol/symbol_type.ts"],"names":[],"mappings":""}

package/cjs/testing/stub.d.ts

@@ -1,5 +1,5 @@
-import type { AnyFunction } from '../function/index.js';
-import type { RecursivePartial } from '../object/index.js';
+import type { AnyFunction } from '../function/any_function.js';
+import type { RecursivePartial } from '../object/RecursivePartial.js';
 export declare namespace stub {
     type Param<T> = T extends AnyFunction ? T : RecursivePartial<T>;
 }

package/cjs/testing/stub.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stub.d.ts","sourceRoot":"","sources":["../../ts/testing/stub.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAE1D,yBAAiB,IAAI,CAAC;IACrB,KAAY,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GAAG,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAA;CACtE;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAE3C;yBAFe,IAAI"}
+{"version":3,"file":"stub.d.ts","sourceRoot":"","sources":["../../ts/testing/stub.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAA;AAC9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAErE,yBAAiB,IAAI,CAAC;IACrB,KAAY,KAAK,CAAC,CAAC,IAAI,CAAC,SAAS,WAAW,GAAG,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAA;CACtE;AAED,wBAAgB,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,KAE3C;yBAFe,IAAI"}

package/cjs/testing/test_type.d.ts

@@ -0,0 +1,102 @@
+import type { IsAny } from '../any/any_type.js';
+import type { IsBoolean } from '../boolean/boolean_type.js';
+import type { IsFalse } from '../boolean/false_type.js';
+import type { IsStrictBoolean } from '../boolean/strict_boolean_type.js';
+import type { IsTrue } from '../boolean/true_type.js';
+import type { Equal } from '../equal/equal.js';
+import type { IsNever } from '../never/never_type.js';
+import { IsNumber } from '../number/number_type.js';
+import type { IsStrictNumber } from '../number/strict_number_type.js';
+import type { CanAssign } from '../predicates/CanAssign.js';
+import type { IsUnknown } from '../unknown/unknown_type.js';
+import type { IsVoid } from '../void/void_type.js';
+/**
+ * Check if type `A` is equal to type `B` and `C`.
+ *
+ * @return `expected` as `A` for type inspection.
+ */
+declare function equal<A, B, C>(expected: Equal<A, B> & Equal<A, C>): A;
+/**
+ * Check if type `A` is equal to type `B`.
+ *
+ * @return `expected` as `A` for type inspection.
+ */
+declare function equal<A, B>(expected: Equal<A, B>): A;
+/**
+ * Test utilities for types.
+ *
+ * This is designed specifically for testing.
+ * The return value is the input `expected` parameter asserted as the first type parameter,
+ * so that the type can be further inspected.
+ */
+export declare const testType: {
+    /**
+     * Check if type `T` is exactly `any`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    any<T>(expected: IsAny<T>): T;
+    /**
+     * Check if type `T` is exactly `unknown`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    unknown<T_1>(expected: IsUnknown<T_1>): T_1;
+    /**
+     * Check if type `T` is exactly `never`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    never<T_2>(expected: IsNever<T_2>): T_2;
+    /**
+     * Check if type `T` is exactly `void`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    void<T_3>(expected: IsVoid<T_3>): T_3;
+    equal: typeof equal;
+    /**
+     * Check if `A` can assign to `B`.
+     *
+     * @return `expected` as `A` for type inspection.
+     */
+    canAssign<A, B>(expected: CanAssign<A, B>): A;
+    /**
+     * Check if type `T` is exactly `boolean`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    strictBoolean<T_4>(expected: IsStrictBoolean<T_4>): T_4;
+    /**
+     * Check if type `T` is `boolean` and boolean literals.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    boolean<T_5>(expected: IsBoolean<T_5>): T_5;
+    /**
+     * Check if type `T` is exactly `true`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    true<T_6>(expected: IsTrue<T_6>): T_6;
+    /**
+     * Check if type `T` is exactly `false`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    false<T_7>(expected: IsFalse<T_7>): T_7;
+    /**
+     * Check if type `T` is exactly `number`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    strictNumber<T_8>(expected: IsStrictNumber<T_8>): T_8;
+    /**
+     * Check if type `T` is `number` or number literals.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    number<T_9>(expected: IsNumber<T_9>): T_9;
+};
+export {};
+//# sourceMappingURL=test_type.d.ts.map

package/cjs/testing/test_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_type.d.ts","sourceRoot":"","sources":["../../ts/testing/test_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAA;AAC/C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAA;AACxE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AACrD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mBAAmB,CAAA;AAC9C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4BAA4B,CAAA;AAC3D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAElD;;;;GAIG;AACH,iBAAS,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;AAC/D;;;;GAIG;AACH,iBAAS,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;AAK9C;;;;;;GAMG;AACH,eAAO,MAAM,QAAQ;IACpB;;;;OAIG;;IAIH;;;;OAIG;;IAIH;;;;OAIG;;IAIH;;;;OAIG;;;IAKH;;;;OAIG;;IAIH;;;;OAIG;;IAIH;;;;OAIG;;IAIH;;;;OAIG;;IAIH;;;;OAIG;;IAIH;;;;OAIG;;IAIH;;;;OAIG;;CAIH,CAAA"}

package/cjs/testing/test_type.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testType = void 0;
+function equal(expected) {
+    return expected;
+}
+/**
+ * Test utilities for types.
+ *
+ * This is designed specifically for testing.
+ * The return value is the input `expected` parameter asserted as the first type parameter,
+ * so that the type can be further inspected.
+ */
+exports.testType = {
+    /**
+     * Check if type `T` is exactly `any`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    any(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is exactly `unknown`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    unknown(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is exactly `never`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    never(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is exactly `void`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    void(expected) {
+        return expected;
+    },
+    equal,
+    /**
+     * Check if `A` can assign to `B`.
+     *
+     * @return `expected` as `A` for type inspection.
+     */
+    canAssign(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is exactly `boolean`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    strictBoolean(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is `boolean` and boolean literals.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    boolean(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is exactly `true`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    true(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is exactly `false`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    false(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is exactly `number`.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    strictNumber(expected) {
+        return expected;
+    },
+    /**
+     * Check if type `T` is `number` or number literals.
+     *
+     * @return `expected` as `T` for type inspection.
+     */
+    number(expected) {
+        return expected;
+    }
+};
+//# sourceMappingURL=test_type.js.map

package/cjs/testing/test_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test_type.js","sourceRoot":"","sources":["../../ts/testing/test_type.ts"],"names":[],"mappings":";;;AAyBA,SAAS,KAAK,CAAC,QAAiB;IAC/B,OAAO,QAAQ,CAAA;AAChB,CAAC;AAED;;;;;;GAMG;AACU,QAAA,QAAQ,GAAG;IACvB;;;;OAIG;IACH,GAAG,CAAI,QAAkB;QACxB,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,OAAO,CAAI,QAAsB;QAChC,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,KAAK,CAAI,QAAoB;QAC5B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,IAAI,CAAI,QAAmB;QAC1B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD,KAAK;IACL;;;;OAIG;IACH,SAAS,CAAO,QAAyB;QACxC,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,aAAa,CAAI,QAA4B;QAC5C,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,OAAO,CAAI,QAAsB;QAChC,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,IAAI,CAAI,QAAmB;QAC1B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,KAAK,CAAI,QAAoB;QAC5B,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,YAAY,CAAI,QAA2B;QAC1C,OAAO,QAAa,CAAA;IACrB,CAAC;IACD;;;;OAIG;IACH,MAAM,CAAI,QAAqB;QAC9B,OAAO,QAAa,CAAA;IACrB,CAAC;CACD,CAAA"}

package/cjs/tuple/tuple_type.d.ts

@@ -0,0 +1,67 @@
+import type { IsNever } from '../never/never_type.js';
+/**
+ * Check if `T` is a tuple and not an array.
+ *
+ * ```ts
+ * import type { TupleType } from 'type-plus'
+ *
+ * type R = TupleType<[]>       // []
+ * type R = TupleType<[1]>      // [1]
+ *
+ * type R = TupleType<number[]> // never
+ * type R = TupleType<string>   // never
+ * type R = TupleType<never>    // never
+ * type R = TupleType<unknown>  // never
+ * ```
+ */
+export type TupleType<T, Then = T, Else = never> = IsNever<T, Else, [
+    T
+] extends [any[]] ? (number extends T['length'] ? Else : Then) : Else>;
+/**
+ * Check if `T` is not a tuple.
+ *
+ * ```ts
+ * import type { NotTupleType } from 'type-plus'
+ *
+ * type R = NotTupleType<[]>       // never
+ * type R = NotTupleType<[1]>      // never
+ *
+ * type R = NotTupleType<number[]> // number[]
+ * type R = NotTupleType<string>   // string
+ * type R = NotTupleType<never>    // never
+ * type R = NotTupleType<unknown>  // unknown
+ * ```
+ */
+export type NotTupleType<T, Then = T, Else = never> = TupleType<T, Else, Then>;
+/**
+ * Is `T` a tuple and not an array.
+ *
+ * ```ts
+ * import type { IsTuple } from 'type-plus'
+ *
+ * type R = IsTuple<[]>       // true
+ *
+ * type R = IsTuple<number[]> // false
+ * type R = IsTuple<string>   // false
+ * type R = IsTuple<never>    // false
+ * type R = IsTuple<unknown>  // false
+ * ```
+ */
+export type IsTuple<T, Then = true, Else = false> = TupleType<T, Then, Else>;
+/**
+ * Is `T` not a tuple.
+ *
+ * ```ts
+ * import type { IsNotTuple } from 'type-plus'
+ *
+ * type R = IsNotTuple<[]>       // false
+ * type R = IsNotTuple<[1]>      // false
+ *
+ * type R = IsNotTuple<number[]> // false
+ * type R = IsNotTuple<string>   // false
+ * type R = IsNotTuple<never>    // false
+ * type R = IsNotTuple<unknown>  // false
+ * ```
+ */
+export type IsNotTuple<T, Then = true, Else = false> = TupleType<T, Else, Then>;
+//# sourceMappingURL=tuple_type.d.ts.map

package/cjs/tuple/tuple_type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple_type.d.ts","sourceRoot":"","sources":["../../ts/tuple/tuple_type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAErD;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,OAAO,CACzD,CAAC,EACD,IAAI,EACJ;IAAC,CAAC;CAAC,SAAS,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,GAAG,IAAI,CACvE,CAAA;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE9E;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA;AAE5E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,IAAI,GAAG,IAAI,EAAE,IAAI,GAAG,KAAK,IAAI,SAAS,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAAA"}

package/cjs/tuple/tuple_type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=tuple_type.js.map

package/cjs/tuple/tuple_type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tuple_type.js","sourceRoot":"","sources":["../../ts/tuple/tuple_type.ts"],"names":[],"mappings":""}