free-types-core 1.0.2 → 1.1.0

package/dist/$Before.d.ts

@@ -1,52 +1,52 @@
-import { Const } from "./Const";
-import { _apply } from "./apply";
-import { Next, ArrayLike } from "./utils";
-import { Contra, NamedConstraints } from "./Type";
-type Type = {
-    type: any;
-    constraints: any;
-    names: any;
-    arg: any;
-};
-type Unconstrained = {
-    [k: number]: unknown;
-};
-export type $Before<$T extends Type, $P extends ContraIndex<$P, $T, I>, I extends number = never> = [I] extends [never] ? $BeforeN<$T, $P> : $BeforeI<$T, $P, I>;
-interface $BeforeI<$T extends Type, $P extends Type, I extends number, Constraints extends Unconstrained = ReplaceAt<$T['constraints'], I, Const<$P['constraints'][0]>>> extends $Type<$T> {
-    type: _apply<$T, ReplaceAt<this['arguments'], I, $P>>;
-    constraints: Constraints;
-    contra: Contra<Constraints>;
-    namedConstraints: NamedConstraints<this>;
-}
-interface $BeforeN<$T extends Type, $P extends Type, Constraints extends Unconstrained = $T['constraints'] extends infer I extends unknown[] ? {
-    [K in keyof I]: $P['constraints'][0];
-} : unknown[]> extends $Type<$T> {
-    type: _apply<$T, this['arguments'] extends (infer I extends ArrayLike) & unknown[] ? {
-        [K in keyof I]: _apply<$P, [I[K]]>;
-    } : ArrayLike>;
-    constraints: Constraints;
-    contra: Contra<Constraints>;
-    namedConstraints: NamedConstraints<this>;
-}
-interface $Type<$T extends Type> {
-    [k: number]: unknown;
-    names: $T['names'];
-    arg: $T['arg'];
-    arguments: unknown[];
-}
-type ContraIndex<$T extends Type, M extends Type, I extends number, Model = [I] extends [never] ? M['constraints'][number] : M['constraints'][I]> = [Model] extends $T['constraints'] ? {
-    constraints: any[];
-    type: Model;
-    names: any;
-    arg: any;
-} : {
-    constraints: [Model];
-    type: Model;
-    names: any;
-    arg: any;
-};
-type ReplaceAt<T extends {
-    [k: number]: unknown;
-    length: number;
-}, N extends number, $P extends Type, L extends number = T['length'], I extends number = 0, R extends unknown[] = []> = I extends L ? R : ReplaceAt<T, N, $P, L, Next<I>, [...R, I extends N ? _apply<$P, [T[I]]> : T[I]]>;
-export {};
+import { Const } from "./Const.js";
+import { _apply } from "./apply.js";
+import { Next, ArrayLike } from "./utils.js";
+import { Contra, NamedConstraints } from "./Type.js";
+type Type = {
+    type: any;
+    constraints: any;
+    names: any;
+    arg: any;
+};
+type Unconstrained = {
+    [k: number]: unknown;
+};
+export type $Before<$T extends Type, $P extends ContraIndex<$P, $T, I>, I extends number = never> = [I] extends [never] ? $BeforeN<$T, $P> : $BeforeI<$T, $P, I>;
+interface $BeforeI<$T extends Type, $P extends Type, I extends number, Constraints extends Unconstrained = ReplaceAt<$T['constraints'], I, Const<$P['constraints'][0]>>> extends $Type<$T> {
+    type: _apply<$T, ReplaceAt<this['arguments'], I, $P>>;
+    constraints: Constraints;
+    contra: Contra<Constraints>;
+    namedConstraints: NamedConstraints<this>;
+}
+interface $BeforeN<$T extends Type, $P extends Type, Constraints extends Unconstrained = $T['constraints'] extends infer I extends unknown[] ? {
+    [K in keyof I]: $P['constraints'][0];
+} : unknown[]> extends $Type<$T> {
+    type: _apply<$T, this['arguments'] extends (infer I extends ArrayLike) & unknown[] ? {
+        [K in keyof I]: _apply<$P, [I[K]]>;
+    } : ArrayLike>;
+    constraints: Constraints;
+    contra: Contra<Constraints>;
+    namedConstraints: NamedConstraints<this>;
+}
+interface $Type<$T extends Type> {
+    [k: number]: unknown;
+    names: $T['names'];
+    arg: $T['arg'];
+    arguments: unknown[];
+}
+type ContraIndex<$T extends Type, M extends Type, I extends number, Model = [I] extends [never] ? M['constraints'][number] : M['constraints'][I]> = [Model] extends $T['constraints'] ? {
+    constraints: any[];
+    type: Model;
+    names: any;
+    arg: any;
+} : {
+    constraints: [Model];
+    type: Model;
+    names: any;
+    arg: any;
+};
+type ReplaceAt<T extends {
+    [k: number]: unknown;
+    length: number;
+}, N extends number, $P extends Type, L extends number = T['length'], I extends number = 0, R extends unknown[] = []> = I extends L ? R : ReplaceAt<T, N, $P, L, Next<I>, [...R, I extends N ? _apply<$P, [T[I]]> : T[I]]>;
+export {};

package/dist/$Before.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/Const.d.ts

@@ -1,31 +1,31 @@
-import { Type } from './Type';
-export { Const, $Const };
-/**
- * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
-*/
-type Const<T> = ConstantType<{
-    type: T;
-}, {
-    constraints: any;
-    names: any;
-}>;
-interface ConstantType<Out extends {
-    type: any;
-}, __> {
-    [k: number]: any;
-    type: Out['type'];
-    arguments: any[] & {
-        length: any;
-    };
-    namedConstraints: any;
-    arg: any;
-    constraints: any;
-    names: any;
-    contra: any;
-}
-/**
- * Turn the input into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
-*/
-interface $Const extends Type<1> {
-    type: Const<this[0]>;
-}
+import { Type } from './Type.js';
+export { Const, $Const };
+/**
+ * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
+*/
+type Const<T> = ConstantType<{
+    type: T;
+}, {
+    constraints: any;
+    names: any;
+}>;
+interface ConstantType<Out extends {
+    type: any;
+}, __> {
+    [k: number]: any;
+    type: Out['type'];
+    arguments: any[] & {
+        length: any;
+    };
+    namedConstraints: any;
+    arg: any;
+    constraints: any;
+    names: any;
+    contra: any;
+}
+/**
+ * Turn the input into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
+*/
+interface $Const extends Type<1> {
+    type: Const<this[0]>;
+}

package/dist/Const.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/Flow.d.ts

@@ -1,31 +1,31 @@
-import { _apply, _Type } from './apply';
-import { Type } from './Type';
-import { Next } from './utils';
-export { Flow };
-type Flow<$Ts extends Composable, Composable extends (_Type & {
-    contra: any;
-})[] = $Ts extends [_Type] ? [_Type] : Check<$Ts>> = Composition<{
-    type: Fallback<$Ts>;
-    constraints: $Ts[0]['constraints'];
-    names: $Ts[0]['names'];
-}, $Ts>;
-type Descriptor = {
-    type: any;
-    constraints: any;
-    names: any;
-};
-interface Composition<D extends Descriptor, $Ts extends (_Type & {
-    contra: any;
-})[]> extends Type {
-    type: unknown[] extends this['arguments'] ? D['type'] : Pipe<[_apply<$Ts[0], this['arguments']>], $Ts>;
-    names: D['names'];
-    constraints: D['constraints'];
-    contra: $Ts[0]['contra'];
-    namedConstraints: $Ts[0]['namedConstraints'];
-}
-type Fallback<$Ts> = $Ts extends [...any, infer $T extends {
-    type: unknown;
-}] ? $T['type'] : never;
-export type Check<T extends unknown[], R extends _Type[] = [], Last extends _Type[] = []> = T extends [infer A extends _Type, infer B extends _Type, ...infer Rest] ? Check2<A, B> extends infer C extends [_Type, _Type] ? Check<Rest, [...R, ...Last, C[0]], [C[1]]> : never : T extends [infer A extends _Type, infer B extends _Type] ? [...R, ...Last, ...Check2<A, B>] : T extends [infer A extends _Type] ? Last extends [] ? [...R, A] : [...R, ...Check2<Last[0], A>] : [...R, ...Last];
-type Check2<A extends _Type, B extends _Type> = A['type'] extends B['constraints'][0] ? [A, B] : [Type<A['constraints'], B['constraints'][0]>, B];
-type Pipe<Args extends unknown[], $Ts extends _Type[], I extends number = 1, R = _apply<$Ts[I], Args>, N extends number = Next<I>> = N extends $Ts['length'] ? R : R extends $Ts[N]['constraints'][0] ? Pipe<[R], $Ts, N> : never;
+import { _apply, _Type } from './apply.js';
+import { Type } from './Type.js';
+import { Next } from './utils.js';
+export { Flow };
+type Flow<$Ts extends Composable, Composable extends (_Type & {
+    contra: any;
+})[] = $Ts extends [_Type] ? [_Type] : Check<$Ts>> = Composition<{
+    type: Fallback<$Ts>;
+    constraints: $Ts[0]['constraints'];
+    names: $Ts[0]['names'];
+}, $Ts>;
+type Descriptor = {
+    type: any;
+    constraints: any;
+    names: any;
+};
+interface Composition<D extends Descriptor, $Ts extends (_Type & {
+    contra: any;
+})[]> extends Type {
+    type: unknown[] extends this['arguments'] ? D['type'] : Pipe<[_apply<$Ts[0], this['arguments']>], $Ts>;
+    names: D['names'];
+    constraints: D['constraints'];
+    contra: $Ts[0]['contra'];
+    namedConstraints: $Ts[0]['namedConstraints'];
+}
+type Fallback<$Ts> = $Ts extends [...any, infer $T extends {
+    type: unknown;
+}] ? $T['type'] : never;
+export type Check<T extends unknown[], R extends _Type[] = [], Last extends _Type[] = []> = T extends [infer A extends _Type, infer B extends _Type, ...infer Rest] ? Check2<A, B> extends infer C extends [_Type, _Type] ? Check<Rest, [...R, ...Last, C[0]], [C[1]]> : never : T extends [infer A extends _Type, infer B extends _Type] ? [...R, ...Last, ...Check2<A, B>] : T extends [infer A extends _Type] ? Last extends [] ? [...R, A] : [...R, ...Check2<Last[0], A>] : [...R, ...Last];
+type Check2<A extends _Type, B extends _Type> = A['type'] extends B['constraints'][0] ? [A, B] : [Type<A['constraints'], B['constraints'][0]>, B];
+type Pipe<Args extends unknown[], $Ts extends _Type[], I extends number = 1, R = _apply<$Ts[I], Args>, N extends number = Next<I>> = N extends $Ts['length'] ? R : R extends $Ts[N]['constraints'][0] ? Pipe<[R], $Ts, N> : never;

package/dist/Flow.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/From.d.ts

@@ -1,70 +1,69 @@
-import { Contra, NamedConstraints } from './Type';
-import { ArrayLike, Next, IsOptional, Mappable, Union2Tuple, Int } from './utils';
-export { From };
-type Named = ({
-    [k: PropertyKey]: string;
-} | undefined)[];
-type None = {};
-/** Create a new `Type` based upon a Mappable `T`.
- *
- * Optionally take a tuple `Args` to specify which fields to turn into a parameter and in what order they must be applied. Parameters can be set to be optional. Named parameters are created automatically for object types, they can be renamed.
- *
- * */
-type From<T extends Mappable<any>, Args extends readonly (keyof T | undefined)[] | Named = never> = ([
-    Args
-] extends [never] ? (T extends unknown[] ? GetIndices<T> : Union2Tuple<keyof T>) extends infer K ? {
-    constraints: PseudoTuple<T, K>;
-    names: None;
-    keys: K;
-} : never : Args extends Named ? {
-    constraints: ToConstraints<T, Args>;
-    names: GetNames<Args>;
-    keys: GetKeys<Args>;
-} : {
-    constraints: PseudoTuple<T, Args>;
-    names: Args extends (string | undefined)[] ? GenerateNames<Args> : {};
-    keys: Required<Args>;
-}) extends infer D extends Descriptor ? FromTemplate<{
-    type: T;
-}, D> : never;
-type Descriptor = {
-    constraints: any;
-    names: any;
-    keys: any;
-};
-interface FromTemplate<T extends {
-    type: any;
-}, D extends Descriptor> {
-    [k: number]: unknown;
-    type: T['type'] extends infer Type ? unknown[] extends this['arguments'] ? Type : {
-        [K in keyof Type]: Value<Type[K], this['arguments'], IndexOf<K, D['keys']>, D['constraints']>;
-    } : never;
-    namedConstraints: NamedConstraints<D>;
-    names: D['names'];
-    constraints: D['constraints'];
-    contra: Contra<D['constraints']>;
-    arg: any;
-    arguments: unknown[];
-}
-type GetIndices<T extends unknown[]> = {
-    [K in keyof T]-?: K;
-};
-export type Value<T, This extends ArrayLike, I, Constraints extends ArrayLike> = [
-    I
-] extends [never] ? T : IsOptional<Constraints, I> extends true ? This[I & number] extends undefined ? T : This[I & number] : This[I & number];
-export type IndexOf<T, Ts extends ArrayLike, L = Required<Ts>['length'], I = 0> = I extends L ? never : [T] extends [`${Ts[I & number]}`] ? I : IndexOf<T, Ts, L, Next<I>>;
-type PseudoTuple<T, Keys> = {
-    [K in keyof Keys]: Exclude<T[Keys[K] & keyof T], undefined>;
-};
-type ToConstraints<T, Args extends Named> = {
-    [K in keyof Args]: T[keyof (Args[K] & {}) & keyof T];
-};
-type GetKeys<Args extends Named, R = Required<Args>> = {
-    [K in keyof R]: keyof R[K];
-};
-type GetNames<Args extends Named, T extends Required<Named> = Required<Args>> = unknown & {
-    [K in keyof T as T[K & `${number}`][keyof T[K]]]: Int<K>;
-};
-type GenerateNames<Args extends (string | undefined)[]> = unknown & {
-    [K in Exclude<keyof Args, keyof []> as Args[K] & string]: Int<K>;
-};
+import { Contra, NamedConstraints } from './Type.js';
+import { ArrayLike, IsOptional, Mappable, Union2Tuple, Int, IndexOf } from './utils.js';
+export { From };
+type Named = ({
+    [k: PropertyKey]: string;
+} | undefined)[];
+type None = {};
+/** Create a new `Type` based upon a Mappable `T`.
+ *
+ * Optionally take a tuple `Args` to specify which fields to turn into a parameter and in what order they must be applied. Parameters can be set to be optional. Named parameters are created automatically for object types, they can be renamed.
+ *
+ * */
+type From<T extends Mappable<any>, Args extends readonly (keyof T | undefined)[] | Named = never> = ([
+    Args
+] extends [never] ? (T extends unknown[] ? GetIndices<T> : Union2Tuple<keyof T>) extends infer K ? {
+    constraints: PseudoTuple<T, K>;
+    names: None;
+    keys: K;
+} : never : Args extends Named ? {
+    constraints: ToConstraints<T, Args>;
+    names: GetNames<Args>;
+    keys: GetKeys<Args>;
+} : {
+    constraints: PseudoTuple<T, Args>;
+    names: Args extends (string | undefined)[] ? GenerateNames<Args> : {};
+    keys: Required<Args>;
+}) extends infer D extends Descriptor ? FromTemplate<{
+    type: T;
+}, D> : never;
+type Descriptor = {
+    constraints: any;
+    names: any;
+    keys: any;
+};
+interface FromTemplate<T extends {
+    type: any;
+}, D extends Descriptor> {
+    [k: number]: unknown;
+    type: T['type'] extends infer Type ? unknown[] extends this['arguments'] ? Type : {
+        [K in keyof Type]: Value<Type[K], this['arguments'], IndexOf<K, D['keys']>, D['constraints']>;
+    } : never;
+    namedConstraints: NamedConstraints<D>;
+    names: D['names'];
+    constraints: D['constraints'];
+    contra: Contra<D['constraints']>;
+    arg: any;
+    arguments: unknown[];
+}
+type GetIndices<T extends unknown[]> = {
+    [K in keyof T]-?: K;
+};
+export type Value<T, This extends ArrayLike, I, Constraints extends ArrayLike> = [
+    I
+] extends [never] ? T : IsOptional<Constraints, I> extends true ? This[I & number] extends undefined ? T : This[I & number] : This[I & number];
+type PseudoTuple<T, Keys> = {
+    [K in keyof Keys]: Exclude<T[Keys[K] & keyof T], undefined>;
+};
+type ToConstraints<T, Args extends Named> = {
+    [K in keyof Args]: T[keyof (Args[K] & {}) & keyof T];
+};
+type GetKeys<Args extends Named, R = Required<Args>> = {
+    [K in keyof R]: keyof R[K];
+};
+type GetNames<Args extends Named, T extends Required<Named> = Required<Args>> = unknown & {
+    [K in keyof T as T[K & `${number}`][keyof T[K]]]: Int<K>;
+};
+type GenerateNames<Args extends (string | undefined)[]> = unknown & {
+    [K in Exclude<keyof Args, keyof []> as Args[K] & string]: Int<K>;
+};

package/dist/From.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/Pipe.d.ts

@@ -1,27 +1,27 @@
-import { Next } from "./utils";
-import { _apply, apply, _Type as Type } from './apply';
-type _Type<C = any> = {
-    type: any;
-    constraints: C;
-};
-type TooManyArgs = 'You can compose up to 10 free types with Pipe';
-type WrongArg = 'would be called with wrong argument';
-/** Pipe an arguments list or named arguments through a composition of free types
- * ```
- * type Foo = Pipe<[1, 2], $Add, $Next, $Exclaim> // "4!"
- * ```
- * ---
- * **Note**: Error messages are narrower than they need to be:
- * ```
- * Pipe<['foo'], $Exclain, $Next>
- * //                      ~~~~~
- * // Type<[number], number>' does not satisfy the constraint 'Type<["foo!"], number>
- * ```
- * Understand it as `Type<[number], number>` would be called with wrong argument `"foo!"`. This inconvenience is required for generic higher order compositions to work properly.
- */
-export type Pipe<Args extends [STOP] extends [never] ? Check : TooManyArgs, A extends Type = never, B extends _<B, WrongArg, RA> = never, C extends _<C, WrongArg, RB> = never, D extends _<D, WrongArg, RC> = never, E extends _<E, WrongArg, RD> = never, F extends _<F, WrongArg, RE> = never, G extends _<G, WrongArg, RF> = never, H extends _<H, WrongArg, RG> = never, I extends _<I, WrongArg, RH> = never, J extends _<J, WrongArg, RI> = never, STOP = never, RA = apply<A, Args, any>, RB = _apply<B, [RA]>, RC = _apply<C, [RB]>, RD = _apply<D, [RC]>, RE = _apply<E, [RD]>, RF = _apply<F, [RE]>, RG = _apply<G, [RF]>, RH = _apply<H, [RG]>, RI = _apply<I, [RH]>, RJ = _apply<J, [RI]>, Check = Args extends readonly unknown[] ? A['constraints'] : A['namedConstraints']> = Result<[RA, RB, RC, RD, RE, RF, RG, RH, RI, RJ]>;
-type Result<T extends unknown[], I extends number = 0, R = never> = [
-    T[I]
-] extends [never] ? R : I extends T['length'] ? R : Result<T, Next<I>, T[I]>;
-type _<$T extends _Type, _, $U> = [$U] extends $T['constraints'] ? any : _Type<[$U]>;
-export {};
+import { Next } from "./utils.js";
+import { _apply, apply, _Type as Type } from './apply.js';
+type _Type<C = any> = {
+    type: any;
+    constraints: C;
+};
+type TooManyArgs = 'You can compose up to 10 free types with Pipe';
+type WrongArg = 'would be called with wrong argument';
+/** Pipe an arguments list or named arguments through a composition of free types
+ * ```
+ * type Foo = Pipe<[1, 2], $Add, $Next, $Exclaim> // "4!"
+ * ```
+ * ---
+ * **Note**: Error messages are narrower than they need to be:
+ * ```
+ * Pipe<['foo'], $Exclain, $Next>
+ * //                      ~~~~~
+ * // Type<[number], number>' does not satisfy the constraint 'Type<["foo!"], number>
+ * ```
+ * Understand it as `Type<[number], number>` would be called with wrong argument `"foo!"`. This inconvenience is required for generic higher order compositions to work properly.
+ */
+export type Pipe<Args extends [STOP] extends [never] ? Check : TooManyArgs, A extends Type = never, B extends _<B, WrongArg, RA> = never, C extends _<C, WrongArg, RB> = never, D extends _<D, WrongArg, RC> = never, E extends _<E, WrongArg, RD> = never, F extends _<F, WrongArg, RE> = never, G extends _<G, WrongArg, RF> = never, H extends _<H, WrongArg, RG> = never, I extends _<I, WrongArg, RH> = never, J extends _<J, WrongArg, RI> = never, STOP = never, RA = apply<A, Args, any>, RB = _apply<B, [RA]>, RC = _apply<C, [RB]>, RD = _apply<D, [RC]>, RE = _apply<E, [RD]>, RF = _apply<F, [RE]>, RG = _apply<G, [RF]>, RH = _apply<H, [RG]>, RI = _apply<I, [RH]>, RJ = _apply<J, [RI]>, Check = Args extends readonly unknown[] ? A['constraints'] : A['namedConstraints']> = Result<[RA, RB, RC, RD, RE, RF, RG, RH, RI, RJ]>;
+type Result<T extends unknown[], I extends number = 0, R = never> = [
+    T[I]
+] extends [never] ? R : I extends T['length'] ? R : Result<T, Next<I>, T[I]>;
+type _<$T extends _Type, _, $U> = [$U] extends $T['constraints'] ? any : _Type<[$U]>;
+export {};

package/dist/Pipe.js

@@ -1 +1 @@
-export {};
+export {};

package/dist/Replace.d.ts

@@ -1,9 +1,9 @@
-import { unwrap, Unwrapped, Search } from './unwrap';
-import { _apply } from './apply';
-import { TypesMap } from './TypesMap';
-export { Replace };
-/** Replace the inner value of a type with compatible arguments.
- *
- *  Can be used to constrain the inner value of a type
- */
-type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = _apply<U['type'], Args>;
+import { unwrap, Unwrapped, Search } from './unwrap.js';
+import { _apply } from './apply.js';
+import { TypesMap } from './TypesMap.js';
+export { Replace };
+/** Replace the inner value of a type with compatible arguments.
+ *
+ *  Can be used to constrain the inner value of a type
+ */
+type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = _apply<U['type'], Args>;

package/dist/Replace.js

@@ -1 +1 @@
-export {};
+export {};