strict-ts-lib-v7.0 0.2.0 → 0.5.0

package/libs-branded/es2016/array-include/index.d.ts

@@ -0,0 +1,131 @@
+interface Array<T> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: T | (import('ts-type-forge').WidenLiteral<T> & {}),
+    fromIndex?: NumberType.ArraySizeArg,
+  ): searchElement is T;
+}
+
+interface ReadonlyArray<T> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: T | (import('ts-type-forge').WidenLiteral<T> & {}),
+    fromIndex?: NumberType.ArraySizeArg,
+  ): searchElement is T;
+}
+
+interface Int8Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Int8,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Uint8Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Uint8,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Uint8ClampedArray<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Uint8,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Int16Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Int16,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Uint16Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Uint16,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Int32Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Int32,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Uint32Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Uint32,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Float32Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Float32,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}
+
+interface Float64Array<TArrayBuffer extends ArrayBufferLike> {
+  /**
+   * Determines whether an array includes a certain element, returning true or false as appropriate.
+   * @param searchElement The element to search for.
+   * @param fromIndex The position in this array at which to begin searching for searchElement.
+   */
+  includes(
+    searchElement: import('ts-type-forge').Float64,
+    fromIndex?: NumberType.TypedArraySizeArg,
+  ): boolean;
+}

package/libs-branded/es2016/full/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference lib="es2016" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />

package/libs-branded/es2016/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference lib="es2015" />
+/// <reference lib="es2016.array.include" />
+/// <reference lib="es2016.intl" />

package/libs-branded/es2016/intl/index.d.ts

@@ -0,0 +1,15 @@
+declare namespace Intl {
+  /**
+   * The `Intl.getCanonicalLocales()` method returns an array containing
+   * the canonical locale names. Duplicates will be omitted and elements
+   * will be validated as structurally valid language tags.
+   *
+   * [MDN](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Intl/getCanonicalLocales)
+   *
+   * @param locale A list of String values for which to get the canonical locale names
+   * @returns An array containing the canonical and validated locale names.
+   */
+  function getCanonicalLocales(
+    locale?: string | readonly string[],
+  ): readonly string[];
+}

package/libs-branded/es2017/arraybuffer/index.d.ts

@@ -0,0 +1,3 @@
+interface ArrayBufferConstructor {
+  new (): ArrayBuffer;
+}

package/libs-branded/es2017/date/index.d.ts

@@ -0,0 +1,21 @@
+interface DateConstructor {
+  /**
+   * Returns the number of milliseconds between midnight, January 1, 1970 Universal Coordinated Time (UTC) (or GMT) and the specified date.
+   * @param year The full year designation is required for cross-century date accuracy. If year is between 0 and 99 is used, then year is assumed to be 1900 + year.
+   * @param monthIndex The month as a number between 0 and 11 (January to December).
+   * @param date The date as a number between 1 and 31.
+   * @param hours Must be supplied if minutes is supplied. A number from 0 to 23 (midnight to 11pm) that specifies the hour.
+   * @param minutes Must be supplied if seconds is supplied. A number from 0 to 59 that specifies the minutes.
+   * @param seconds Must be supplied if milliseconds is supplied. A number from 0 to 59 that specifies the seconds.
+   * @param ms A number from 0 to 999 that specifies the milliseconds.
+   */
+  UTC(
+    year: NumberType.YearEnum,
+    monthIndex?: import('ts-type-forge').MonthIndexEnum,
+    date?: import('ts-type-forge').DateEnum,
+    hours?: import('ts-type-forge').HoursEnum,
+    minutes?: import('ts-type-forge').MinutesEnum,
+    seconds?: import('ts-type-forge').SecondsEnum,
+    ms?: import('ts-type-forge').MillisecondsEnum,
+  ): import('ts-type-forge').SafeUint;
+}

package/libs-branded/es2017/full/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference lib="es2017" />
+/// <reference lib="dom" />
+/// <reference lib="webworker.importscripts" />
+/// <reference lib="scripthost" />
+/// <reference lib="dom.iterable" />

package/libs-branded/es2017/index.d.ts

@@ -0,0 +1,8 @@
+/// <reference lib="es2016" />
+/// <reference lib="es2017.arraybuffer" />
+/// <reference lib="es2017.date" />
+/// <reference lib="es2017.intl" />
+/// <reference lib="es2017.object" />
+/// <reference lib="es2017.sharedmemory" />
+/// <reference lib="es2017.string" />
+/// <reference lib="es2017.typedarrays" />

package/libs-branded/es2017/intl/index.d.ts

@@ -0,0 +1,26 @@
+declare namespace Intl {
+  interface DateTimeFormatPartTypesRegistry {
+    readonly day: unknown;
+    readonly dayPeriod: unknown;
+    readonly era: unknown;
+    readonly hour: unknown;
+    readonly literal: unknown;
+    readonly minute: unknown;
+    readonly month: unknown;
+    readonly second: unknown;
+    readonly timeZoneName: unknown;
+    readonly weekday: unknown;
+    readonly year: unknown;
+  }
+
+  type DateTimeFormatPartTypes = keyof DateTimeFormatPartTypesRegistry;
+
+  interface DateTimeFormatPart {
+    readonly type: DateTimeFormatPartTypes;
+    readonly value: string;
+  }
+
+  interface DateTimeFormat {
+    formatToParts(date?: Date | number): readonly DateTimeFormatPart[];
+  }
+}

package/libs-branded/es2017/object/index.d.ts

@@ -0,0 +1,113 @@
+declare namespace StrictLibInternals {
+  /**
+   * Opens a union of string literals so that it still accepts — and
+   * completes to — the literals, without rejecting the excess keys a
+   * wider object may carry.
+   *
+   * Adds nothing when `K` already contains `string`: `string | (string & {})`
+   * *is* `string`, so the arm would only leave a confusing artifact in
+   * every type computed from it.
+   *
+   * @internal
+   */
+  type WithOpenString<K> = string extends K ? K : K | (string & {});
+
+  /** @internal */
+  type ToObjectKeys<R extends import('ts-type-forge').UnknownRecord> =
+    WithOpenString<ToStr<keyof R>>;
+
+  /** @internal */
+  type ToStr<A> = A extends string ? A : A extends number ? `${A}` : never;
+
+  /** @internal */
+  type PickByValue<R, V> = Pick<
+    R,
+    {
+      [K in keyof R]: R[K] extends V ? K : never;
+    }[keyof R]
+  >;
+
+  /** @internal */
+  type ToObjectEntries<R extends import('ts-type-forge').UnknownRecord> =
+    R extends R
+      ? readonly (
+          | (string extends ToStr<keyof R>
+              ? never
+              : readonly [
+                  string & {},
+                  import('ts-type-forge').WidenLiteral<
+                    import('ts-type-forge').ValueOf<R>
+                  >,
+                ])
+          | {
+              readonly [K in keyof R]: readonly [
+                ToStr<keyof PickByValue<R, R[K]>>,
+                R[K],
+              ];
+              // eslint-disable-next-line @typescript-eslint/no-restricted-types
+            }[import('ts-type-forge').RelaxedExclude<keyof R, symbol>]
+        )[]
+      : never;
+}
+
+interface ObjectConstructor {
+  /**
+   * Returns an array of values of the enumerable own properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  values<T>(o: { readonly [s: string]: T } | ArrayLike<T>): readonly T[];
+
+  /**
+   * Returns an array of values of the enumerable own properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  values(o: {}): readonly unknown[];
+
+  /**
+   * Returns an array of key/values of the enumerable own properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   *
+   * ```ts
+   * const obj = {
+   *   x: 1,
+   *   y: 2,
+   *   z: 2,
+   *   3: 4,
+   * } as const;
+   *
+   * const entries = Object.entries(obj); // (['3', 4] | ['x', 1] | ['y' | 'z', 2] | [string, unknown])[]
+   * ```
+   *
+   */
+  entries<const R extends import('ts-type-forge').UnknownRecord>(
+    object: R,
+  ): StrictLibInternals.ToObjectEntries<R>;
+
+  /**
+   * Returns an array of key/values of the enumerable own properties of an
+   * object
+   *
+   * @param o Object that contains the properties and methods. This can be an
+   *   object that you created or an existing Document Object Model (DOM)
+   *   object.
+   */
+  entries<T>(
+    o: { readonly [s: string]: T } | ArrayLike<T>,
+  ): readonly (readonly [string, T])[];
+
+  /**
+   * Returns an array of key/values of the enumerable own properties of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  entries(o: {}): readonly (readonly [string, unknown])[];
+
+  /**
+   * Returns an object containing all own property descriptors of an object
+   * @param o Object that contains the properties and methods. This can be an object that you created or an existing Document Object Model (DOM) object.
+   */
+  getOwnPropertyDescriptors<T>(o: T): {
+    readonly [P in keyof T]: TypedPropertyDescriptor<T[P]>;
+  } & {
+    readonly [x: string]: PropertyDescriptor;
+  };
+}