free-types-core 0.4.3 → 0.4.5

package/dist/Const.d.ts

@@ -3,7 +3,7 @@ export { Const, $Const };
 /**
  * Turn a type `T` into a constant `Type<❋, T>`, totally ignoring arity and type constraints on its input.
 */
-type Const<T> = {
+declare type Const<T> = {
     type: T;
     constraints: any;
     arguments: any[] & {

package/dist/Remaining.d.ts

@@ -2,4 +2,4 @@ import { Type } from './Type';
 import { Slice, Subtract } from './utils';
 export { Remaining };
 /** Use as a type constraint to match a Type whose state of application is known */
-type Remaining<T extends Type, R extends number> = unknown[] extends T['constraints'] ? Type : Type<Slice<T['constraints'], Subtract<T['constraints']['length'], R>, T['constraints']['length']>, T['type']>;
+declare type Remaining<T extends Type, R extends number> = unknown[] extends T['constraints'] ? Type : Type<Slice<T['constraints'], Subtract<T['constraints']['length'], R>, T['constraints']['length']>, T['type']>;

package/dist/Replace.d.ts

@@ -6,4 +6,4 @@ export { Replace };
  *
  *  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>;
+declare type Replace<T, Args extends U['type']['constraints'], From extends Search = TypesMap, U extends Unwrapped = unwrap<T, From>> = apply<U['type'], Args>;

package/dist/Type.d.ts

@@ -1,7 +1,7 @@
 import { Tuple } from './utils';
 export { Type };
 /** Extend `Type<Input?, Output?>` with an interface to produce a free type, or use it as a type constraint.*/
-type Type<Input extends number | unknown[] = unknown[], Output = unknown> = CreateType<{
+declare type Type<Input extends number | unknown[] = unknown[], Output = unknown> = CreateType<{
     type: Output;
     constraints: Constraints<Input, Slots<Input>>;
     arguments: unknown[];
@@ -24,10 +24,10 @@ interface CreateType<T extends {
     8: unknown;
     9: unknown;
 }
-type Slots<T> = T extends Precomputable ? PrecomputedSlots[T & Precomputable] : Tuple<T extends unknown[] ? T['length'] : T extends number ? T : number>;
-type Constraints<Input, Slots> = number extends Input ? unknown[] : unknown[] extends Input ? unknown[] : Input extends unknown[] ? Input : Slots;
-type PrecomputedSlots = {
+declare type Slots<T> = T extends Precomputable ? PrecomputedSlots[T & Precomputable] : Tuple<T extends unknown[] ? T['length'] : T extends number ? T : number>;
+declare type Constraints<Input, Slots> = number extends Input ? unknown[] : unknown[] extends Input ? unknown[] : Input extends unknown[] ? Input : Slots;
+declare type PrecomputedSlots = {
     [I in Precomputable]: Tuple<Seq10[I]>;
 };
-type Precomputable = Seq10[number];
-type Seq10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+declare type Precomputable = Seq10[number];
+declare type Seq10 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

package/dist/apply.d.ts

@@ -2,21 +2,21 @@ import { Type } from './Type';
 import { ArrayKeys, Next } from './utils';
 export { apply, $apply, Generic };
 /** Apply a free type with all its arguments and evaluate the type */
-type apply<$T extends Type, Args extends $T['constraints'] = []> = applyUnsafe<$T, Args>;
+declare type apply<$T extends Type, Args extends $T['constraints'] = []> = applyUnsafe<$T, Args>;
 interface $apply<Args extends unknown[] = []> extends Type<[Type]> {
     type: apply<this[0] extends Type ? this[0] : Type, Args>;
 }
 /** Apply a free type `$T` with its type constraints. */
-type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
-type applyUnsafe<$T extends {
+declare type Generic<$T extends Type> = _apply<$T, $T['constraints']>;
+declare type applyUnsafe<$T extends {
     type: unknown;
     constraints: {
         length: number;
     };
 }, Args extends unknown[]> = number extends $T['constraints']['length'] ? _apply<$T, Args> : _apply<$T, Take<Args, Required<$T['constraints']>['length']>>;
-type _apply<T extends {
+declare type _apply<T extends {
     type: unknown;
 }, Args> = (T & Omit<Args, ArrayKeys> & {
     arguments: Args;
 })['type'];
-type Take<T extends unknown[], To extends number, I extends number = 0, R extends unknown[] = []> = I extends To ? R : Take<T, To, Next<I>, [...R, T[I]]>;
+declare type Take<T extends unknown[], To extends number, I extends number = 0, R extends unknown[] = []> = I extends To ? R : Take<T, To, Next<I>, [...R, T[I]]>;

package/dist/free-types.d.ts

@@ -4,7 +4,7 @@ export { $Id as Id, $Record as Record, $Array as Array, $Tuple as Tuple, $Readon
 interface $Id extends Type<1> {
     type: this[0];
 }
-type Key = string | number | symbol;
+declare type Key = string | number | symbol;
 interface $Record extends Type<[Key, unknown]> {
     type: Record<this[0] & Key, this[1]>;
 }

package/dist/helpers.d.ts

@@ -1,62 +1,62 @@
 import { Next, IsUnknown, Prev } from './utils';
 export { At, Checked, Lossy, Optional, A, B, C, D, E };
-type Type<N extends number> = {
+declare type Type<N extends number> = {
     constraints: {
         [K in Prev<N>]: unknown;
     };
     arguments: unknown[];
 };
-type Type_<N extends number> = {
+declare type Type_<N extends number> = {
     constraints: {
         [K in Prev<N>]?: unknown;
     };
     arguments: unknown[];
 };
-type Default = {
+declare type Default = {
     constraints: [0, 1, 2, 3, 4];
     arguments: unknown[];
 };
 /** - safely index `this`
  * - optionally take a fallback
 */
-type At<N extends number, This extends Type<Next<N>>, Fallback = unknown> = IsUnknown<This['arguments'][N]> extends true ? Fallback : This['arguments'][N];
+declare type At<N extends number, This extends Type<Next<N>>, Fallback = unknown> = IsUnknown<This['arguments'][N]> extends true ? Fallback : This['arguments'][N];
 /** - safely index `this`
  * - defuse the corresponding type constraint with an inline conditional
  * - optionally take a fallback
  */
-type Checked<N extends number, This extends Type<Next<N>>, Fallback = N extends keyof This['constraints'] ? This['constraints'][N] : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends This['constraints'][N] ? This['arguments'][N] : Fallback : never;
+declare type Checked<N extends number, This extends Type<Next<N>>, Fallback = N extends keyof This['constraints'] ? This['constraints'][N] : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends This['constraints'][N] ? This['arguments'][N] : Fallback : never;
 /** - safely index `this`
  * - works on optional parameters
  * - defuse the corresponding type constraint with an inline conditional
  * - optionally take a fallback
  */
-type Optional<N extends number, This extends Type_<Next<N>>, Fallback = N extends keyof This['constraints'] ? Exclude<This['constraints'][N], undefined> : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends Exclude<This['constraints'][N], undefined> ? This['arguments'][N] : Fallback : never;
+declare type Optional<N extends number, This extends Type_<Next<N>>, Fallback = N extends keyof This['constraints'] ? Exclude<This['constraints'][N], undefined> : never> = N extends keyof This['constraints'] ? This['arguments'][N] extends Exclude<This['constraints'][N], undefined> ? This['arguments'][N] : Fallback : never;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  */
-type Lossy<N extends number, This extends Type<Next<N>>> = N extends keyof This['constraints'] ? This['arguments'][N] & This['constraints'][N] : never;
+declare type Lossy<N extends number, This extends Type<Next<N>>> = N extends keyof This['constraints'] ? This['arguments'][N] & This['constraints'][N] : never;
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `0` When no argument is supplied
 */
-type A<This extends Type<1> = Default> = This['arguments'][0] & This['constraints'][0];
+declare type A<This extends Type<1> = Default> = This['arguments'][0] & This['constraints'][0];
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `1` When no argument is supplied
 */
-type B<This extends Type<2> = Default> = This['arguments'][1] & This['constraints'][1];
+declare type B<This extends Type<2> = Default> = This['arguments'][1] & This['constraints'][1];
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `2` When no argument is supplied
 */
-type C<This extends Type<3> = Default> = This['arguments'][2] & This['constraints'][2];
+declare type C<This extends Type<3> = Default> = This['arguments'][2] & This['constraints'][2];
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `3` When no argument is supplied
 */
-type D<This extends Type<4> = Default> = This['arguments'][3] & This['constraints'][3];
+declare type D<This extends Type<4> = Default> = This['arguments'][3] & This['constraints'][3];
 /** - safely index `this`
  * - intersect the corresponding type constraint
  * - equals `4` When no argument is supplied
 */
-type E<This extends Type<5> = Default> = This['arguments'][4] & This['constraints'][4];
+declare type E<This extends Type<5> = Default> = This['arguments'][4] & This['constraints'][4];

package/dist/hkt.d.ts

@@ -1,11 +1,11 @@
 import { Type } from "./Type";
 export { HKT, Contra };
 /** Interfaces extending this type are able to use `hkt` internally. */
-type HKT = {
+declare type HKT = {
     HKT: [any, ...any[]];
 };
 /** Expect a free type with contravariant arguments */
-type Contra<$T extends Type, $U extends Type> = $U['constraints'] extends $T['constraints'] ? $T['type'] extends $U['type'] ? Type : Type<$T['constraints'], $U['type']> : {
+declare type Contra<$T extends Type, $U extends Type> = $U['constraints'] extends $T['constraints'] ? $T['type'] extends $U['type'] ? Type : Type<$T['constraints'], $U['type']> : {
     'Contravariance issue': {
         'the input': $U['constraints'];
         'is not assignable to': $T['constraints'];

package/dist/inferArgs.d.ts

@@ -1,7 +1,7 @@
 import { Type } from './Type';
 import { apply } from './apply';
 export { inferArgs };
-type inferArgs<T, $T extends Type> = T extends apply<$T, [
+declare type inferArgs<T, $T extends Type> = T extends apply<$T, [
     infer A,
     infer B,
     infer C,

package/dist/partial.d.ts

@@ -2,16 +2,17 @@ import { Type } from './Type';
 import { apply } from './apply';
 import { Slice, Subtract, ToTuple } from './utils';
 export { partial, partialRight, PartialRight, $partial };
+export { PartialType };
 /** Return a new type based upon `$T`, with `Args` already applied, expecting the remaining arguments */
-type partial<$T extends Type, Args extends Partial<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? Args extends unknown[] ? _partial<$T, Args> : never : never;
+declare type partial<$T extends Type, Args extends Partial<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? Args extends unknown[] ? _partial<$T, Args> : never : never;
 /** A free version of `partial` */
 interface $partial<$T extends Type> extends Type<1> {
     type: _partial<$T, [this['arguments'][0]]>;
 }
-type _partial<$T extends Type, Args extends unknown[]> = PartialType<$T, Args, Slice<$T['constraints'], Args['length'], Required<$T['constraints']>['length']>, 'left'>;
+declare type _partial<$T extends Type, Args extends unknown[]> = PartialType<$T, Args, Slice<$T['constraints'], Args['length'], Required<$T['constraints']>['length']>, 'left'>;
 /** Return a new type based upon `$T`, with `Args` already applied to the rightmost parameters of `$T`, and expecting the remaining arguments */
-type partialRight<$T extends Type, Args extends PartialRight<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? PartialType<$T, Args, Slice<$T['constraints'], 0, Subtract<Required<$T['constraints']>['length'], Args['length']>>, 'right'> : never;
-type PartialRight<T extends unknown[], R = never> = T extends [unknown, ...(infer Rest)] ? PartialRight<Rest, T | R> : [] | R;
+declare type partialRight<$T extends Type, Args extends PartialRight<$Model['constraints']>, $Model extends Type = $T> = $T extends $Model ? PartialType<$T, Args, Slice<$T['constraints'], 0, Subtract<Required<$T['constraints']>['length'], Args['length']>>, 'right'> : never;
+declare type PartialRight<T extends unknown[], R = never> = T extends [unknown, ...(infer Rest)] ? PartialRight<Rest, T | R> : [] | R;
 interface PartialType<$T extends Type, Applied extends unknown[], Constraints extends unknown[], Direction> extends Type {
     type: apply<$T, Direction extends 'left' ? [...Applied, ...ToTuple<this['arguments']>] : [...ToTuple<this['arguments']>, ...Applied]>;
     constraints: Constraints;

package/dist/unwrap.d.ts

@@ -4,30 +4,30 @@ import { inferArgs } from './inferArgs';
 import { Generic, apply } from './apply';
 import { TypesMap } from './TypesMap';
 import { Tuple, ReadonlyTuple, Array, ReadonlyArray } from './free-types';
-type Search = Type | SearchList;
-type SearchList = Type[] | Record<string, Type> | Interface;
-type Interface = {
+declare type Search = Type | SearchList;
+declare type SearchList = Type[] | Record<string, Type> | Interface;
+declare type Interface = {
     [k: string]: any;
 } & {
     [Symbol.toStringTag]?: never;
 };
 export { unwrap, Unwrapped, Search };
 /** Decompose a type into its constituents */
-type unwrap<T, From extends Search = TypesMap> = T extends readonly unknown[] ? unwrapLists<T> : _unwrap<T, From extends Type ? [From] : From>;
-type unwrapLists<T> = T extends unknown[] ? T extends [unknown, ...unknown[]] ? Unwrapped<'Tuple', Tuple, T> : Unwrapped<'Array', Array, [T[0]]> : T extends readonly [unknown, ...unknown[]] ? Unwrapped<'ReadonlyTuple', ReadonlyTuple, Mutable<T>> : Unwrapped<'ReadonlyArray', ReadonlyArray, [(T & unknown[])[0]]>;
-type Mutable<T> = {
+declare type unwrap<T, From extends Search = TypesMap> = T extends readonly unknown[] ? unwrapLists<T> : _unwrap<T, From extends Type ? [From] : From>;
+declare type unwrapLists<T> = T extends unknown[] ? T extends [unknown, ...unknown[]] ? Unwrapped<'Tuple', Tuple, T> : Unwrapped<'Array', Array, [T[0]]> : T extends readonly [unknown, ...unknown[]] ? Unwrapped<'ReadonlyTuple', ReadonlyTuple, Mutable<T>> : Unwrapped<'ReadonlyArray', ReadonlyArray, [(T & unknown[])[0]]>;
+declare type Mutable<T> = {
     -readonly [K in keyof T]: K extends ArrayKeys ? T[K] : T[K];
 };
-type _unwrap<T, From extends SearchList, R = {
+declare type _unwrap<T, From extends SearchList, R = {
     [K in keyof From as K extends ArrayKeys ? never : K extends string ? K : never]: From[K] extends Type ? Branch<T, From[K], K>[T extends Generic<From[K]> ? 'match' : 'miss'] : never;
 }> = R[keyof R];
 interface Branch<T, $T extends Type, K> {
     match: Disambiguate<T, $T, inferArgs<T, $T>, K & string>;
     miss: never;
 }
-type Disambiguate<T, $T extends Type, Args extends unknown[], K extends string> = Eq<T, apply<$T, Args>> extends true ? Unwrapped<K, $T, Args> : never;
+declare type Disambiguate<T, $T extends Type, Args extends unknown[], K extends string> = Eq<T, apply<$T, Args>> extends true ? Unwrapped<K, $T, Args> : never;
 /** The result of unwrapping a type with `unwrap` */
-type Unwrapped<URI extends string = string, T extends Type = Type, A = unknown[]> = {
+declare type Unwrapped<URI extends string = string, T extends Type = Type, A = unknown[]> = {
     URI: URI;
     type: T;
     args: A;

package/dist/utils.d.ts

@@ -1,29 +1,29 @@
 export { Natural, Prev, Next, Subtract };
 export { ArrayKeys, Slice, ToTuple, Tuple, Head, Tail, Last, Init };
 export { Extends, Eq, IsUnknown, IsAny, IsOptional };
-type Natural = [0, ..._Next];
-type Prev<I extends number> = number extends I ? number : number & _Prev[I];
-type _Prev = [never, ...Natural];
-type Next<I extends number> = number extends I ? number : number & _Next[I];
-type _Next = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
-type Subtract<A extends number, B extends number> = number extends A ? number : number extends B ? number : _Subtract<A, B>;
-type _Subtract<A extends number, B extends number, _A = Prev<A>, _B = Prev<B>> = B extends 0 ? A : [_A] extends [never] ? never : [_B] extends never ? never : _Subtract<_A & number, _B & number>;
-type ArrayKeys = Exclude<keyof [], never>;
-type Slice<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = I extends To ? R : Slice<T, From, To, Next<I>, IsOptional<T, I> extends true ? [...R, T[I]?] : [...R, T[I]]>;
-type IsOptional<T extends unknown[], I extends number> = [
+declare type Natural = [0, ..._Next];
+declare type Prev<I extends number> = number extends I ? number : number & _Prev[I];
+declare type _Prev = [never, ...Natural];
+declare type Next<I extends number> = number extends I ? number : number & _Next[I];
+declare type _Next = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64];
+declare type Subtract<A extends number, B extends number> = number extends A ? number : number extends B ? number : _Subtract<A, B>;
+declare type _Subtract<A extends number, B extends number, _A = Prev<A>, _B = Prev<B>> = B extends 0 ? A : [_A] extends [never] ? never : [_B] extends never ? never : _Subtract<_A & number, _B & number>;
+declare type ArrayKeys = Exclude<keyof [], never>;
+declare type Slice<T extends unknown[], From extends number, To extends number = Required<T>['length'], I extends number = From, R extends unknown[] = []> = I extends To ? R : Slice<T, From, To, Next<I>, IsOptional<T, I> extends true ? [...R, T[I]?] : [...R, T[I]]>;
+declare type IsOptional<T extends unknown[], I extends number> = [
     {
         [K in T['length'] as K]: K extends I ? never : unknown;
     }[I]
 ] extends [never] ? true : false;
-type ToTuple<T extends readonly unknown[], I extends number = 0, R extends unknown[] = []> = any[] extends T ? T[0][] : I extends T['length'] ? R : ToTuple<T, Next<I>, [...R, T[I]]>;
-type Tuple<L extends number, T = unknown, R extends unknown[] = []> = number extends L ? T[] : L extends R['length'] ? R : Tuple<L, T, [T, ...R]>;
-type Head<T extends [unknown, ...unknown[]]> = T[0];
-type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
-type Last<T extends unknown[]> = T[Prev<T['length']>];
-type Init<T extends [unknown, ...unknown[]]> = T extends [...infer R, unknown] ? R : never;
-type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
-type IsAny<T> = Extends<T | anything, T & anything>;
-type Extends<A, B> = [A] extends [B] ? true : false;
-type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
+declare type ToTuple<T extends readonly unknown[], I extends number = 0, R extends unknown[] = []> = any[] extends T ? T[0][] : I extends T['length'] ? R : ToTuple<T, Next<I>, [...R, T[I]]>;
+declare type Tuple<L extends number, T = unknown, R extends unknown[] = []> = number extends L ? T[] : L extends R['length'] ? R : Tuple<L, T, [T, ...R]>;
+declare type Head<T extends [unknown, ...unknown[]]> = T[0];
+declare type Tail<T extends [unknown, ...unknown[]]> = T extends [unknown, ...infer R] ? R : never;
+declare type Last<T extends unknown[]> = T[Prev<T['length']>];
+declare type Init<T extends [unknown, ...unknown[]]> = T extends [...infer R, unknown] ? R : never;
+declare type IsUnknown<T> = unknown extends T ? IsAny<T> extends false ? true : false : false;
+declare type IsAny<T> = Extends<T | anything, T & anything>;
+declare type Extends<A, B> = [A] extends [B] ? true : false;
+declare type Eq<A, B> = [A] extends [B] ? [B] extends [A] ? true : false : false;
 declare const thing: unique symbol;
-type anything = typeof thing;
+declare type anything = typeof thing;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "free-types-core",
-    "version": "0.4.3",
+    "version": "0.4.5",
     "description": "A type-level library enabling the creation and the manipulation of type constructors which are detached from their type parameters.",
     "keywords:": [
         "higher kinded type",