strict-ts-lib-v5.4 0.4.0

package/libs/es2018/asyncgenerator/index.d.ts

@@ -0,0 +1,69 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2018.asynciterable" />
+
+interface AsyncGenerator<
+  T = unknown,
+  TReturn = any,
+  TNext = unknown,
+> extends AsyncIterator<T, TReturn, TNext> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(
+    ...args: readonly [] | readonly [TNext]
+  ): Promise<IteratorResult<T, TReturn>>;
+  return(
+    value: TReturn | PromiseLike<TReturn>,
+  ): Promise<IteratorResult<T, TReturn>>;
+  throw(e: unknown): Promise<IteratorResult<T, TReturn>>;
+  [Symbol.asyncIterator](): AsyncGenerator<T, TReturn, TNext>;
+}
+
+interface AsyncGeneratorFunction {
+  /**
+   * Creates a new AsyncGenerator object.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly unknown[]): AsyncGenerator;
+  /**
+   * Creates a new AsyncGenerator object.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly unknown[]): AsyncGenerator;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: number;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: AsyncGenerator;
+}
+
+interface AsyncGeneratorFunctionConstructor {
+  /**
+   * Creates a new AsyncGenerator function.
+   * @param args A list of arguments the function accepts.
+   */
+  new (...args: readonly string[]): AsyncGeneratorFunction;
+  /**
+   * Creates a new AsyncGenerator function.
+   * @param args A list of arguments the function accepts.
+   */
+  (...args: readonly string[]): AsyncGeneratorFunction;
+  /**
+   * The length of the arguments.
+   */
+  readonly length: number;
+  /**
+   * Returns the name of the function.
+   */
+  readonly name: string;
+  /**
+   * A reference to the prototype.
+   */
+  readonly prototype: AsyncGeneratorFunction;
+}

package/libs/es2018/asynciterable/index.d.ts

@@ -0,0 +1,31 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2015.symbol" />
+/// <reference lib="es2015.iterable" />
+
+interface SymbolConstructor {
+  /**
+   * A method that returns the default async iterator for an object. Called by the semantics of
+   * the for-await-of statement.
+   */
+  readonly asyncIterator: unique symbol;
+}
+
+interface AsyncIterator<T, TReturn = any, TNext = undefined> {
+  // NOTE: 'next' is defined using a tuple to ensure we report the correct assignability errors in all places.
+  next(
+    ...args: readonly [] | readonly [TNext]
+  ): Promise<IteratorResult<T, TReturn>>;
+  return?(
+    value?: TReturn | PromiseLike<TReturn>,
+  ): Promise<IteratorResult<T, TReturn>>;
+  throw?(e?: unknown): Promise<IteratorResult<T, TReturn>>;
+}
+
+interface AsyncIterable<T> {
+  [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+interface AsyncIterableIterator<T> extends AsyncIterator<T> {
+  [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}

package/libs/es2018/full/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2018" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />
+/// <reference lib="dom.asynciterable" />

package/libs/es2018/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2017" />
+/// <reference lib="es2018.asynciterable" />
+/// <reference lib="es2018.asyncgenerator" />
+/// <reference lib="es2018.promise" />
+/// <reference lib="es2018.regexp" />
+/// <reference lib="es2018.intl" />

package/libs/es2018/intl/index.d.ts

@@ -0,0 +1,103 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  // http://cldr.unicode.org/index/cldr-spec/plural-rules#TOC-Determining-Plural-Categories
+  type LDMLPluralRule = 'zero' | 'one' | 'two' | 'few' | 'many' | 'other';
+  type PluralRuleType = 'cardinal' | 'ordinal';
+
+  interface PluralRulesOptions {
+    readonly localeMatcher?: 'lookup' | 'best fit' | undefined;
+    readonly type?: PluralRuleType | undefined;
+    readonly minimumIntegerDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+    readonly minimumFractionDigits?:
+      | import('ts-type-forge').UintRange<0, 21>
+      | undefined;
+    readonly maximumFractionDigits?:
+      | import('ts-type-forge').UintRange<0, 21>
+      | undefined;
+    readonly minimumSignificantDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+    readonly maximumSignificantDigits?:
+      | import('ts-type-forge').UintRange<1, 22>
+      | undefined;
+  }
+
+  interface ResolvedPluralRulesOptions {
+    readonly locale: string;
+    readonly pluralCategories: readonly LDMLPluralRule[];
+    readonly type: PluralRuleType;
+    readonly minimumIntegerDigits: import('ts-type-forge').UintRange<1, 22>;
+    readonly minimumFractionDigits: import('ts-type-forge').UintRange<0, 21>;
+    readonly maximumFractionDigits: import('ts-type-forge').UintRange<0, 21>;
+    readonly minimumSignificantDigits?: import('ts-type-forge').UintRange<
+      1,
+      22
+    >;
+    readonly maximumSignificantDigits?: import('ts-type-forge').UintRange<
+      1,
+      22
+    >;
+  }
+
+  interface PluralRules {
+    resolvedOptions(): ResolvedPluralRulesOptions;
+    select(n: number): LDMLPluralRule;
+  }
+
+  interface PluralRulesConstructor {
+    new (
+      locales?: string | readonly string[],
+      options?: PluralRulesOptions,
+    ): PluralRules;
+    (
+      locales?: string | readonly string[],
+      options?: PluralRulesOptions,
+    ): PluralRules;
+    supportedLocalesOf(
+      locales: string | readonly string[],
+      options?: { readonly localeMatcher?: 'lookup' | 'best fit' },
+    ): string[];
+  }
+
+  const PluralRules: PluralRulesConstructor;
+
+  // We can only have one definition for 'type' in TypeScript, and so you can learn where the keys come from here:
+  type ES2018NumberFormatPartType =
+    | 'literal'
+    | 'nan'
+    | 'infinity'
+    | 'percent'
+    | 'integer'
+    | 'group'
+    | 'decimal'
+    | 'fraction'
+    | 'plusSign'
+    | 'minusSign'
+    | 'percentSign'
+    | 'currency'
+    | 'code'
+    | 'symbol'
+    | 'name';
+  type ES2020NumberFormatPartType =
+    | 'compact'
+    | 'exponentInteger'
+    | 'exponentMinusSign'
+    | 'exponentSeparator'
+    | 'unit'
+    | 'unknown';
+  type NumberFormatPartTypes =
+    | ES2018NumberFormatPartType
+    | ES2020NumberFormatPartType;
+
+  interface NumberFormatPart {
+    readonly type: NumberFormatPartTypes;
+    readonly value: string;
+  }
+
+  interface NumberFormat {
+    formatToParts(number?: number | bigint): NumberFormatPart[];
+  }
+}

package/libs/es2018/promise/index.d.ts

@@ -0,0 +1,14 @@
+/// <reference no-default-lib="true"/>
+
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+  /**
+   * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+   * resolved value cannot be modified from the callback.
+   * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+   * @returns A Promise for the completion of the callback.
+   */
+  finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}

package/libs/es2018/regexp/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference no-default-lib="true"/>
+
+interface RegExpMatchArray {
+  readonly groups?: {
+    readonly [key: string]: string;
+  };
+}
+
+interface RegExpExecArray {
+  readonly groups?: {
+    readonly [key: string]: string;
+  };
+}
+
+interface RegExp {
+  /**
+   * Returns a Boolean value indicating the state of the dotAll flag (s) used with a regular expression.
+   * Default is false. Read-only.
+   */
+  readonly dotAll: boolean;
+}

package/libs/es2019/array/index.d.ts

@@ -0,0 +1,94 @@
+/// <reference no-default-lib="true"/>
+
+type FlatArray<Arr, Depth extends number> = {
+  readonly done: Arr;
+  readonly recur: Arr extends ReadonlyArray<infer InnerArr>
+    ? FlatArray<
+        InnerArr,
+        (readonly [
+          -1,
+          0,
+          1,
+          2,
+          3,
+          4,
+          5,
+          6,
+          7,
+          8,
+          9,
+          10,
+          11,
+          12,
+          13,
+          14,
+          15,
+          16,
+          17,
+          18,
+          19,
+          20,
+        ])[Depth]
+      >
+    : Arr;
+}[Depth extends -1 ? 'done' : 'recur'];
+
+interface ReadonlyArray<T> {
+  /**
+   * Calls a defined callback function on each element of an array. Then, flattens the result into
+   * a new array.
+   * This is identical to a map followed by flat with depth 1.
+   *
+   * @param callback A function that accepts up to three arguments. The flatMap method calls the
+   * callback function one time for each element in the array.
+   * @param thisArg An object to which the this keyword can refer in the callback function. If
+   * thisArg is omitted, undefined is used as the this value.
+   */
+  flatMap<U, This = undefined>(
+    callback: (
+      this: This,
+      value: T,
+      index: number,
+      array: readonly T[],
+    ) => U | ReadonlyArray<U>,
+    thisArg?: This,
+  ): U[];
+
+  /**
+   * Returns a new array with all sub-array elements concatenated into it recursively up to the
+   * specified depth.
+   *
+   * @param depth The maximum recursion depth
+   */
+  flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
+}
+
+interface Array<T> {
+  /**
+   * Calls a defined callback function on each element of an array. Then, flattens the result into
+   * a new array.
+   * This is identical to a map followed by flat with depth 1.
+   *
+   * @param callback A function that accepts up to three arguments. The flatMap method calls the
+   * callback function one time for each element in the array.
+   * @param thisArg An object to which the this keyword can refer in the callback function. If
+   * thisArg is omitted, undefined is used as the this value.
+   */
+  flatMap<U, This = undefined>(
+    callback: (
+      this: This,
+      value: T,
+      index: number,
+      array: readonly T[],
+    ) => U | ReadonlyArray<U>,
+    thisArg?: This,
+  ): U[];
+
+  /**
+   * Returns a new array with all sub-array elements concatenated into it recursively up to the
+   * specified depth.
+   *
+   * @param depth The maximum recursion depth
+   */
+  flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
+}

package/libs/es2019/full/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2019" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />
+/// <reference lib="dom.asynciterable" />

package/libs/es2019/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+/// <reference lib="es2018" />
+/// <reference lib="es2019.array" />
+/// <reference lib="es2019.object" />
+/// <reference lib="es2019.string" />
+/// <reference lib="es2019.symbol" />
+/// <reference lib="es2019.intl" />

package/libs/es2019/intl/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference no-default-lib="true"/>
+
+declare namespace Intl {
+  interface DateTimeFormatPartTypesRegistry {
+    readonly unknown: unknown;
+  }
+}

package/libs/es2019/object/index.d.ts

@@ -0,0 +1,143 @@
+/// <reference no-default-lib="true"/>
+/// <reference lib="es5" />
+
+/// <reference lib="es2015.iterable" />
+
+declare namespace StrictLibInternals {
+  type RecursionLimit = 20;
+
+  /**
+   * - `[['x', 1], ['y', 3]]` -> `{ x: 1, y: 3 }`
+   *
+   * @internal
+   */
+  export type EntriesToObject<
+    Entries extends readonly (readonly [PropertyKey, unknown])[],
+  > = import('ts-type-forge').MergeIntersection<
+    EntriesToObjectImpl<{}, Entries>
+  >;
+
+  /** @internal */
+  type EntriesToObjectImpl<
+    R,
+    Entries extends readonly (readonly [PropertyKey, unknown])[],
+  > = import('ts-type-forge').TypeEq<Entries['length'], 0> extends true
+    ? R
+    : EntriesToObjectImpl<
+        R & { [key in Entries[0][0]]: Entries[0][1] },
+        import('ts-type-forge').List.Tail<Entries>
+      >;
+
+  /**
+   * - `['x' | 'y' | 'z', number][]]` -> `'x' | 'y' | 'z'`
+   * - `[['a' | 'b' | 'c', number], ...['x' | 'y' | 'z', number][]]` -> `'a' | 'b' |
+   *   'c' | 'x' | 'y' | 'z'`
+   *
+   * @internal
+   *
+   * @note 上の2個目の例に対応するためには、無限長の Entries に対しても再帰を回す必要があるが、
+   * 止めるタイミングを決められないので再帰制限を設けている。
+   */
+  export type KeysOfEntries<
+    Entries extends readonly (readonly [PropertyKey, unknown])[],
+  > = KeysOfEntriesImpl<never, Entries, RecursionLimit>;
+
+  /** @internal */
+  type KeysOfEntriesImpl<
+    K,
+    Entries extends readonly (readonly [PropertyKey, unknown])[],
+    RemainingNumRecursions extends number,
+  > = import('ts-type-forge').TypeEq<RemainingNumRecursions, 0> extends true
+    ? K
+    : import('ts-type-forge').TypeEq<Entries['length'], 0> extends true
+      ? K
+      : KeysOfEntriesImpl<
+          K | Entries[0][0],
+          import('ts-type-forge').List.Tail<Entries>,
+          import('ts-type-forge').Decrement<RemainingNumRecursions>
+        >;
+
+  /** @internal */
+  export type ValuesOfEntries<
+    Entries extends readonly (readonly [PropertyKey, unknown])[],
+  > = ValuesOfEntriesImpl<never, Entries, RecursionLimit>;
+
+  /** @internal */
+  type ValuesOfEntriesImpl<
+    K,
+    Entries extends readonly (readonly [PropertyKey, unknown])[],
+    RemainingNumRecursions extends number,
+  > = import('ts-type-forge').TypeEq<RemainingNumRecursions, 0> extends true
+    ? K
+    : import('ts-type-forge').TypeEq<Entries['length'], 0> extends true
+      ? K
+      : ValuesOfEntriesImpl<
+          K | Entries[0][1],
+          import('ts-type-forge').List.Tail<Entries>,
+          import('ts-type-forge').Decrement<RemainingNumRecursions>
+        >;
+
+  /** @internal */
+  export type PartialIfKeyIsUnion<K, T> =
+    import('ts-type-forge').IsUnion<K> extends true ? Partial<T> : T;
+}
+
+interface ObjectConstructor {
+  /**
+   * Returns an object created by key-value entries for properties and methods
+   * @param entries An iterable object that contains key-value entries for properties and methods.
+   *
+   * @example
+   *   const entries = [
+   *     ['x', 1],
+   *     ['y', 3],
+   *   ] as const satisfies [['x', 1], ['y', 3]];
+   *
+   *   const obj = Object.fromEntries(entries) satisfies { x: 1; y: 3 };
+   *
+   * @note `entries` がタプル型の場合には key-value の組み合わせも反映した型にする。
+   * そうでない場合、 `K` が union 型の場合、`entries` がそのすべてを網羅しているとは限らないため、
+   * `fromEntries` の返り値型がその union 要素すべてを含む型になってしまわないように `Partial` を付けている。
+   *
+   * index signature の record では `Object.entries` の key が `string` そのものになり
+   * union ではなくなるため、`Partial` は付かない（`WithOpenString` 参照）。
+   */
+  fromEntries<
+    const Entries extends readonly (readonly [PropertyKey, unknown])[],
+  >(
+    entries: Entries,
+  ): import('ts-type-forge').IsFixedLengthList<Entries> extends true
+    ? StrictLibInternals.EntriesToObject<Entries>
+    : StrictLibInternals.PartialIfKeyIsUnion<
+        StrictLibInternals.KeysOfEntries<Entries>,
+        import('ts-type-forge').MutableRecord<
+          StrictLibInternals.KeysOfEntries<Entries>,
+          StrictLibInternals.ValuesOfEntries<Entries>
+        >
+      >;
+
+  /**
+   * Returns an object created by key-value entries for properties and methods
+   * @param entries An iterable object that contains key-value entries for properties and methods.
+   *
+   * @example
+   *   const entries: readonly (readonly ['x' | 'y' | 'z' | 4, 1 | 2 | 3])[] = [
+   *     ['x', 1],
+   *     ['y', 2],
+   *     ['z', 3],
+   *     [4, 3],
+   *   ] as const;
+   *
+   *   const obj = Object.fromEntries(entries); // Record<'x' | 'y' | 'z' | 4, 1 | 2 | 3>
+   *
+   */
+  fromEntries<K extends PropertyKey, V>(
+    entries: Iterable<readonly [K, V]>,
+  ): import('ts-type-forge').MutableRecord<K, V>;
+
+  /**
+   * Returns an object created by key-value entries for properties and methods
+   * @param entries An iterable object that contains key-value entries for properties and methods.
+   */
+  fromEntries(entries: Iterable<readonly unknown[]>): unknown;
+}

package/libs/es2019/string/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference no-default-lib="true"/>
+
+interface String {
+  /** Removes the trailing white space and line terminator characters from a string. */
+  trimEnd(): string;
+
+  /** Removes the leading white space and line terminator characters from a string. */
+  trimStart(): string;
+
+  /**
+   * Removes the leading white space and line terminator characters from a string.
+   * @deprecated A legacy feature for browser compatibility. Use `trimStart` instead
+   */
+  trimLeft(): string;
+
+  /**
+   * Removes the trailing white space and line terminator characters from a string.
+   * @deprecated A legacy feature for browser compatibility. Use `trimEnd` instead
+   */
+  trimRight(): string;
+}

package/libs/es2019/symbol/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference no-default-lib="true"/>
+
+interface Symbol {
+  /**
+   * Expose the [[Description]] internal slot of a symbol directly.
+   */
+  readonly description: string | undefined;
+}