@arktype/util - npm Package Compare versions

Comparing version 0.0.23 to 0.0.24

__tests__/callable.test.ts

 import { attest } from "@arktype/attest"
-import { Callable, type conform, type Hkt } from "@arktype/util"
+import { Callable } from "@arktype/util"
 
@@ -4,0 +4,0 @@ describe("callable", () => {

__tests__/hkt.test.ts

 import { attest } from "@arktype/attest"
-import type { conform, Hkt } from "@arktype/util"
+import type { conform, Hkt, List } from "@arktype/util"
 
@@ -7,6 +7,3 @@ describe("hkt", () => {
 		f: (
-			args: conform<
-				this[Hkt.key],
-				readonly [element: unknown, to: readonly unknown[]]
-			>
+			args: conform<this[Hkt.key], readonly [element: unknown, to: List]>
 		) => [...(typeof args)[1], (typeof args)[0]]
@@ -19,3 +16,3 @@ }
 	it("reify", () => {
-		const append = (([element, to]: [unknown, readonly unknown[]]) => [
+		const append = (([element, to]: [unknown, List]) => [
 			...to,
@@ -22,0 +19,0 @@ element

__tests__/intersections.test.ts

 import { attest } from "@arktype/attest"
 import type {
-	initOf,
 	intersectArrays,
@@ -5,0 +4,0 @@ intersectParameters

__tests__/overloads.test.ts

 import { attest } from "@arktype/attest"
 import type { conform } from "../generics.js"
+import type { List } from "../lists.js"
 import type { overloadOf } from "../unionToTuple.js"
@@ -11,6 +12,3 @@
 
-const pipe = <
-	f extends (...args: any[]) => unknown,
-	args extends readonly unknown[]
->(
+const pipe = <f extends (...args: any[]) => unknown, args extends List>(
 	args: conform<args, Parameters<overloadOf<f>>>,
@@ -17,0 +15,0 @@ f: f

domain.ts

 import type { evaluate } from "./generics.js"
+import type { stringifyUnion } from "./unionToTuple.js"
 
@@ -65,1 +66,30 @@ export const hasDomain = <data, domain extends Domain>(
 }
+
+const enumerableDomainDescriptions = {
+	boolean: "boolean",
+	null: "null",
+	undefined: "undefined"
+} as const
+
+const nonEnumerableDomainDescriptions = {
+	bigint: "a bigint",
+	number: "a number",
+	object: "an object",
+	string: "a string",
+	symbol: "a symbol"
+} as const
+
+export type NonEnumerableDomain = keyof typeof nonEnumerableDomainDescriptions
+
+/** Each domain's completion for the phrase "Must be _____" */
+export const domainDescriptions = {
+	...nonEnumerableDomainDescriptions,
+	...enumerableDomainDescriptions
+} satisfies Record<Domain, string>
+
+export type domainDescriptions = typeof domainDescriptions
+
+export type describeDomainOf<t> = stringifyUnion<
+	domainDescriptions[domainOf<t>],
+	" or "
+>

functions.ts

 import { throwInternalError } from "./errors.js"
-import { CastableBase } from "./records.js"
 
@@ -4,0 +3,0 @@ export const cached = <T>(thunk: () => T) => {

intersections.ts

 import type { domainOf } from "./domain.js"
 import type { andPreserveUnknown, conform } from "./generics.js"
 import type { Hkt } from "./hkt.js"
-import type { headOf, lastOf } from "./lists.js"
+import type { List } from "./lists.js"
 import type { requiredKeyOf, valueOf } from "./records.js"
@@ -16,4 +16,4 @@
 export type intersectArrays<
-	l extends readonly unknown[],
-	r extends readonly unknown[],
+	l extends List,
+	r extends List,
 	operator extends Hkt.Kind = AndPreserveUnknown
@@ -23,4 +23,4 @@ > = intersectSequences<l, r, [], [], operator, "array">
 export type intersectParameters<
-	l extends readonly unknown[],
-	r extends readonly unknown[],
+	l extends List,
+	r extends List,
 	operator extends Hkt.Kind = AndPreserveUnknown
@@ -30,6 +30,6 @@ > = intersectSequences<l, r, [], [], operator, "parameters">
 type intersectSequences<
-	l extends readonly unknown[],
-	r extends readonly unknown[],
-	prefix extends readonly unknown[],
-	postfix extends readonly unknown[],
+	l extends List,
+	r extends List,
+	prefix extends List,
+	postfix extends List,
 	intersector extends Hkt.Kind,
@@ -104,3 +104,3 @@ kind extends SequenceIntersectionKind
 	optional: boolean
-	rest: readonly unknown[]
+	rest: List
 }
@@ -111,3 +111,3 @@
 type parseNextElement<
-	elements extends readonly unknown[],
+	elements extends List,
 	kind extends SequenceIntersectionKind
@@ -114,0 +114,0 @@ > = elements extends readonly []

lists.ts

 import type { isDisjoint } from "./intersections.js"
-import type { NumberLiteral } from "./numericLiterals.js"
+import type {
+	NumberLiteral,
+	parseNonNegativeInteger
+} from "./numericLiterals.js"
 
@@ -57,3 +60,3 @@ export type pathToString<
 export type filter<
-	t extends readonly unknown[],
+	t extends List,
 	constraint,
@@ -80,32 +83,24 @@ result extends unknown[] = []
 
-export type headOf<t extends readonly unknown[]> = t[0]
+export type headOf<t extends List> = t[0]
 
-export type tailOf<t extends readonly unknown[]> = t extends readonly [
-	unknown,
-	...infer tail
-]
+export type tailOf<t extends List> = t extends readonly [unknown, ...infer tail]
 	? tail
 	: never
 
-export type lastOf<t extends readonly unknown[]> = t extends readonly [
-	...unknown[],
-	infer last
-]
-	? last
-	: never
+export type lastIndexOf<t extends List> = tailOf<t>["length"]
 
-export type initOf<t extends readonly unknown[]> = t extends readonly [
-	...infer init,
-	unknown
-]
+export type lastOf<t extends List> = t[lastIndexOf<t>]
+
+export type initOf<t extends List> = t extends readonly [...infer init, unknown]
 	? init
 	: never
 
-export type numericStringKeyOf<t extends readonly unknown[]> = Extract<
-	keyof t,
-	NumberLiteral
->
+export type numericStringKeyOf<t extends List> = Extract<keyof t, NumberLiteral>
 
+export type indexOf<array extends List> = keyof array extends infer k
+	? parseNonNegativeInteger<k & string>
+	: never
+
 export const listFrom = <t>(data: t) =>
-	(Array.isArray(data) ? data : [data]) as t extends readonly unknown[]
+	(Array.isArray(data) ? data : [data]) as t extends List
 		? [t] extends [null]
@@ -139,3 +134,3 @@ ? // check for any/never
 
-export const includes = <array extends readonly unknown[]>(
+export const includes = <array extends List>(
 	array: array,
@@ -142,0 +137,0 @@ element: unknown

main.ts

 export * from "./compilation.js"
+export * from "./describe.js"
 export * from "./domain.js"
@@ -3,0 +4,0 @@ export * from "./errors.js"

morph.ts

 import type { evaluate } from "./generics.js"
-import type { listable } from "./lists.js"
+import type { List, listable } from "./lists.js"
 import type { Entry, entryOf, fromEntries } from "./records.js"
@@ -43,10 +43,7 @@ import type { intersectUnion } from "./unionToTuple.js"
 
-type numericArrayEntry<a extends readonly unknown[]> =
-	number extends a["length"]
-		? [number, a[number]]
-		: {
-				[i in keyof a]: i extends `${infer n extends number}`
-					? [n, a[i]]
-					: never
-		  }[number]
+type numericArrayEntry<a extends List> = number extends a["length"]
+	? [number, a[number]]
+	: {
+			[i in keyof a]: i extends `${infer n extends number}` ? [n, a[i]] : never
+	  }[number]
 
@@ -61,6 +58,3 @@ export type MappedEntry = listable<Entry<string | symbol> | Entry<number>>
 
-export function morph<
-	const o extends readonly unknown[],
-	transformed extends MappedEntry
->(
+export function morph<const o extends List, transformed extends MappedEntry>(
 	o: o,
@@ -67,0 +61,0 @@ flatMapEntry: (...args: numericArrayEntry<o>) => transformed

objectKinds.ts

@@ -1,3 +0,4 @@
-import { domainOf, type Domain } from "./domain.js"
+import { domainOf, type Domain, type domainDescriptions } from "./domain.js"
 import type { evaluate } from "./generics.js"
+import type { List } from "./lists.js"
 import { isKeyOf } from "./records.js"
@@ -38,3 +39,3 @@
 	? keyof kinds | undefined
-	: data extends (...args: any[]) => unknown
+	: data extends (...args: never[]) => unknown
 	? "Function"
@@ -45,2 +46,6 @@ : instantiableObjectKind<data, kinds> extends never
 
+export type describeObject<o extends object> = objectKindOf<o> extends string
+	? objectKindDescriptions[objectKindOf<o>]
+	: domainDescriptions["object"]
+
 type instantiableObjectKind<
@@ -50,3 +55,3 @@ data extends object,
 > = {
-	[kind in keyof kinds]: kinds[kind] extends Constructor<data> ? kind : never
+	[kind in keyof kinds]: data extends InstanceType<kinds[kind]> ? kind : never
 }[keyof kinds]
@@ -109,4 +114,3 @@
 
-export const isArray = (data: unknown): data is readonly unknown[] =>
-	Array.isArray(data)
+export const isArray = (data: unknown): data is List => Array.isArray(data)
 
@@ -130,2 +134,4 @@ /** Each defaultObjectKind's completion for the phrase "Must be _____" */
 
+export type objectKindDescriptions = typeof objectKindDescriptions
+
 // this will only return an object kind if it's the root constructor
@@ -132,0 +138,0 @@ // example TypeError would return undefined not 'Error'

out/functions.js

 import { throwInternalError } from "./errors.js";
-import { CastableBase } from "./records.js";
 export const cached = (thunk) => {
@@ -4,0 +3,0 @@ let isCached = false;

out/intersections.d.ts

 import type { domainOf } from "./domain.js";
 import type { andPreserveUnknown, conform } from "./generics.js";
 import type { Hkt } from "./hkt.js";
+import type { List } from "./lists.js";
 import type { requiredKeyOf, valueOf } from "./records.js";
@@ -9,5 +10,5 @@ export interface AndPreserveUnknown extends Hkt.Kind {
 type SequenceIntersectionKind = "array" | "parameters";
-export type intersectArrays<l extends readonly unknown[], r extends readonly unknown[], operator extends Hkt.Kind = AndPreserveUnknown> = intersectSequences<l, r, [], [], operator, "array">;
-export type intersectParameters<l extends readonly unknown[], r extends readonly unknown[], operator extends Hkt.Kind = AndPreserveUnknown> = intersectSequences<l, r, [], [], operator, "parameters">;
-type intersectSequences<l extends readonly unknown[], r extends readonly unknown[], prefix extends readonly unknown[], postfix extends readonly unknown[], intersector extends Hkt.Kind, kind extends SequenceIntersectionKind> = [parseNextElement<l, kind>, parseNextElement<r, kind>] extends [
+export type intersectArrays<l extends List, r extends List, operator extends Hkt.Kind = AndPreserveUnknown> = intersectSequences<l, r, [], [], operator, "array">;
+export type intersectParameters<l extends List, r extends List, operator extends Hkt.Kind = AndPreserveUnknown> = intersectSequences<l, r, [], [], operator, "parameters">;
+type intersectSequences<l extends List, r extends List, prefix extends List, postfix extends List, intersector extends Hkt.Kind, kind extends SequenceIntersectionKind> = [parseNextElement<l, kind>, parseNextElement<r, kind>] extends [
     infer lState extends ElementParseResult,
@@ -35,6 +36,6 @@ infer rState extends ElementParseResult
     optional: boolean;
-    rest: readonly unknown[];
+    rest: List;
 };
 type result<from extends ElementParseResult> = from;
-type parseNextElement<elements extends readonly unknown[], kind extends SequenceIntersectionKind> = elements extends readonly [] ? result<{
+type parseNextElement<elements extends List, kind extends SequenceIntersectionKind> = elements extends readonly [] ? result<{
     head: kind extends "array" ? never : unknown;
@@ -41,0 +42,0 @@ last: kind extends "array" ? never : unknown;

out/lists.d.ts

 import type { isDisjoint } from "./intersections.js";
-import type { NumberLiteral } from "./numericLiterals.js";
+import type { NumberLiteral, parseNonNegativeInteger } from "./numericLiterals.js";
 export type pathToString<segments extends string[], delimiter extends string = "/"> = segments extends [] ? "/" : join<segments, delimiter>;
@@ -8,3 +8,3 @@ export type join<segments extends string[], delimiter extends string, result extends string = ""> = segments extends [infer head extends string, ...infer tail extends string[]] ? join<tail, delimiter, result extends "" ? head : `${result}${delimiter}${head}`> : result;
 export declare const intersectUniqueLists: <item>(l: readonly item[], r: readonly item[]) => item[];
-export type filter<t extends readonly unknown[], constraint, result extends unknown[] = []> = t extends readonly [infer head, ...infer tail] ? filter<tail, constraint, head extends constraint ? [...result, head] : result> : result;
+export type filter<t extends List, constraint, result extends unknown[] = []> = t extends readonly [infer head, ...infer tail] ? filter<tail, constraint, head extends constraint ? [...result, head] : result> : result;
 export type List<t = unknown> = readonly t[];
@@ -14,20 +14,13 @@ export type listable<t> = t | readonly t[];
 export type CollapsingList<t = unknown> = readonly [] | t | readonly [t, t, ...t[]];
-export type headOf<t extends readonly unknown[]> = t[0];
-export type tailOf<t extends readonly unknown[]> = t extends readonly [
-    unknown,
-    ...infer tail
-] ? tail : never;
-export type lastOf<t extends readonly unknown[]> = t extends readonly [
-    ...unknown[],
-    infer last
-] ? last : never;
-export type initOf<t extends readonly unknown[]> = t extends readonly [
-    ...infer init,
-    unknown
-] ? init : never;
-export type numericStringKeyOf<t extends readonly unknown[]> = Extract<keyof t, NumberLiteral>;
-export declare const listFrom: <t>(data: t) => t extends readonly unknown[] ? [t] extends [null] ? t[] : t : t[];
+export type headOf<t extends List> = t[0];
+export type tailOf<t extends List> = t extends readonly [unknown, ...infer tail] ? tail : never;
+export type lastIndexOf<t extends List> = tailOf<t>["length"];
+export type lastOf<t extends List> = t[lastIndexOf<t>];
+export type initOf<t extends List> = t extends readonly [...infer init, unknown] ? init : never;
+export type numericStringKeyOf<t extends List> = Extract<keyof t, NumberLiteral>;
+export type indexOf<array extends List> = keyof array extends infer k ? parseNonNegativeInteger<k & string> : never;
+export declare const listFrom: <t>(data: t) => t extends List<unknown> ? [t] extends [null] ? t[] : t : t[];
 export declare const spliterate: <item, included extends item>(list: readonly item[], by: (item: item) => item is included) => [included: included[], excluded: Exclude<item, included>[]];
 export declare const ReadonlyArray: new <T>(...args: T[]) => readonly T[];
-export declare const includes: <array extends readonly unknown[]>(array: array, element: unknown) => element is array[number];
+export declare const includes: <array extends List<unknown>>(array: array, element: unknown) => element is array[number];
 export declare const range: (length: number, offset?: number) => number[];
@@ -34,0 +27,0 @@ export type AppendOptions = {

out/morph.d.ts

 import type { evaluate } from "./generics.js";
-import type { listable } from "./lists.js";
+import type { List, listable } from "./lists.js";
 import type { Entry, entryOf, fromEntries } from "./records.js";
@@ -13,3 +13,3 @@ import type { intersectUnion } from "./unionToTuple.js";
 }[keyof o];
-type numericArrayEntry<a extends readonly unknown[]> = number extends a["length"] ? [number, a[number]] : {
+type numericArrayEntry<a extends List> = number extends a["length"] ? [number, a[number]] : {
     [i in keyof a]: i extends `${infer n extends number}` ? [n, a[i]] : never;
@@ -21,3 +21,3 @@ }[number];
 ] extends [listable<Entry<number>>] ? arrayFromListableEntries<extractEntries<transformed>> : objectFromListableEntries<extractEntrySets<transformed>>;
-export declare function morph<const o extends readonly unknown[], transformed extends MappedEntry>(o: o, flatMapEntry: (...args: numericArrayEntry<o>) => transformed): fromMappedEntries<transformed>;
+export declare function morph<const o extends List, transformed extends MappedEntry>(o: o, flatMapEntry: (...args: numericArrayEntry<o>) => transformed): fromMappedEntries<transformed>;
 export declare function morph<const o extends object, transformed extends MappedEntry>(o: o, flatMapEntry: (...args: entryOf<o>) => transformed): fromMappedEntries<transformed>;
@@ -24,0 +24,0 @@ export declare function morph<const o extends object, transformed extends MappedEntry>(o: o, flatMapEntry: (...args: entryArgsWithIndex<o>) => transformed): fromMappedEntries<transformed>;

out/objectKinds.d.ts

 import { domainOf, type Domain } from "./domain.js";
 import type { evaluate } from "./generics.js";
+import type { List } from "./lists.js";
 export declare const builtinObjectKinds: {
@@ -74,3 +75,3 @@ readonly Array: ArrayConstructor;
 }>(data: object, kind: kind, kinds?: kinds | undefined) => data is InstanceType<kinds[kind]>;
-export declare const isArray: (data: unknown) => data is readonly unknown[];
+export declare const isArray: (data: unknown) => data is List;
 /** Each defaultObjectKind's completion for the phrase "Must be _____" */
@@ -77,0 +78,0 @@ export declare const objectKindDescriptions: {

out/records.d.ts

 import type { defined, evaluate } from "./generics.js";
+import type { List } from "./lists.js";
 export type Dict<k extends string = string, v = unknown> = {
@@ -37,3 +38,3 @@ readonly [_ in k]: v;
     [k in keyof o]-?: [k, o[k] & ({} | null)];
-}[o extends readonly unknown[] ? keyof o & number : keyof o] & unknown;
+}[o extends List ? keyof o & number : keyof o] & unknown;
 export type entriesOf<o extends object> = entryOf<o>[];
@@ -47,3 +48,3 @@ export declare const entriesOf: <o extends object>(o: o) => entriesOf<o>;
 /** Mimics the result of Object.keys(...) */
-export type keysOf<o> = o extends readonly unknown[] ? number extends o["length"] ? `${number}` : keyof o & `${number}` : {
+export type keysOf<o> = o extends List ? number extends o["length"] ? `${number}` : keyof o & `${number}` : {
     [K in keyof o]: K extends string ? K : K extends number ? `${K}` : never;
@@ -92,3 +93,11 @@ }[keyof o];
 export declare const isEmptyObject: (o: object) => o is EmptyObject;
+export declare const stringAndSymbolicEntriesOf: (o: Record<string | symbol, unknown>) => ([string, unknown] | readonly [symbol, unknown])[];
+export type Key = string | symbol;
+export type invert<t extends Record<PropertyKey, PropertyKey>> = {
+    [k in t[keyof t]]: {
+        [k2 in keyof t]: t[k2] extends k ? k2 : never;
+    }[keyof t];
+} & unknown;
+export declare const invert: <t extends Record<PropertyKey, PropertyKey>>(t: t) => { [k in t[keyof t]]: { [k2 in keyof t]: t[k2] extends k ? k2 : never; }[keyof t]; };
 export {};
 //# sourceMappingURL=records.d.ts.map

out/records.js

@@ -0,1 +1,2 @@
+import { morph } from "./morph.js";
 export const entriesOf = (o) => Object.entries(o);
@@ -38,2 +39,7 @@ export const fromEntries = (entries) => Object.fromEntries(entries);
 export const isEmptyObject = (o) => Object.keys(o).length === 0;
+export const stringAndSymbolicEntriesOf = (o) => [
+    ...Object.entries(o),
+    ...Object.getOwnPropertySymbols(o).map((k) => [k, o[k]])
+];
+export const invert = (t) => morph(t, (k, v) => [v, k]);
 //# sourceMappingURL=records.js.map

out/traits.d.ts

 import type { conform, evaluate } from "./generics.js";
 import type { intersectParameters } from "./intersections.js";
+import type { List } from "./lists.js";
 import { type Constructor } from "./objectKinds.js";
@@ -20,3 +21,3 @@ import { NoopBase, type optionalizeKeys } from "./records.js";
 }>;
-type traitsImplementingKey<traits extends readonly unknown[], k, result extends unknown[] = []> = traits extends readonly [
+type traitsImplementingKey<traits extends List, k, result extends unknown[] = []> = traits extends readonly [
     TraitConstructor<any[], infer instance, infer abstracts>,
@@ -32,7 +33,7 @@ ...infer tail
 export declare const compose: TraitComposition;
-export type TraitConstructor<params extends readonly unknown[] = any[], instance = {}, abstracted = {}, statics = {}> = statics & (new (...args: params) => {
+export type TraitConstructor<params extends List = any[], instance = {}, abstracted = {}, statics = {}> = statics & (new (...args: params) => {
     $abstracted: abstracted;
 } & instance);
 export type ComposedTraits = {
-    params: readonly unknown[];
+    params: List;
     implemented: unknown;
@@ -46,3 +47,3 @@ abstracted: unknown;
 } & Omit<r, keyof l>;
-type composeRecurse<traits extends readonly unknown[], params extends readonly unknown[], implemented, abstracted, statics> = traits extends readonly [
+type composeRecurse<traits extends List, params extends List, implemented, abstracted, statics> = traits extends readonly [
     TraitConstructor<infer nextParams, infer nextInstance, infer nextAbstracted, infer nextStatics>,
@@ -49,0 +50,0 @@ ...infer tail

out/unionToTuple.d.ts

 import type { conform } from "./generics.js";
-import type { join } from "./lists.js";
+import type { List, join } from "./lists.js";
 export type stringifyUnion<t extends string> = join<unionToTuple<t>, ", ">;
@@ -8,5 +8,5 @@ export type unionToTuple<t> = unionToTupleRecurse<t, []> extends infer result ? conform<result, t[]> : never;
 export type intersectUnion<t> = (t extends unknown ? (_: t) => void : never) extends (_: infer intersection) => void ? intersection : never;
-export type overloadOf<f extends (...args: never[]) => unknown, givenArgs extends readonly unknown[] = readonly unknown[]> = Exclude<collectSignatures<(() => never) & f, givenArgs, unknown>, f extends () => never ? never : () => never>;
-type collectSignatures<f, givenArgs extends readonly unknown[], result> = result & f extends (...args: infer args) => infer returns ? result extends f ? never : collectSignatures<f, givenArgs, Pick<f, keyof f> & result & ((...args: args) => returns)> | (args extends givenArgs ? (...args: args) => returns : never) : never;
+export type overloadOf<f extends (...args: never[]) => unknown, givenArgs extends List = List> = Exclude<collectSignatures<(() => never) & f, givenArgs, unknown>, f extends () => never ? never : () => never>;
+type collectSignatures<f, givenArgs extends List, result> = result & f extends (...args: infer args) => infer returns ? result extends f ? never : collectSignatures<f, givenArgs, Pick<f, keyof f> & result & ((...args: args) => returns)> | (args extends givenArgs ? (...args: args) => returns : never) : never;
 export {};
 //# sourceMappingURL=unionToTuple.d.ts.map

package.json

 {
 	"name": "@arktype/util",
-	"version": "0.0.23",
+	"version": "0.0.24",
 	"author": {
@@ -5,0 +5,0 @@ "name": "David Blass",

records.ts

 import type { defined, evaluate } from "./generics.js"
+import type { List } from "./lists.js"
+import { morph } from "./morph.js"
 
@@ -70,3 +72,3 @@ export type Dict<k extends string = string, v = unknown> = {
 	[k in keyof o]-?: [k, o[k] & ({} | null)]
-}[o extends readonly unknown[] ? keyof o & number : keyof o] &
+}[o extends List ? keyof o & number : keyof o] &
 	unknown
@@ -93,3 +95,3 @@
 /** Mimics the result of Object.keys(...) */
-export type keysOf<o> = o extends readonly unknown[]
+export type keysOf<o> = o extends List
 	? number extends o["length"]
@@ -204,1 +206,17 @@ ? `${number}`
 	Object.keys(o).length === 0
+
+export const stringAndSymbolicEntriesOf = (
+	o: Record<string | symbol, unknown>
+) => [
+	...Object.entries(o),
+	...Object.getOwnPropertySymbols(o).map((k) => [k, o[k]] as const)
+]
+
+export type Key = string | symbol
+
+export type invert<t extends Record<PropertyKey, PropertyKey>> = {
+	[k in t[keyof t]]: { [k2 in keyof t]: t[k2] extends k ? k2 : never }[keyof t]
+} & unknown
+
+export const invert = <t extends Record<PropertyKey, PropertyKey>>(t: t) =>
+	morph(t as any, (k, v) => [v, k]) as invert<t>

traits.ts

 import { hasDomain } from "./domain.js"
 import type { conform, evaluate } from "./generics.js"
 import type { intersectParameters } from "./intersections.js"
+import type { List } from "./lists.js"
 import { ancestorsOf, type Constructor } from "./objectKinds.js"
@@ -79,3 +80,3 @@ import { NoopBase, type optionalizeKeys } from "./records.js"
 type traitsImplementingKey<
-	traits extends readonly unknown[],
+	traits extends List,
 	k,
@@ -198,3 +199,3 @@ result extends unknown[] = []
 export type TraitConstructor<
-	params extends readonly unknown[] = any[],
+	params extends List = any[],
 	instance = {},
@@ -209,3 +210,3 @@ abstracted = {},
 export type ComposedTraits = {
-	params: readonly unknown[]
+	params: List
 	implemented: unknown
@@ -231,4 +232,4 @@ abstracted: unknown
 type composeRecurse<
-	traits extends readonly unknown[],
-	params extends readonly unknown[],
+	traits extends List,
+	params extends List,
 	implemented,
@@ -235,0 +236,0 @@ abstracted,

unionToTuple.ts

 import type { conform } from "./generics.js"
-import type { join } from "./lists.js"
+import type { List, join } from "./lists.js"
 
-export type stringifyUnion<t extends string> = join<unionToTuple<t>, ", ">
+export type stringifyUnion<
+	t extends string,
+	delimiter extends string = ", "
+> = join<unionToTuple<t>, delimiter>
 
@@ -34,3 +37,3 @@ export type unionToTuple<t> = unionToTupleRecurse<t, []> extends infer result
 	f extends (...args: never[]) => unknown,
-	givenArgs extends readonly unknown[] = readonly unknown[]
+	givenArgs extends List = List
 > = Exclude<
@@ -50,7 +53,5 @@ collectSignatures<
 
-type collectSignatures<
-	f,
-	givenArgs extends readonly unknown[],
-	result
-> = result & f extends (...args: infer args) => infer returns
+type collectSignatures<f, givenArgs extends List, result> = result & f extends (
+	...args: infer args
+) => infer returns
 	? result extends f
@@ -57,0 +58,0 @@ ? never

No alert changes

Improved metrics

Total package byte prevSize

262443

increased by1.27%

Number of package files

119

increased by0.85%

Lines of code

3978

increased by1.3%

No dependency changes