@jakubmazanec/ts-utils 2.1.0-c5ebb6f → 2.1.0-dee6883

package/dist/types/DeepPartial.d.ts

@@ -32,27 +32,27 @@ import type { Primitive } from './Primitive.js';
  */
 export type DeepPartial<T> = T extends Date | Primitive | RegExp ? T : T extends Map<infer KeyType, infer ValueType> ? DeepPartialMap<KeyType, ValueType> : T extends Set<infer ItemType> ? DeepPartialSet<ItemType> : T extends ReadonlyMap<infer KeyType, infer ValueType> ? DeepPartialReadonlyMap<KeyType, ValueType> : T extends ReadonlySet<infer ItemType> ? DeepPartialReadonlySet<ItemType> : T extends (...args: any[]) => unknown ? T | undefined : T extends object ? T extends Array<infer I> ? I[] extends T ? Array<DeepPartial<I | undefined>> : DeepPartialObject<T> : DeepPartialObject<T> : unknown;
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialMap<KeyType, ValueType> extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {
 }
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialSet<T> extends Set<DeepPartial<T>> {
 }
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialReadonlyMap<KeyType, ValueType> extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {
 }
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {
 }
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 type DeepPartialObject<ObjectType extends object> = {
     [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;

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 {@linkcode DeepPartial}.\n */\ninterface DeepPartialMap<KeyType, ValueType>\n  extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ninterface DeepPartialSet<T> extends Set<DeepPartial<T>> {}\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ninterface DeepPartialReadonlyMap<KeyType, ValueType>\n  extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {}\n\n/**\n * Helper type for {@linkcode DeepPartial}.\n */\ninterface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {}\n\n/**\n * Helper type for {@linkcode 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,GAEtG,WAgFE"}

package/dist/types/DeepReadonly.d.ts

@@ -18,15 +18,15 @@ import type { Primitive } from './Primitive.js';
  */
 export type DeepReadonly<T> = T extends Primitive | ((...args: any[]) => unknown) ? T : T extends ReadonlyMap<infer K, infer V> ? DeepReadonlyMap<K, V> : T extends ReadonlySet<infer I> ? DeepReadonlySet<I> : T extends object ? DeepReadonlyObject<T> : unknown;
 /**
- * Helper type for {@linkcode DeepReadonly}.
+ * Helper type for {@link DeepReadonly}.
  */
 type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
 /**
- * Helper type for {@linkcode DeepReadonly}.
+ * Helper type for {@link DeepReadonly}.
  */
 type DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;
 /**
- * Helper type for {@linkcode DeepReadonly}.
+ * Helper type for {@link DeepReadonly}.
  */
 type DeepReadonlyObject<O extends object> = {
     readonly [K in keyof O]: DeepReadonly<O[K]>;

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 {@linkcode DeepReadonly}.\n */\ntype DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;\n\n/**\n * Helper type for {@linkcode DeepReadonly}.\n */\ntype DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;\n\n/**\n * Helper type for {@linkcode 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,GAE/D,WA4CE"}

package/dist/types/UnionToIntersection.d.ts

@@ -9,7 +9,7 @@
  */
 export type UnionToIntersection<U> = boolean extends U ? UnionToIntersectionHelper<Exclude<U, boolean>> & boolean : UnionToIntersectionHelper<U>;
 /**
- * Helper type for {@linkcode UnionToIntersection}.
+ * Helper type for {@link UnionToIntersection}.
  */
 type UnionToIntersectionHelper<U> = (U extends unknown ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 export {};

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 {@linkcode 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,WAWU"}

package/dist/types/Writable.d.ts

@@ -1,5 +1,5 @@
 /**
- * Create a new type that removes `readonly` from object types's keys. Inverse of {@linkcode Readonly<T>}.
+ * Create a new type that removes `readonly` from object types's keys. Inverse of {@link Readonly<T>}.
  */
 export type Writable<T> = {
     -readonly [K in keyof T]: T[K];

package/dist/types/Writable.js

@@ -1,5 +1,5 @@
 /**
- * Create a new type that removes `readonly` from object types's keys. Inverse of {@linkcode Readonly<T>}.
+ * Create a new type that removes `readonly` from object types's keys. Inverse of {@link Readonly<T>}.
  */ export { };
 
 //# sourceMappingURL=Writable.js.map

package/dist/types/Writable.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/Writable.ts"],"sourcesContent":["/**\n * Create a new type that removes `readonly` from object types's keys. Inverse of {@linkcode Readonly<T>}.\n */\nexport type Writable<T> = {\n  -readonly [K in keyof T]: T[K];\n};\n"],"names":[],"mappings":"AAAA;;CAEC,GACD,WAEE"}
+{"version":3,"sources":["../../src/types/Writable.ts"],"sourcesContent":["/**\n * Create a new type that removes `readonly` from object types's keys. Inverse of {@link Readonly<T>}.\n */\nexport type Writable<T> = {\n  -readonly [K in keyof T]: T[K];\n};\n"],"names":[],"mappings":"AAAA;;CAEC,GACD,WAEE"}

package/dist/utils/assert.d.ts

@@ -8,7 +8,7 @@ export declare class AssertionError extends Error {
     constructor(message?: string);
 }
 /**
- * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if
+ * A function that throws {@link AssertionError} (with optional message defined with `errorMessage`) if
  * `condition` is falsy.
  * You can use it to narrow types:
  *

package/dist/utils/assert.js

@@ -9,7 +9,7 @@
     }
 }
 /**
- * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if
+ * A function that throws {@link AssertionError} (with optional message defined with `errorMessage`) if
  * `condition` is falsy.
  * You can use it to narrow types:
  *

package/dist/utils/assert.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/assert.ts"],"sourcesContent":["/**\n * A subclass of `Error` that indicates an assertion  failure.\n */\nexport class AssertionError extends Error {\n  /**\n   * @param message Message added to the default error message\n   */\n  constructor(message?: string) {\n    super(`Wrong assertion encountered${message ? `: \"${message}\"` : ''}!`);\n\n    this.name = 'AssertionError';\n  }\n}\n\n/**\n * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if\n * `condition` is falsy.\n * You can use it to narrow types:\n *\n * ```TypeScript\n * interface Foo {\n *   kind: 'Foo';\n * }\n *\n * interface Bar {\n *   kind: 'Bar';\n * }\n *\n * declare const foobar: Foo | Bar;\n *\n * assert(is<Foo>(foobar, foobar.kind === 'Foo'));\n *\n * // `typeof foobar` is now `Foo`\n * ```\n *\n * @param condition Condition we're asserting isn't falsy\n * @param errorMessage Message for the `AssertionError`\n */\nexport function assert(condition: unknown, errorMessage?: string): asserts condition {\n  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we don't mind here\n  if (!condition) {\n    throw new AssertionError(errorMessage);\n  }\n}\n"],"names":["AssertionError","Error","constructor","message","name","assert","condition","errorMessage"],"mappings":"AAAA;;CAEC,GACD,OAAO,MAAMA,uBAAuBC;IAClC;;GAEC,GACDC,YAAYC,OAAgB,CAAE;QAC5B,KAAK,CAAC,CAAC,2BAA2B,EAAEA,UAAU,CAAC,GAAG,EAAEA,QAAQ,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;QAEtE,IAAI,CAACC,IAAI,GAAG;IACd;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASC,OAAOC,SAAkB,EAAEC,YAAqB;IAC9D,+FAA+F;IAC/F,IAAI,CAACD,WAAW;QACd,MAAM,IAAIN,eAAeO;IAC3B;AACF"}
+{"version":3,"sources":["../../src/utils/assert.ts"],"sourcesContent":["/**\n * A subclass of `Error` that indicates an assertion  failure.\n */\nexport class AssertionError extends Error {\n  /**\n   * @param message Message added to the default error message\n   */\n  constructor(message?: string) {\n    super(`Wrong assertion encountered${message ? `: \"${message}\"` : ''}!`);\n\n    this.name = 'AssertionError';\n  }\n}\n\n/**\n * A function that throws {@link AssertionError} (with optional message defined with `errorMessage`) if\n * `condition` is falsy.\n * You can use it to narrow types:\n *\n * ```TypeScript\n * interface Foo {\n *   kind: 'Foo';\n * }\n *\n * interface Bar {\n *   kind: 'Bar';\n * }\n *\n * declare const foobar: Foo | Bar;\n *\n * assert(is<Foo>(foobar, foobar.kind === 'Foo'));\n *\n * // `typeof foobar` is now `Foo`\n * ```\n *\n * @param condition Condition we're asserting isn't falsy\n * @param errorMessage Message for the `AssertionError`\n */\nexport function assert(condition: unknown, errorMessage?: string): asserts condition {\n  // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions -- we don't mind here\n  if (!condition) {\n    throw new AssertionError(errorMessage);\n  }\n}\n"],"names":["AssertionError","Error","constructor","message","name","assert","condition","errorMessage"],"mappings":"AAAA;;CAEC,GACD,OAAO,MAAMA,uBAAuBC;IAClC;;GAEC,GACDC,YAAYC,OAAgB,CAAE;QAC5B,KAAK,CAAC,CAAC,2BAA2B,EAAEA,UAAU,CAAC,GAAG,EAAEA,QAAQ,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC;QAEtE,IAAI,CAACC,IAAI,GAAG;IACd;AACF;AAEA;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASC,OAAOC,SAAkB,EAAEC,YAAqB;IAC9D,+FAA+F;IAC/F,IAAI,CAACD,WAAW;QACd,MAAM,IAAIN,eAAeO;IAC3B;AACF"}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@jakubmazanec/ts-utils",
-  "version": "2.1.0-c5ebb6f",
+  "version": "2.1.0-dee6883",
   "description": "Collection of TypeScript types and utilities.",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jakubmazanec/js-tools",
+    "url": "git@github.com:jakubmazanec/js-tools.git",
     "directory": "packages/ts-utils"
   },
   "license": "LGPL-3.0-only",

package/src/types/DeepPartial.ts

@@ -54,29 +54,29 @@ export type DeepPartial<T> = T extends Date | Primitive | RegExp
   : unknown;
 
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialMap<KeyType, ValueType>
   extends Map<DeepPartial<KeyType>, DeepPartial<ValueType>> {}
 
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialSet<T> extends Set<DeepPartial<T>> {}
 
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialReadonlyMap<KeyType, ValueType>
   extends ReadonlyMap<DeepPartial<KeyType>, DeepPartial<ValueType>> {}
 
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 interface DeepPartialReadonlySet<T> extends ReadonlySet<DeepPartial<T>> {}
 
 /**
- * Helper type for {@linkcode DeepPartial}.
+ * Helper type for {@link DeepPartial}.
  */
 type DeepPartialObject<ObjectType extends object> = {
   [KeyType in keyof ObjectType]?: DeepPartial<ObjectType[KeyType]>;

package/src/types/DeepReadonly.ts

@@ -30,17 +30,17 @@ export type DeepReadonly<T> = T extends Primitive | ((...args: any[]) => unknown
   : unknown;
 
 /**
- * Helper type for {@linkcode DeepReadonly}.
+ * Helper type for {@link DeepReadonly}.
  */
 type DeepReadonlyMap<K, V> = ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>;
 
 /**
- * Helper type for {@linkcode DeepReadonly}.
+ * Helper type for {@link DeepReadonly}.
  */
 type DeepReadonlySet<I> = ReadonlySet<DeepReadonly<I>>;
 
 /**
- * Helper type for {@linkcode DeepReadonly}.
+ * Helper type for {@link DeepReadonly}.
  */
 type DeepReadonlyObject<O extends object> = {
   readonly [K in keyof O]: DeepReadonly<O[K]>;

package/src/types/UnionToIntersection.ts

@@ -12,7 +12,7 @@ export type UnionToIntersection<U> = boolean extends U
   : UnionToIntersectionHelper<U>;
 
 /**
- * Helper type for {@linkcode UnionToIntersection}.
+ * Helper type for {@link UnionToIntersection}.
  */
 type UnionToIntersectionHelper<U> = (U extends unknown ? (k: U) => void : never) extends (
   k: infer I,

package/src/types/Writable.ts

@@ -1,5 +1,5 @@
 /**
- * Create a new type that removes `readonly` from object types's keys. Inverse of {@linkcode Readonly<T>}.
+ * Create a new type that removes `readonly` from object types's keys. Inverse of {@link Readonly<T>}.
  */
 export type Writable<T> = {
   -readonly [K in keyof T]: T[K];

package/src/utils/assert.ts

@@ -13,7 +13,7 @@ export class AssertionError extends Error {
 }
 
 /**
- * A function that throws {@linkcode AssertionError} (with optional message defined with `errorMessage`) if
+ * A function that throws {@link AssertionError} (with optional message defined with `errorMessage`) if
  * `condition` is falsy.
  * You can use it to narrow types:
  *