@jakubmazanec/ts-utils 2.1.2 → 3.0.0-next.7305494

package/README.md

@@ -19,7 +19,7 @@ It cannot be required from a CommonJS module.
 
 #### Prerequisites
 
-- Node.js 16 or later
+- Node.js 20 or later
 - TypeScript 5 or later
 
 ## Usage

package/dist/types/DeepPartial.js

@@ -1,3 +1,33 @@
-/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-interface -- needed */ export { };
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-interface -- needed */ /**
+ * Same as built-in `Partial`, but works recursively. Useful when 1) you have a config object to which you need to merge another object, which would be a deep partial of a default object, or 2) you need to test or mock complex object, but most of its keys would be redundant for this purpose.
+ *
+ * ```TypeScript
+ * import { DeepPartial } from '@ori/ts-utils';
+ * import { UiSettings } from './UiSettings';
+ *
+ * let settings: UiSettings = {
+ *   lineNumbers: true,
+ *   scrollbar: {
+ *     useShadows: false,
+ *     vertical: 'visible',
+ *     horizontal: 'auto',
+ *   },
+ *   minimap: {
+ *     enabled: false,
+ *   },
+ *   folding: {
+ *     enabled: true,
+ *   },
+ * };
+ *
+ * function updateSettings(newSettings: DeepPartial<UiSettings>) {
+ *   return { ...settings, ...newSettings };
+ * }
+ *
+ * settings = updateSettings({ minimap: { enabled: true } });
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */ export { };
 
 //# sourceMappingURL=DeepPartial.js.map

package/dist/types/DeepPartial.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/DeepPartial.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-interface -- needed */\n\nimport type {Primitive} from './Primitive.js';\n\n/**\n * Same as built-in `Partial`, but works recursively. Useful when 1) you have a config object to which you need to merge another object, which would be a deep partial of a default object, or 2) you need to test or mock complex object, but most of its keys would be redundant for this purpose.\n *\n * ```TypeScript\n * import { DeepPartial } from '@ori/ts-utils';\n * import { UiSettings } from './UiSettings';\n *\n * let settings: UiSettings = {\n *   lineNumbers: true,\n *   scrollbar: {\n *     useShadows: false,\n *     vertical: 'visible',\n *     horizontal: 'auto',\n *   },\n *   minimap: {\n *     enabled: false,\n *   },\n *   folding: {\n *     enabled: true,\n *   },\n * };\n *\n * function updateSettings(newSettings: DeepPartial<UiSettings>) {\n *   return { ...settings, ...newSettings };\n * }\n *\n * settings = updateSettings({ minimap: { enabled: true } });\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type DeepPartial<T> = T extends Date | Primitive | RegExp\n  ? T\n  : T extends Map<infer KeyType, infer ValueType>\n  ? DeepPartialMap<KeyType, ValueType>\n  : T extends Set<infer ItemType>\n  ? DeepPartialSet<ItemType>\n  : T extends ReadonlyMap<infer KeyType, infer ValueType>\n  ? DeepPartialReadonlyMap<KeyType, ValueType>\n  : T extends ReadonlySet<infer ItemType>\n  ? DeepPartialReadonlySet<ItemType>\n  : T extends (...args: any[]) => unknown\n  ? T | undefined\n  : T extends object\n  ? T extends Array<infer I> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156\n    ? I[] extends T // Test for arrays (non-tuples) specifically\n      ? Array<DeepPartial<I | undefined>> // Recreate relevant array type to prevent eager evaluation of circular reference\n      : DeepPartialObject<T> // Tuples behave properly\n    : DeepPartialObject<T>\n  : unknown;\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialMap<KeyType, ValueType>\n  extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialSet<T> extends Set<DeepPartial<T>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialReadonlyMap<KeyType, ValueType>\n  extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ntype DeepPartialObject<ObjectType extends object> = {\n  [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;\n};\n"],"names":[],"mappings":"AAAA,sGAAsG,GAEtG,WAgFE"}
+{"version":3,"sources":["../../src/types/DeepPartial.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/no-empty-interface -- needed */\n\nimport type {Primitive} from './Primitive.js';\n\n/**\n * Same as built-in `Partial`, but works recursively. Useful when 1) you have a config object to which you need to merge another object, which would be a deep partial of a default object, or 2) you need to test or mock complex object, but most of its keys would be redundant for this purpose.\n *\n * ```TypeScript\n * import { DeepPartial } from '@ori/ts-utils';\n * import { UiSettings } from './UiSettings';\n *\n * let settings: UiSettings = {\n *   lineNumbers: true,\n *   scrollbar: {\n *     useShadows: false,\n *     vertical: 'visible',\n *     horizontal: 'auto',\n *   },\n *   minimap: {\n *     enabled: false,\n *   },\n *   folding: {\n *     enabled: true,\n *   },\n * };\n *\n * function updateSettings(newSettings: DeepPartial<UiSettings>) {\n *   return { ...settings, ...newSettings };\n * }\n *\n * settings = updateSettings({ minimap: { enabled: true } });\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type DeepPartial<T> = T extends Date | Primitive | RegExp\n  ? T\n  : T extends Map<infer KeyType, infer ValueType>\n  ? DeepPartialMap<KeyType, ValueType>\n  : T extends Set<infer ItemType>\n  ? DeepPartialSet<ItemType>\n  : T extends ReadonlyMap<infer KeyType, infer ValueType>\n  ? DeepPartialReadonlyMap<KeyType, ValueType>\n  : T extends ReadonlySet<infer ItemType>\n  ? DeepPartialReadonlySet<ItemType>\n  : T extends (...args: any[]) => unknown\n  ? T | undefined\n  : T extends object\n  ? T extends Array<infer I> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156\n    ? I[] extends T // Test for arrays (non-tuples) specifically\n      ? Array<DeepPartial<I | undefined>> // Recreate relevant array type to prevent eager evaluation of circular reference\n      : DeepPartialObject<T> // Tuples behave properly\n    : DeepPartialObject<T>\n  : unknown;\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialMap<KeyType, ValueType>\n  extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialSet<T> extends Set<DeepPartial<T>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialReadonlyMap<KeyType, ValueType>\n  extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ninterface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {}\n\n/**\n * Helper type for {@link DeepPartial}.\n */\ntype DeepPartialObject<ObjectType extends object> = {\n  [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;\n};\n"],"names":[],"mappings":"AAAA,sGAAsG,GAItG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BC,GACD,WAkBY"}

package/dist/types/DeepReadonly.js

@@ -1,3 +1,19 @@
-/* eslint-disable @typescript-eslint/no-explicit-any -- needed */ export { };
+/* eslint-disable @typescript-eslint/no-explicit-any -- needed */ /**
+ * Same as built-in `Readonly`, but works recursively:
+ *
+ * ```TypeScript
+ * import { DeepReadonly } from '@ori/ts-utils';
+ *
+ * const rawData = {
+ *   foo: ['bar'],
+ * };
+ *
+ * const data: DeepReadonly<typeof rawData> = rawData;
+ *
+ * data.foo.push('bar'); // error TS2339: Property 'push' does not exist on type 'readonly string[]'
+ * ```
+ *
+ * @typeParam T Base for the new type
+ */ export { };
 
 //# sourceMappingURL=DeepReadonly.js.map

package/dist/types/DeepReadonly.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/DeepReadonly.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- needed */\n\nimport type {Primitive} from './Primitive.js';\n\n/**\n * Same as built-in `Readonly`, but works recursively:\n *\n * ```TypeScript\n * import { DeepReadonly } from '@ori/ts-utils';\n *\n * const rawData = {\n *   foo: ['bar'],\n * };\n *\n * const data: DeepReadonly<typeof rawData> = rawData;\n *\n * data.foo.push('bar'); // error TS2339: Property 'push' does not exist on type 'readonly string[]'\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type DeepReadonly<T> = T extends Primitive | ((...args: any[]) => unknown)\n  ? T\n  : T extends ReadonlyMap<infer K, infer V>\n  ? DeepReadonlyMap<K, V>\n  : T extends ReadonlySet<infer I>\n  ? DeepReadonlySet<I>\n  : T extends object\n  ? DeepReadonlyObject<T>\n  : unknown;\n\n/**\n * Helper type for {@link DeepReadonly}.\n */\ntype DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;\n\n/**\n * Helper type for {@link DeepReadonly}.\n */\ntype DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;\n\n/**\n * Helper type for {@link DeepReadonly}.\n */\ntype DeepReadonlyObject<O extends object> = {\n  readonly [K in keyof O]: DeepReadonly<O[K]>;\n};\n"],"names":[],"mappings":"AAAA,+DAA+D,GAE/D,WA4CE"}
+{"version":3,"sources":["../../src/types/DeepReadonly.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any -- needed */\n\nimport type {Primitive} from './Primitive.js';\n\n/**\n * Same as built-in `Readonly`, but works recursively:\n *\n * ```TypeScript\n * import { DeepReadonly } from '@ori/ts-utils';\n *\n * const rawData = {\n *   foo: ['bar'],\n * };\n *\n * const data: DeepReadonly<typeof rawData> = rawData;\n *\n * data.foo.push('bar'); // error TS2339: Property 'push' does not exist on type 'readonly string[]'\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type DeepReadonly<T> = T extends Primitive | ((...args: any[]) => unknown)\n  ? T\n  : T extends ReadonlyMap<infer K, infer V>\n  ? DeepReadonlyMap<K, V>\n  : T extends ReadonlySet<infer I>\n  ? DeepReadonlySet<I>\n  : T extends object\n  ? DeepReadonlyObject<T>\n  : unknown;\n\n/**\n * Helper type for {@link DeepReadonly}.\n */\ntype DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;\n\n/**\n * Helper type for {@link DeepReadonly}.\n */\ntype DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;\n\n/**\n * Helper type for {@link DeepReadonly}.\n */\ntype DeepReadonlyObject<O extends object> = {\n  readonly [K in keyof O]: DeepReadonly<O[K]>;\n};\n"],"names":[],"mappings":"AAAA,+DAA+D,GAI/D;;;;;;;;;;;;;;;;CAgBC,GACD,WAQY"}

package/dist/types/LiteralUnion.js

@@ -1,3 +1,21 @@
-export { };
+/**
+ * Creates union type by combining primitve types and literal types while allowing auto-completion in IDEs.
+ * This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).
+ *
+ * ```TypeScript
+ * type Animal = 'cat' | 'dog' | string;
+ *
+ * const: animal: Animal = ''; // No auto-completion here...
+ * ```
+ *
+ * ```TypeScript
+ * type Animal = LiteralUnion<'cat' | 'dog', string>;
+ *
+ * const: animal: Animal = ''; // Auto-completion works: 'cat' and 'dog' is suggested!
+ * ```
+ *
+ * @typeParam L Union of literal types
+ * @typeParam T Primitive type
+ */ export { };
 
 //# sourceMappingURL=LiteralUnion.js.map

package/dist/types/LiteralUnion.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/LiteralUnion.ts"],"sourcesContent":["import type {Primitive} from './Primitive.js';\n\n/**\n * Creates union type by combining primitve types and literal types while allowing auto-completion in IDEs.\n * This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).\n *\n * ```TypeScript\n * type Animal = 'cat' | 'dog' | string;\n *\n * const: animal: Animal = ''; // No auto-completion here...\n * ```\n *\n * ```TypeScript\n * type Animal = LiteralUnion<'cat' | 'dog', string>;\n *\n * const: animal: Animal = ''; // Auto-completion works: 'cat' and 'dog' is suggested!\n * ```\n *\n * @typeParam L Union of literal types\n * @typeParam T Primitive type\n */\nexport type LiteralUnion<L, T extends Primitive> = L | (Record<never, never> & T);\n"],"names":[],"mappings":"AAAA,WAqBkF"}
+{"version":3,"sources":["../../src/types/LiteralUnion.ts"],"sourcesContent":["import type {Primitive} from './Primitive.js';\n\n/**\n * Creates union type by combining primitve types and literal types while allowing auto-completion in IDEs.\n * This type is a workaround for [Microsoft/TypeScript#29729](https://github.com/Microsoft/TypeScript/issues/29729).\n *\n * ```TypeScript\n * type Animal = 'cat' | 'dog' | string;\n *\n * const: animal: Animal = ''; // No auto-completion here...\n * ```\n *\n * ```TypeScript\n * type Animal = LiteralUnion<'cat' | 'dog', string>;\n *\n * const: animal: Animal = ''; // Auto-completion works: 'cat' and 'dog' is suggested!\n * ```\n *\n * @typeParam L Union of literal types\n * @typeParam T Primitive type\n */\nexport type LiteralUnion<L, T extends Primitive> = L | (Record<never, never> & T);\n"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;CAkBC,GACD,WAAkF"}

package/dist/types/UnionToIntersection.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/UnionToIntersection.ts"],"sourcesContent":["/**\n * Converts union type to intersection type:\n *\n * ```TypeScript\n * type Result = UnionToIntersection<{ foo: string } | { bar: string }>; // `typeof Result` is `{foo: string} & {bar: string}`\n * ```\n *\n * @typeParam U Base for the new type\n */\nexport type UnionToIntersection<U> = boolean extends U\n  ? UnionToIntersectionHelper<Exclude<U, boolean>> & boolean\n  : UnionToIntersectionHelper<U>;\n\n/**\n * Helper type for {@link UnionToIntersection}.\n */\ntype UnionToIntersectionHelper<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n"],"names":[],"mappings":"AAAA;;;;;;;;CAQC,GACD,WAWU"}
+{"version":3,"sources":["../../src/types/UnionToIntersection.ts"],"sourcesContent":["/**\n * Converts union type to intersection type:\n *\n * ```TypeScript\n * type Result = UnionToIntersection<{ foo: string } | { bar: string }>; // `typeof Result` is `{foo: string} & {bar: string}`\n * ```\n *\n * @typeParam U Base for the new type\n */\nexport type UnionToIntersection<U> = boolean extends U\n  ? UnionToIntersectionHelper<Exclude<U, boolean>> & boolean\n  : UnionToIntersectionHelper<U>;\n\n/**\n * Helper type for {@link UnionToIntersection}.\n */\ntype UnionToIntersectionHelper<U> = (U extends unknown ? (k: U) => void : never) extends (\n  k: infer I,\n) => void\n  ? I\n  : never;\n"],"names":[],"mappings":"AAAA;;;;;;;;CAQC,GACD,WAEiC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jakubmazanec/ts-utils",
-  "version": "2.1.2",
+  "version": "3.0.0-next.7305494",
   "description": "Collection of TypeScript types and utilities.",
   "repository": {
     "type": "git",
@@ -26,10 +26,11 @@
     "typecheck": "tsc --project tsconfig.typecheck.json"
   },
   "devDependencies": {
-    "@jest/globals": "^29.5.0"
+    "@jest/globals": "^29.5.0",
+    "@types/node": "^20.8.5"
   },
-  "packageManager": "npm@8.19.4",
+  "packageManager": "npm@10.1.0",
   "engines": {
-    "node": ">=16.20.0"
+    "node": "^20.8.0"
   }
 }