linted 14.4.0-rc.1 → 14.4.0-rc.3

package/src/type/literal/string/letter.d.ts

@@ -0,0 +1,35 @@
+declare type letter =
+  | lower
+  | upper
+;
+
+declare type lower = Lowercase<upper>;
+
+declare type upper =
+  | "A"
+  | "B"
+  | "C"
+  | "D"
+  | "E"
+  | "F"
+  | "G"
+  | "H"
+  | "I"
+  | "J"
+  | "K"
+  | "L"
+  | "M"
+  | "N"
+  | "O"
+  | "P"
+  | "Q"
+  | "R"
+  | "S"
+  | "T"
+  | "U"
+  | "V"
+  | "W"
+  | "X"
+  | "Y"
+  | "Z"
+;

package/src/type/module/markdownlint.d.ts

@@ -0,0 +1,21 @@
+declare module "eslint-plugin-markdownlint" {
+  export const configs: Record<
+    "flat/recommended"
+    ,
+    Record<
+      "rules"
+      ,
+      IRule
+    >
+  >;
+}
+
+declare module "eslint-plugin-markdownlint/parser" {
+  export const parseForESLint: (
+    code: string
+  )=> {
+    ast: unknown;
+    parserServices: unknown;
+    visitorKeys: unknown;
+  };
+}

package/src/type/safe/Safe.d.ts

@@ -0,0 +1,2 @@
+declare const p: unique symbol;
+declare type Safe<P extends primitive, Check> = P & { [p]: Check };

package/src/type/safe/numbers/finite/Finite.d.ts

@@ -0,0 +1,2 @@
+declare const finite: unique symbol;
+declare type Finite<N extends number> = N & { [finite]: 1 };

package/src/type/safe/numbers/finite.d.ts

@@ -0,0 +1 @@
+declare type finite = Finite<numberful>;

package/src/type/safe/numbers/fint.d.ts

@@ -0,0 +1 @@
+declare type fint = Finite<int>;

package/src/type/safe/numbers/int/Int.d.ts

@@ -0,0 +1,2 @@
+declare const int: unique symbol;
+declare type Int<N extends number> = N & { [int]: 1 };

package/src/type/safe/numbers/int.d.ts

@@ -0,0 +1 @@
+declare type int = Int<numberful>;

package/src/type/safe/numbers/numberful.d.ts

@@ -0,0 +1 @@
+declare type numberful = Safe<number, "numberful">;

package/src/type/safe/numbers/polarity/Negative.d.ts

@@ -0,0 +1,4 @@
+declare type Negative<
+  N extends number,
+  Zero = true,
+> = Pole<N, "-", Zero>;

package/src/type/safe/numbers/polarity/Positive.d.ts

@@ -0,0 +1,4 @@
+declare type Positive<
+  N extends number,
+  Zero = true,
+> = Pole<N, "+", Zero>;

package/src/type/safe/numbers/polarity/pole/Pole.d.ts

@@ -0,0 +1,18 @@
+declare const pole: unique symbol;
+declare const min: unique symbol;
+declare type Pole<
+  N extends number,
+  P extends
+  | "-"
+  | "+"
+  ,
+  Zero,
+> =
+  & N
+  & {
+    [pole]: P;
+    [min]: Zero extends false
+      ? P extends "+" ? 1 : -1
+      : 0;
+  }
+;

package/src/type/safe/primitive.d.ts

@@ -0,0 +1,5 @@
+declare type primitive =
+  | string
+  | number
+  | boolean
+;

package/src/type/safe/strings/char.d.ts

@@ -0,0 +1 @@
+declare type char = stringful & PropLength<1>;

package/src/type/safe/strings/length/PropLength.d.ts

@@ -0,0 +1,3 @@
+declare type PropLength<L extends number> = Length<L> extends never
+  ? never
+  : { length: Length<L> };

package/src/type/safe/strings/stringful.d.ts

@@ -0,0 +1 @@
+declare type stringful = Safe<string, "stringful"> & { 0: stringful & PropLength<1> };

package/src/type/utility/interface/construct/Particord.d.ts

@@ -0,0 +1 @@
+declare type Particord<K extends string, V> = Partial<Recordful<K, V>>;

package/src/type/utility/interface/construct/Property.d.ts

@@ -0,0 +1,8 @@
+declare type Property<K extends string, OK extends string, V> = literalful<K> extends never
+  ? Particord<OK, V>
+  : Recordful<K, V>
+  & (
+    literalful<OK> extends never
+      ? object
+      : Particord<OK, V>
+  );

package/src/type/utility/interface/construct/Recordful.d.ts

@@ -0,0 +1,5 @@
+declare type Recordful<K extends string, V> = [V] extends [never]
+  ? never
+  : literalful<K> extends never
+    ? never
+    : Record<literalful<K>, V>;

package/src/type/utility/interface/construct/Table.d.ts

@@ -0,0 +1,3 @@
+declare type Table<V = unknown> = [V] extends [never]
+  ? never
+  : Record<string, V>;

package/src/type/utility/interface/construct/properties/Field.d.ts

@@ -0,0 +1 @@
+declare type Field<K extends string, OK extends string = never> = Property<K, OK, string>;

package/src/type/utility/interface/construct/properties/Flag.d.ts

@@ -0,0 +1 @@
+declare type Flag<OK extends string, K extends string = never> = Property<K, OK, boolean>;

package/src/type/utility/interface/construct/properties/Limit.d.ts

@@ -0,0 +1,8 @@
+declare type Limit<K extends string, OK extends string = never> = Property<K, OK, Boundary>;
+
+type Boundary = Recordful<
+  | "min"
+  | "max"
+  ,
+  number
+>;

package/src/type/utility/interface/construct/properties/List.d.ts

@@ -0,0 +1 @@
+declare type List<K extends string, OK extends string = never> = Property<K, OK, readonly string[]>;

package/src/type/utility/interface/construct/properties/Listish.d.ts

@@ -0,0 +1 @@
+declare type Listish<K extends string, OK extends string = never> = Property<K, OK, Unflat>;

package/src/type/utility/interface/construct/properties/Scalar.d.ts

@@ -0,0 +1 @@
+declare type Scalar<K extends string, OK extends string = never> = Property<K, OK, number>;

package/src/type/utility/interface/construct/tables/FieldTable.d.ts

@@ -0,0 +1 @@
+declare type FieldTable = Table<string>;

package/src/type/utility/interface/construct/tables/FlagTable.d.ts

@@ -0,0 +1 @@
+declare type FlagTable = Table<boolean>;

package/src/type/utility/interface/construct/tables/ListTable.d.ts

@@ -0,0 +1 @@
+declare type ListTable = Table<readonly string[]>;

package/src/type/utility/interface/construct/tables/ListishTable.d.ts

@@ -0,0 +1 @@
+declare type ListishTable = Table<Unflat>;

package/src/type/utility/interface/construct/tables/ScalarTable.d.ts

@@ -0,0 +1 @@
+declare type ScalarTable = Table<number>;

package/src/type/utility/interface/identity/Interface.d.ts

@@ -0,0 +1,80 @@
+declare type Interface<R extends object> = [R] extends [object]
+  ? [Extract<R, readonly unknown[]>] extends [never]
+      ? Required<R> extends Record<infer K, unknown>
+        ? Exclude<K, string> extends never
+          ? literalful<K & string> extends never
+            ? never
+            : R
+          : never
+        : never
+      : never
+  : never;
+
+declare namespace InterfaceTest {
+  export type T = Interface<{ a: 5 }>;
+  export type T0 = Interface<{
+    a: 1;
+    b?: 2;
+  }>;
+  export type T1 = Interface<{
+    a: 1;
+    b: 2;
+  }>;
+  export type T2 = Interface<Record<"a", unknown>>;
+  export type T3 = Interface<Record<"a" | "b", unknown>>;
+}
+
+declare namespace NotInterface {
+  export type N = Interface<never>;
+  export type N0 = Interface<object>;
+  export type N0a = Interface<Record<"a" | "b" | 5, unknown>>;
+  export type N0b = Interface<Record<"a" | "b" | number, unknown>>;
+  export type N0c = Interface<Record<string, unknown>>;
+  export type N0d = Interface<Record<string | number, unknown>>;
+  export type N0e = Interface<Record<stringful, string>>;
+  export type N0f = Interface<Record<stringful | "5", string>>;
+  export type N1 = Interface<[]>;
+  export type N1b = Interface<[1]>;
+  export type N1c = Interface<[1, 1]>;
+  export type N1d = Interface<number[]>;
+  export type N1e = Interface<readonly []>;
+  export type N1f = Interface<readonly [1]>;
+  export type N1g = Interface<readonly [1, 1]>;
+  export type N1h = Interface<readonly number[]>;
+  export type N2 = Interface<()=> void>;
+  export type N2a = Interface<(a: string)=> boolean>;
+  export type N2b = Interface<(a: string)=> string[]>;
+  export type N2c = Interface<(a: string)=> object>;
+  export type N5 = Interface<[] | { a: 1 }>;
+  export type N5a = Interface<[30] | { a: 1 }>;
+  export type N5b = Interface<object | []>;
+  export type N5c = Interface<
+    | {
+      a: 1;
+      b: 2;
+    }
+    | {
+      a: 1;
+      b: 2;
+      c: 2;
+    }
+  >;
+
+  // export type N3 = Interface<stringful>;
+  // export type N3b = Interface<numberful>;
+  // export type N13c = Interface<string>;
+  // export type N13d = Interface<"cool">;
+  // export type N13e = Interface<number>;
+  // export type N13f = Interface<0>;
+  // export type N13g = Interface<1>;
+  // export type N13h = Interface<true>;
+  // export type N13i = Interface<false>;
+  // export type N13j = Interface<boolean>;
+  // export type N14 = Interface<null>;
+  // export type N14a = Interface<undefined>;
+  // export type N14c = Interface<unknown>;
+  // export type N15 = Interface<string | { a: cool }>;
+  // export type N15b = Interface<Record<"a" | "b" | string, unknown>>;
+}
+
+type gg = Extract<{ a: 5 }, readonly unknown[]>;

package/src/type/utility/interface/identity/Keys.d.ts

@@ -0,0 +1,71 @@
+declare type Keys<R extends object> = Interface<R> extends never
+  ? never
+  : keyof Interface<R>;
+
+declare namespace Keys {
+  const RESULT: {
+    positive: typeof POSITIVE | 1;
+    negative: typeof NEGATIVE | 0;
+  };
+
+  export const POSITIVE: {
+    T: Keys<{ a: 5 }>;
+    T0: Keys<{
+      a: 1;
+      b?: 2;
+    }>;
+    T1: Keys<{
+      a: 1;
+      b: 2;
+    }>;
+  } extends Record<string, string> ? "PASS" : never;
+  const s: unique symbol;
+
+  export const NEGATIVE: {
+    N: Keys<never>;
+    N0: Keys<{ [s]: 1 }>;
+    N1: Keys<Record<string, 1>>;
+    N1b: Keys<Record<stringful, 1>>;
+    N1c: Keys<Record<"", 1>>;
+    N1d: Keys<Record<number, 1>>;
+    N2: Keys<Record<stringful | "30", 1>>;
+    N2b: Keys<Record<stringful | "", 1>>;
+    N2c: Keys<Record<number | "", 1>>;
+    N2d: Keys<Record<number | "c", 1>>;
+    N2e: Keys<object>;
+    N2f: Keys<{
+      a: 1;
+      [min]: 1;
+    }>;
+    N3: Keys<[]>;
+    N3a: Keys<readonly [1, 1]>;
+    N4: Keys<
+      | {
+        a: 1;
+        b: 1;
+      }
+      | object
+    >;
+    N5: Keys<[1] | { a: 1 }>;
+    N5a: Keys<
+      | {
+        a: 1;
+        b: 1;
+      }
+      | { c: 1 }
+    >;
+    N5b: Keys<
+      | {
+        a: 1;
+        b: 1;
+      }
+      | { c?: 1 }
+    >;
+
+    // N10: Keys<null>;
+    // N10a: Keys<undefined>;
+    // N10b: Keys<void>;
+    // N10c: Keys<unknown>;
+    // N11c: Keys<Record<string | "30", 1>>;
+  } extends Record<string, never> ? "PASS" : never;
+}

package/src/type/utility/interface/transform/Unrequire.d.ts

@@ -0,0 +1,45 @@
+declare type Unrequire<R extends object, OK extends string> = Interface<R> extends never
+  ? never
+  : literalful<OK> extends never
+    ? never
+    : OK extends keyof R
+      ? Omit<Interface<R>, literalful<OK>> & Partial<Pick<Interface<R>, literalful<OK>>>
+      : never;
+
+declare namespace Unrequire {
+  export type T = Unrequire<{
+    a: 1;
+    b: 1;
+    c: 1;
+  }, "c">;
+  export type T1c = "a" extends keyof T ? true : false; // true
+  export type T1b = "b" extends keyof T ? true : false; // true
+  export type T1 = "c" extends keyof T ? true : false; // true
+  export type T2 = {
+    a: 1;
+    b: 1;
+  } extends T ? true : false; // true
+  export type T2b = {
+    a: 1;
+    b: 1;
+    c: 1;
+  } extends T ? true : false; // true
+  export type T2c = {
+    a: 1;
+    b: 1;
+    c: 1;
+    z: 9001;
+  } extends T ? true : false; // true
+}
+
+declare namespace NotUnrequire {
+  export type N_null = {
+    a: 1;
+    b: 1;
+    c: 1;
+  } extends Unrequire.T ? true : false; // true
+  export type N = {
+    b: 1;
+    c: 1;
+  } extends Unrequire.T ? true : false; // false
+}

package/src/type/utility/iterable/construct/ArrayN.d.ts

@@ -0,0 +1,12 @@
+// TODO: constrain to positive integer
+declare type ArrayN<I, N extends number = 0> = [I] extends [never]
+  ? never
+  : N extends number
+    ? N extends 0
+      ? [...I[]]
+      : ArrayBuilder<I, N>
+    : never;
+
+type ArrayBuilder<I, N extends number, H extends I[] = []> = H["length"] extends N
+  ? [...H, ...I[]]
+  : ArrayBuilder<I, N, [...H, I]>;

package/src/type/utility/iterable/construct/Tuple.d.ts

@@ -0,0 +1,27 @@
+// TODO: constrain to positive integer
+declare type Tuple<I, N extends number = 2> = [I] extends [never]
+  ? never
+  : N extends number
+    ? N extends 0
+      ? readonly []
+      : TupleBuilder<I, Numbered<N>>
+    : never;
+
+type TupleBuilder<I, N, H extends readonly I[] = readonly []> = H["length"] extends N
+  ? H
+  : TupleBuilder<I, N, readonly [...H, I]>;
+
+declare namespace Tuple {
+  export type T = Tuple<string>;
+  export type T0 = Tuple<string, 0>;
+  export type T0a = Tuple<string, 1>;
+  export type T0b = Tuple<string, 3>;
+  export type T1 = Tuple<string | number>;
+  export type T2 = Tuple<string, 2 | 3>;
+  export type T3 = Tuple<string | number, 2 | 3>;
+  export type T4 = Tuple<string, never>;
+  export type T4a = Tuple<string, 0>;
+  export type T4b = Tuple<string, 0 | 1>;
+}
+
+type NN = Numbered<5 | 10>;

package/src/type/utility/iterable/construct/arrays/Arrays.d.ts

@@ -0,0 +1 @@
+declare type Arrayful<I> = ArrayN<I, 1>;

package/src/type/utility/iterable/construct/tuples/Tuples.d.ts

@@ -0,0 +1,9 @@
+declare type Monad<I> = Tuple<I, 1>;
+declare type Triad<I> = Tuple<I, 3>;
+declare type Quad<I> = Tuple<I, 4>;
+declare type Pentad<I> = Tuple<I, 5>;
+declare type Hexad<I> = Tuple<I, 6>;
+declare type Heptad<I> = Tuple<I, 7>;
+declare type Octad<I> = Tuple<I, 8>;
+declare type Nonad<I> = Tuple<I, 9>;
+declare type Decad<I> = Tuple<I, 10>;

package/src/type/utility/iterable/identity/DyadType.d.ts

@@ -0,0 +1,3 @@
+declare type DyadType<A extends readonly unknown[]> = 1 extends ArrayLength<A>
+  ? never
+  : MonadType<A>;

package/src/type/utility/iterable/identity/MonadType.d.ts

@@ -0,0 +1,48 @@
+declare type MonadType<A extends readonly unknown[]> = 0 extends ArrayLength<A>
+  ? never
+  : ArrayType<A>;
+
+declare namespace MonadType {
+  export type T0 = MonadType<[1, 1]>;
+  export type T1 = MonadType<readonly [1, 1]>;
+  export type T2 = MonadType<readonly [1, 1?]>;
+  export type T3 = MonadType<readonly [1?, 1?]>;
+  export type T4 = MonadType<readonly [1?, 1?]>;
+  export type T5 = MonadType<[[]]>;
+  export type T6 = MonadType<string[] | int[]>;
+  export type T7 = MonadType<(string | int)[]>;
+  export type T18 = MonadType<[string] | [5, 10]>;
+  export type T8a = MonadType<Tuple<boolean>>;
+  export type T8b = MonadType<ArrayN<string, 3>>;
+  export type T8c = MonadType<
+    | ArrayN<string, 3>
+    | Tuple<boolean>
+    | [string]
+    | [5, 10]
+    | [5, 13]
+    | readonly [5, 10]
+  >;
+}
+
+declare namespace NotMonadType {
+  export type N12 = MonadType<never>;
+  export type N26 = MonadType<[]>;
+  export type N27 = MonadType<string[]>;
+  export type N28 = MonadType<readonly []>;
+  export type N29 = MonadType<readonly string[]>;
+  export type N30 = MonadType<[5] | []>;
+  export type N30a = MonadType<[5] | string[]>;
+  export type N30b = MonadType<[5] | readonly []>;
+  export type N30c = MonadType<[5] | readonly string[]>;
+  export type N30d = MonadType<
+    | []
+    | [5, 10]
+    | string []
+    | readonly []
+    | readonly [5, 10]
+    | readonly string[]
+  >;
+  export type N31 = MonadType<ArrayN<string>>;
+  export type N32 = MonadType<[string?]>;
+  export type N33 = MonadType<readonly [string?]>;
+}

package/src/type/utility/iterable/identity/TriadType.d.ts

@@ -0,0 +1,3 @@
+declare type TriadType<A extends readonly unknown[]> = 2 extends ArrayLength<A>
+  ? never
+  : DyadType<A>;

package/src/type/utility/iterable/identity/array/ArrayType.d.ts

@@ -0,0 +1,65 @@
+declare type ArrayType<A> = [A] extends [readonly unknown[]] ? A : never;
+
+// tests
+declare namespace ArrayType {
+  export type T0 = ArrayType<[]>;
+  export type T1 = ArrayType<[1, 1]>;
+  export type T2 = ArrayType<string[]>;
+  export type T3 = ArrayType<readonly []>;
+  export type T4 = ArrayType<readonly [1, 1]>;
+  export type T5 = ArrayType<readonly string[]>;
+  export type T6 = ArrayType<[[]]>;
+  export type T7 = ArrayType<string[] | int[]>;
+  export type T8 = ArrayType<(string | int)[]>;
+  export type T9 = ArrayType<
+    | []
+    | [5, 10]
+    | string []
+    | readonly []
+    | readonly [5, 10]
+    | readonly string[]
+  >;
+  export type T10 = ArrayType<[1?, ...string[]]>;
+  export type T11 = ArrayType<[1] | [1, 2?]>;
+}
+
+declare namespace NotArrayType {
+  export type N0 = ArrayType<"">;
+  export type N1 = ArrayType<"test">;
+  export type N2 = ArrayType<string>;
+  export type N3 = ArrayType<boolean>;
+  export type N4 = ArrayType<true>;
+  export type N5 = ArrayType<false>;
+  export type N6 = ArrayType<0>;
+  export type N7 = ArrayType<1>;
+  export type N8 = ArrayType<number>;
+  export type N9 = ArrayType<null>;
+  export type N10 = ArrayType<undefined>;
+  export type N11 = ArrayType<unknown>;
+  export type N12 = ArrayType<never>;
+  export type N13 = ArrayType<void>;
+  export type N14 = ArrayType<()=> void>;
+  export type N15 = ArrayType<(a: string)=> []>;
+  export type N16 = ArrayType<Record<string, unknown>>;
+  export type N17 = ArrayType<Record<number, 5>>;
+  export type N18 = ArrayType<stringful>;
+  export type N19 = ArrayType<{ 0: string }>;
+  export type N20 = ArrayType<{
+    0: string;
+    length: 1;
+  }>;
+  export type N21 = ArrayType<symbol>;
+  export type N22 = ArrayType<Bookmark>;
+  export type N23 = ArrayType<
+    | []
+    | object
+  >;
+  export type N24 = ArrayType<
+    | []
+    | string
+  >;
+  export type N25 = ArrayType<
+    | []
+    | null
+  >;
+}

package/src/type/utility/iterable/identity/array/length/ArrayLength.d.ts

@@ -0,0 +1,16 @@
+declare type ArrayLength<A extends readonly unknown[]> = Length<ArrayType<A>["length"]>;
+
+declare namespace ArrayLength {
+  export type T0 = ArrayLength<[]>;
+  export type T0a = ArrayLength<string[]>;
+  export type T0b = ArrayLength<readonly []>;
+  export type T0d = ArrayLength<readonly string[]>;
+  export type T0c = ArrayLength<[string?, string?]>;
+  export type T1 = ArrayLength<[string] | [string, string?, string?]>;
+  export type T1b = ArrayLength<[string] | [string?, string?, string?]>; // 0 | 1 | 2 | 3 -- empty Tuple -> length: 0 is just 0, so does not consume other possible lengths
+  export type T1c = ArrayLength<string[] | [string, string, string]>; // 0 -- Array -> length: number coerced to length 0 but consumes all other possible lengths
+}
+
+declare namespace NotArrayLength {
+  export type N = ArrayLength<never>;
+}

package/src/type/utility/iterable/transform/Join.d.ts

@@ -0,0 +1,21 @@
+declare type Join<A extends readonly unknown[], D extends string = string> = ArrayType<A> extends never
+  ? never
+  : MonadType<A> extends never
+    ? string
+    : MonadType<A> extends readonly (infer I extends string)[]
+      ? [I] extends [stringful]
+          ? stringful
+          : Extract<I, stringful> extends never
+            ? literalful<I> extends never
+              ? DyadType<MonadType<A>> extends never
+                ? string
+                : literalful<D> extends never
+                  ? [D] extends [stringful]
+                      ? stringful
+                      : string
+                  : stringful
+              : stringful
+            : stringful
+      : never;
+
+type bingus = MonadType<Filepath<2>["nodes"]>;

package/src/type/utility/iterable/transform/Unflat.d.ts

@@ -0,0 +1,3 @@
+declare type Unflat<In = string, RO extends boolean = true> = [In] extends [never]
+  ? never
+  : In | (True<RO> extends never ? In[] : readonly In[]);

package/src/type/utility/iterable/transform/stringarray/Chain.d.ts

@@ -0,0 +1,30 @@
+declare type Chain<
+  A extends readonly string[],
+  D extends string = "/",
+  Reverse extends boolean = false,
+> = literal<D> extends never
+  ? never
+  : D extends D
+    ? ArrayType<A> extends never
+      ? never
+      : ArrayType<A> extends readonly [infer H extends string, ...infer T extends string[]]
+        ? ArrayType<T> extends readonly []
+          ? literalful<H>
+          : True<Reverse> extends never
+            ? `${literalful<H>}${literal<D>}${Chain<ArrayType<T>, literal<D>>}`
+            : `${Chain<ArrayType<T>, literal<D>, True<Reverse>>}${literal<D>}${literalful<H>}`
+        : never
+    : never;
+
+declare namespace Chain {
+  export type T = Chain<["a", "b", "c"]>;
+  export type T0 = Chain<["a", "b", "c"], "">;
+  export type T0a = Chain<["a", "b", "c"], "-">;
+  export type T1 = Chain<["a", "b", "c"], "/", true>;
+  export type T1a = Chain<["a", "b", "c"], ".", true>;
+  export type T2 = Chain<["a", "b" | "bar", "c"]>;
+  export type T2a = Chain<["a" | "foo", "b" | "bar", "c"]>; // 4
+  export type T3 = Chain<["a", "b", "c"], "." | "/">;
+  export type T4 = Chain<["a" | "foo", "b" | "bar", "c"], "." | "/">; // 8
+  export type T5 = Chain<["a" | "foo", "b" | "bar", "c"], "." | "/", true>; // 8
+}