@jakubmazanec/ts-utils 2.0.0-next.838299b → 2.1.0-9029e49

package/README.md

@@ -2,7 +2,7 @@
 
 # @jakubmazanec/ts-utils
 
-Collection of TypeScript types and utilities.
+<!-- description -->Collection of TypeScript types and utilities.<!-- description -->
 
 </div>
 

package/dist/types/IsEqual.d.ts

@@ -9,18 +9,7 @@
  * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`
  * ```
  *
- * @typeParam A1 First type to compare
- * @typeParam A2 Second type to compare
+ * @typeParam T First type to compare
+ * @typeParam U Second type to compare
  */
-export type IsEqual<A1, A2> = IsStrictlyEqual<Unite<A1>, Unite<A2>>;
-/**
- * Helper type for {@linkcode IsEqual}.
- */
-type IsStrictlyEqual<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1 ? true : false ? true : false;
-/**
- * Helper type for {@linkcode IsEqual}.
- */
-type Unite<T> = T extends Record<string, unknown> ? {
-    [K in keyof T]: T[K];
-} : T;
-export {};
+export type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2 ? true : false;

package/dist/types/IsEqual.js

@@ -9,8 +9,8 @@
  * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`
  * ```
  *
- * @typeParam A1 First type to compare
- * @typeParam A2 Second type to compare
+ * @typeParam T First type to compare
+ * @typeParam U Second type to compare
  */ export { };
 
 //# sourceMappingURL=IsEqual.js.map

package/dist/types/IsEqual.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/IsEqual.ts"],"sourcesContent":["/**\n * Allows you to test if two types are the same:\n *\n * ```TypeScript\n * type Result = IsEqual<string, number> // `typeof Result` is `false`\n * ```\n *\n * ```TypeScript\n * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`\n * ```\n *\n * @typeParam A1 First type to compare\n * @typeParam A2 Second type to compare\n */\nexport type IsEqual<A1, A2> = IsStrictlyEqual<Unite<A1>, Unite<A2>>;\n\n/**\n * Helper type for {@linkcode IsEqual}.\n */\ntype IsStrictlyEqual<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1\n  ? true\n  : false\n  ? true\n  : false;\n\n/**\n * Helper type for {@linkcode IsEqual}.\n */\ntype Unite<T> = T extends Record<string, unknown> ? {[K in keyof T]: T[K]} : T;\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;CAaC,GACD,WAc+E"}
+{"version":3,"sources":["../../src/types/IsEqual.ts"],"sourcesContent":["/**\n * Allows you to test if two types are the same:\n *\n * ```TypeScript\n * type Result = IsEqual<string, number> // `typeof Result` is `false`\n * ```\n *\n * ```TypeScript\n * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`\n * ```\n *\n * @typeParam T First type to compare\n * @typeParam U Second type to compare\n */\nexport type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2\n  ? true\n  : false;\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;CAaC,GACD,WAEU"}

package/dist/types/Simplify.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Maps all keys of type `T` to a new object type. Useful for converting interfaces to types or showing better hints from the language server.
+ *
+ * @typeParam T Base for the new type.
+ */
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+};

package/dist/types/Simplify.js

@@ -0,0 +1,7 @@
+/**
+ * Maps all keys of type `T` to a new object type. Useful for converting interfaces to types or showing better hints from the language server.
+ *
+ * @typeParam T Base for the new type.
+ */ export { };
+
+//# sourceMappingURL=Simplify.js.map

package/dist/types/Simplify.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/types/Simplify.ts"],"sourcesContent":["/**\n * Maps all keys of type `T` to a new object type. Useful for converting interfaces to types or showing better hints from the language server.\n *\n * @typeParam T Base for the new type.\n */\nexport type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};\n"],"names":[],"mappings":"AAAA;;;;CAIC,GACD,WAA6D"}

package/dist/types/TupleToUnion.d.ts

@@ -5,6 +5,6 @@
  * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `"foo" | "bar"`
  * ```
  *
- * @typeParam T Base for the new type
+ * @typeParam T Base for the new type.
  */
 export type TupleToUnion<T extends unknown[] | readonly unknown[]> = T[number];

package/dist/types/TupleToUnion.js

@@ -5,7 +5,7 @@
  * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `"foo" | "bar"`
  * ```
  *
- * @typeParam T Base for the new type
+ * @typeParam T Base for the new type.
  */ export { };
 
 //# sourceMappingURL=TupleToUnion.js.map

package/dist/types/TupleToUnion.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/TupleToUnion.ts"],"sourcesContent":["/**\n * Converts tuple type to union type:\n *\n * ```TypeScript\n * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `\"foo\" | \"bar\"`\n * ```\n *\n * @typeParam T Base for the new type\n */\nexport type TupleToUnion<T extends unknown[] | readonly unknown[]> = T[number];\n"],"names":[],"mappings":"AAAA;;;;;;;;CAQC,GACD,WAA+E"}
+{"version":3,"sources":["../../src/types/TupleToUnion.ts"],"sourcesContent":["/**\n * Converts tuple type to union type:\n *\n * ```TypeScript\n * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `\"foo\" | \"bar\"`\n * ```\n *\n * @typeParam T Base for the new type.\n */\nexport type TupleToUnion<T extends unknown[] | readonly unknown[]> = T[number];\n"],"names":[],"mappings":"AAAA;;;;;;;;CAQC,GACD,WAA+E"}

package/dist/types/Writable.d.ts

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

package/dist/types/Writable.js

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

package/dist/types/Writable.js.map

@@ -0,0 +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"}

package/dist/types.d.ts

@@ -11,5 +11,7 @@ export * from './types/Parameters.js';
 export * from './types/Primitive.js';
 export * from './types/RequiredKeys.js';
 export * from './types/ReturnType.js';
+export * from './types/Simplify.js';
 export * from './types/TupleToUnion.js';
 export * from './types/UnionToIntersection.js';
+export * from './types/Writable.js';

package/dist/types.js

@@ -11,7 +11,9 @@ export * from './types/Parameters.js';
 export * from './types/Primitive.js';
 export * from './types/RequiredKeys.js';
 export * from './types/ReturnType.js';
+export * from './types/Simplify.js';
 export * from './types/TupleToUnion.js';
 export * from './types/UnionToIntersection.js';
+export * from './types/Writable.js';
 
 //# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/types.ts"],"sourcesContent":["export * from './types/AtLeastOneRequired.js';\nexport * from './types/DeepPartial.js';\nexport * from './types/DeepReadonly.js';\nexport * from './types/If.js';\nexport * from './types/IsEqual.js';\nexport * from './types/LiteralUnion.js';\nexport * from './types/NonArray.js';\nexport * from './types/NonArrayLike.js';\nexport * from './types/OptionalKeys.js';\nexport * from './types/Parameters.js';\nexport * from './types/Primitive.js';\nexport * from './types/RequiredKeys.js';\nexport * from './types/ReturnType.js';\nexport * from './types/TupleToUnion.js';\nexport * from './types/UnionToIntersection.js';\n"],"names":[],"mappings":"AAAA,cAAc,gCAAgC;AAC9C,cAAc,yBAAyB;AACvC,cAAc,0BAA0B;AACxC,cAAc,gBAAgB;AAC9B,cAAc,qBAAqB;AACnC,cAAc,0BAA0B;AACxC,cAAc,sBAAsB;AACpC,cAAc,0BAA0B;AACxC,cAAc,0BAA0B;AACxC,cAAc,wBAAwB;AACtC,cAAc,uBAAuB;AACrC,cAAc,0BAA0B;AACxC,cAAc,wBAAwB;AACtC,cAAc,0BAA0B;AACxC,cAAc,iCAAiC"}
+{"version":3,"sources":["../src/types.ts"],"sourcesContent":["export * from './types/AtLeastOneRequired.js';\nexport * from './types/DeepPartial.js';\nexport * from './types/DeepReadonly.js';\nexport * from './types/If.js';\nexport * from './types/IsEqual.js';\nexport * from './types/LiteralUnion.js';\nexport * from './types/NonArray.js';\nexport * from './types/NonArrayLike.js';\nexport * from './types/OptionalKeys.js';\nexport * from './types/Parameters.js';\nexport * from './types/Primitive.js';\nexport * from './types/RequiredKeys.js';\nexport * from './types/ReturnType.js';\nexport * from './types/Simplify.js';\nexport * from './types/TupleToUnion.js';\nexport * from './types/UnionToIntersection.js';\nexport * from './types/Writable.js';\n"],"names":[],"mappings":"AAAA,cAAc,gCAAgC;AAC9C,cAAc,yBAAyB;AACvC,cAAc,0BAA0B;AACxC,cAAc,gBAAgB;AAC9B,cAAc,qBAAqB;AACnC,cAAc,0BAA0B;AACxC,cAAc,sBAAsB;AACpC,cAAc,0BAA0B;AACxC,cAAc,0BAA0B;AACxC,cAAc,wBAAwB;AACtC,cAAc,uBAAuB;AACrC,cAAc,0BAA0B;AACxC,cAAc,wBAAwB;AACtC,cAAc,sBAAsB;AACpC,cAAc,0BAA0B;AACxC,cAAc,iCAAiC;AAC/C,cAAc,sBAAsB"}

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,EAAE,CAAC,CAAC,CAAC;QAEtE,IAAI,CAACC,IAAI,GAAG;IACd;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;CAuBC,GACD,OAAO,SAASC,OAAOC,SAAkB,EAAEC,YAAqB,EAAqB;IACnF,+FAA+F;IAC/F,IAAI,CAACD,WAAW;QACd,MAAM,IAAIN,eAAeO,cAAc;IACzC,CAAC;AACH,CAAC"}
+{"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,OAAO;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/dist/utils/is.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/is.ts"],"sourcesContent":["/**\n * A generic type guard. If `isMatched` is `true`, TypeScript assumes `value` is of type `T`.\n * You can use it to narrow types:\n *\n * ```TypeScript\n * interface Foo {\n *   value: string;\n * }\n *\n * interface Bar {\n *   value: number;\n * }\n *\n * declare let foobar: Foo | Bar;\n *\n * if (is<Foo>(foobar, typeof foobar.value === 'string')) {\n *   // `typeof foobar` is now `Foo`\n * } else {\n *   // `typeof foobar` is now `Bar`\n * }\n * ```\n *\n * @typeParam T Potential type of `value`\n * @param value Value being checked\n * @param isMatched Specifies if `value` is of type `T`\n * @return Value of `isMatched`\n */\nexport function is<T>(value: unknown, isMatched: boolean): value is T {\n  return isMatched;\n}\n"],"names":["is","value","isMatched"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,GACD,OAAO,SAASA,GAAMC,KAAc,EAAEC,SAAkB,EAAc;IACpE,OAAOA;AACT,CAAC"}
+{"version":3,"sources":["../../src/utils/is.ts"],"sourcesContent":["/**\n * A generic type guard. If `isMatched` is `true`, TypeScript assumes `value` is of type `T`.\n * You can use it to narrow types:\n *\n * ```TypeScript\n * interface Foo {\n *   value: string;\n * }\n *\n * interface Bar {\n *   value: number;\n * }\n *\n * declare let foobar: Foo | Bar;\n *\n * if (is<Foo>(foobar, typeof foobar.value === 'string')) {\n *   // `typeof foobar` is now `Foo`\n * } else {\n *   // `typeof foobar` is now `Bar`\n * }\n * ```\n *\n * @typeParam T Potential type of `value`\n * @param value Value being checked\n * @param isMatched Specifies if `value` is of type `T`\n * @return Value of `isMatched`\n */\nexport function is<T>(value: unknown, isMatched: boolean): value is T {\n  return isMatched;\n}\n"],"names":["is","value","isMatched"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,GACD,OAAO,SAASA,GAAMC,KAAc,EAAEC,SAAkB;IACtD,OAAOA;AACT"}

package/dist/utils/isNonNullable.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/utils/isNonNullable.ts"],"sourcesContent":["/**\n * A type guard that checks whether variable is not `null` or `undefined`:\n *\n * ```TypeScript\n * declare let foobar: string | null;\n *\n * if (isNonNullable(foobar)) {\n *   // `typeof foobar` is now `string`\n * } else {\n *   // `typeof foobar` is now `null`\n * }\n * ```\n *\n * @typeParam T Type of `value`\n * @param value Value being checked\n * @return `true` if `value` is non-nullable\n */\nexport function isNonNullable<T>(value: T): value is NonNullable<T> {\n  return value !== undefined && value !== null;\n}\n"],"names":["isNonNullable","value","undefined"],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASA,cAAiBC,KAAQ,EAA2B;IAClE,OAAOA,UAAUC,aAAaD,UAAU,IAAI;AAC9C,CAAC"}
+{"version":3,"sources":["../../src/utils/isNonNullable.ts"],"sourcesContent":["/**\n * A type guard that checks whether variable is not `null` or `undefined`:\n *\n * ```TypeScript\n * declare let foobar: string | null;\n *\n * if (isNonNullable(foobar)) {\n *   // `typeof foobar` is now `string`\n * } else {\n *   // `typeof foobar` is now `null`\n * }\n * ```\n *\n * @typeParam T Type of `value`\n * @param value Value being checked\n * @return `true` if `value` is non-nullable\n */\nexport function isNonNullable<T>(value: T): value is NonNullable<T> {\n  return value !== undefined && value !== null;\n}\n"],"names":["isNonNullable","value","undefined"],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASA,cAAiBC,KAAQ;IACvC,OAAOA,UAAUC,aAAaD,UAAU;AAC1C"}

package/dist/utils/tuple.d.ts

@@ -0,0 +1,2 @@
+import { type Primitive } from '../types.js';
+export declare function tuple<T extends Array<Primitive | {}>>(...values: T): T;

package/dist/utils/tuple.js

@@ -0,0 +1,6 @@
+// eslint-disable-next-line @typescript-eslint/ban-types -- this is intended
+export function tuple(...values) {
+    return values;
+}
+
+//# sourceMappingURL=tuple.js.map

package/dist/utils/tuple.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/tuple.ts"],"sourcesContent":["import {type Primitive} from '../types.js';\n\n// eslint-disable-next-line @typescript-eslint/ban-types -- this is intended\nexport function tuple<T extends Array<Primitive | {}>>(...values: T) {\n  return values;\n}\n"],"names":["tuple","values"],"mappings":"AAEA,4EAA4E;AAC5E,OAAO,SAASA,MAAuC,GAAGC,MAAS;IACjE,OAAOA;AACT"}

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
 export * from './utils/assert.js';
 export * from './utils/is.js';
 export * from './utils/isNonNullable.js';
+export * from './utils/tuple.js';

package/dist/utils.js

@@ -1,5 +1,6 @@
 export * from './utils/assert.js';
 export * from './utils/is.js';
 export * from './utils/isNonNullable.js';
+export * from './utils/tuple.js';
 
 //# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["export * from './utils/assert.js';\nexport * from './utils/is.js';\nexport * from './utils/isNonNullable.js';\n"],"names":[],"mappings":"AAAA,cAAc,oBAAoB;AAClC,cAAc,gBAAgB;AAC9B,cAAc,2BAA2B"}
+{"version":3,"sources":["../src/utils.ts"],"sourcesContent":["export * from './utils/assert.js';\nexport * from './utils/is.js';\nexport * from './utils/isNonNullable.js';\nexport * from './utils/tuple.js';\n"],"names":[],"mappings":"AAAA,cAAc,oBAAoB;AAClC,cAAc,gBAAgB;AAC9B,cAAc,2BAA2B;AACzC,cAAc,mBAAmB"}

package/package.json

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

package/src/types/IsEqual.ts

@@ -9,21 +9,9 @@
  * type Result = IsEqual<{foo: string}, {foo: string}> // `typeof Result` is `true`
  * ```
  *
- * @typeParam A1 First type to compare
- * @typeParam A2 Second type to compare
+ * @typeParam T First type to compare
+ * @typeParam U Second type to compare
  */
-export type IsEqual<A1, A2> = IsStrictlyEqual<Unite<A1>, Unite<A2>>;
-
-/**
- * Helper type for {@linkcode IsEqual}.
- */
-type IsStrictlyEqual<A1, A2> = (<A>() => A extends A2 ? true : false) extends <A>() => A extends A1
-  ? true
-  : false
+export type IsEqual<T, U> = (<G>() => G extends T ? 1 : 2) extends <G>() => G extends U ? 1 : 2
   ? true
   : false;
-
-/**
- * Helper type for {@linkcode IsEqual}.
- */
-type Unite<T> = T extends Record<string, unknown> ? {[K in keyof T]: T[K]} : T;

package/src/types/Simplify.ts

@@ -0,0 +1,6 @@
+/**
+ * Maps all keys of type `T` to a new object type. Useful for converting interfaces to types or showing better hints from the language server.
+ *
+ * @typeParam T Base for the new type.
+ */
+export type Simplify<T> = {[KeyType in keyof T]: T[KeyType]};

package/src/types/TupleToUnion.ts

@@ -5,6 +5,6 @@
  * type Result = TupleToUnion<['foo', 'bar']>; // `typeof Result` is `"foo" | "bar"`
  * ```
  *
- * @typeParam T Base for the new type
+ * @typeParam T Base for the new type.
  */
 export type TupleToUnion<T extends unknown[] | readonly unknown[]> = T[number];

package/src/types/Writable.ts

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

package/src/types.ts

@@ -11,5 +11,7 @@ export * from './types/Parameters.js';
 export * from './types/Primitive.js';
 export * from './types/RequiredKeys.js';
 export * from './types/ReturnType.js';
+export * from './types/Simplify.js';
 export * from './types/TupleToUnion.js';
 export * from './types/UnionToIntersection.js';
+export * from './types/Writable.js';

package/src/utils/tuple.ts

@@ -0,0 +1,6 @@
+import {type Primitive} from '../types.js';
+
+// eslint-disable-next-line @typescript-eslint/ban-types -- this is intended
+export function tuple<T extends Array<Primitive | {}>>(...values: T) {
+  return values;
+}

package/src/utils.ts

@@ -1,3 +1,4 @@
 export * from './utils/assert.js';
 export * from './utils/is.js';
 export * from './utils/isNonNullable.js';
+export * from './utils/tuple.js';