@eslint-react/jsx 0.8.6-beta.0 → 0.8.6-beta.3

package/node_modules/@eslint-react/tools/dist/index.d.mts

@@ -0,0 +1,173 @@
+import * as Chunk from 'effect/Chunk';
+export { Chunk };
+import * as Data from 'effect/Data';
+export { Data };
+import * as Either from 'effect/Either';
+export { Either as E };
+import * as Equal from 'effect/Equal';
+export { Equal };
+import * as Function$1 from 'effect/Function';
+export { Function$1 as F };
+import * as List from 'effect/List';
+export { List };
+import * as MutableList from 'effect/MutableList';
+export { MutableList as MutList };
+import * as MutableRef from 'effect/MutableRef';
+export { MutableRef as MutRef };
+import * as Option from 'effect/Option';
+export { Option as O };
+import * as ReadonlyRecord from 'effect/ReadonlyRecord';
+export { ReadonlyRecord as Record };
+
+/**
+ * Returns the element type of an array.
+ * @since 0.4.0
+ * @template T type of the array elements.
+ * @param arr The array to get the element type from.
+ * @returns The element type of the array.
+ */
+type ArrayElement<A> = A extends readonly (infer T)[] ? T : never;
+/**
+ * Returns a new array with unique values based on the given function.
+ * @since 0.0.1
+ * @template T type of the array elements.
+ * @param arr The array to filter.
+ * @param fn The function to get the value to compare.
+ * @returns new array with unique values.
+ */
+declare function uniqueBy<T>(arr: T[], fn: (x: T) => unknown): T[];
+
+/**
+ * @since 0.0.1
+ */
+declare const noop: () => void;
+/**
+ * @since 0.0.1
+ * @param a The value to return.
+ */
+declare const identity: <T>(a: T) => T;
+/**
+ * @param a The value to infer.
+ * @since 0.0.1
+ */
+declare const asConst: <const T>(a: T) => T;
+
+/**
+ * @since 0.4.0
+ */
+type Cast<X, Y> = X extends Y ? X : Y;
+/**
+ * @since 0.0.1
+ */
+type Remap<T> = {
+    [P in keyof T]: T[P];
+};
+/**
+ * @since 0.0.1
+ */
+type Pretty<T> = {
+    [P in keyof T]: T[P];
+} & {};
+
+/**
+ * Infers embedded primitive type of any type
+ * @since 0.0.1
+ * @param T Type to infer
+ * @returns Embedded type of {@link TType}
+ * @example
+ * type Result = Narrow<['foo', 'bar', 1]>
+ * @see https://twitter.com/hd_nvim/status/1578567206190780417
+ */
+type Narrow<TType> = {
+    [K in keyof TType]: Narrow<TType[K]>;
+} | (TType extends [] ? [] : never) | (TType extends Function ? TType : never) | (TType extends bigint | boolean | number | string ? TType : never);
+/**
+ * Infers embedded primitive type of any type
+ * Same as `as const` but without setting the object as readonly and without needing the user to use it.
+ * @since 0.0.1
+ * @param a Value to infer
+ * @returns Value with embedded type inferred
+ * @example
+ * const result = narrow(['foo', 'bar', 1])
+ */
+declare const narrow: <TType>(a: Narrow<TType>) => Narrow<TType>;
+
+/**
+ * @since 0.3.4
+ */
+type FieldDiff<T1, T2> = Omit<T1, keyof T2> | Omit<T2, keyof T1>;
+/**
+ * @since 0.3.4
+ */
+type Combine<T1, T2> = Pretty<{
+    [K in keyof (T1 | T2)]: T1[K] | T2[K];
+} & Partial<T1 & T2>>;
+/**
+ * A record with loose keys.
+ * @template T The type of the values.
+ * @since 0.4.0
+ */
+type LooseRecord<T> = Record<PropertyKey, T>;
+type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};
+type FromEntries<T> = T extends [infer Key, unknown][] ? {
+    [K in Cast<Key, string>]: Extract<ArrayElement<T>, [K, unknown]>[1];
+} : {
+    [key in string]: unknown;
+};
+type FromEntriesWithReadOnly<T> = FromEntries<DeepWriteable<T>>;
+/**
+ * type-safe version of Object.fromEntries
+ * @param entries The entries to create the object from.
+ * @returns The object created from the entries.
+ * @since 0.4.0
+ */
+declare const fromEntries: <T extends [PropertyKey, unknown][]>(entries: T) => FromEntries<T>;
+/**
+ * type-safe version of Object.fromEntries
+ * @param entries The entries to create the object from.
+ * @returns The object created from the entries.
+ * @since 0.4.0
+ */
+declare const fromEntriesWithReadOnly: <T extends [PropertyKey, unknown][]>(entries: T) => FromEntries<DeepWriteable<T>>;
+/**
+ * type-safe version of Object.entries
+ * @param value The value to get the entries from.
+ * @returns The entries of the value.
+ * @since 0.4.0
+ */
+declare const entries: <T extends LooseRecord<unknown>>(value: T) => { [K in keyof T]-?: [K, T[K]]; }[keyof T][];
+/**
+ * type-safe version of Object.keys
+ * @param value The value to get the keys from.
+ * @returns The keys of the value.
+ * @since 0.4.0
+ */
+declare const keys: <T extends LooseRecord<unknown>>(value: T) => (keyof T)[];
+/**
+ * type-safe version of Object.values
+ * @param value The value to get the values from.
+ * @returns The values of the value.
+ * @since 0.4.0
+ */
+declare const values: <T extends LooseRecord<unknown>>(value: T) => T[keyof T][];
+
+/**
+ * @since 0.0.1
+ * @template T The type to get the union from
+ * @example
+ * type Result = UnionFromTuple<['foo', 'bar', 1]>
+ * // Result = 'foo' | 'bar' | 1
+ */
+type UnionFromTuple<T> = T extends (infer U)[] ? U : never;
+/**
+ * @since 0.0.1
+ * @template T The type to get the intersection from
+ * @example
+ * type Result = IntersectionFromTuple<['foo', 'bar', 1]>
+ * // Result = 'foo' & 'bar' & 1
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+export { type ArrayElement, type Cast, type Combine, type DeepWriteable, type FieldDiff, type FromEntries, type FromEntriesWithReadOnly, type LooseRecord, type Narrow, type Pretty, type Remap, type UnionFromTuple, type UnionToIntersection, asConst, entries, fromEntries, fromEntriesWithReadOnly, identity, keys, narrow, noop, uniqueBy, values };

package/node_modules/@eslint-react/tools/dist/index.d.ts

@@ -0,0 +1,173 @@
+import * as Chunk from 'effect/Chunk';
+export { Chunk };
+import * as Data from 'effect/Data';
+export { Data };
+import * as Either from 'effect/Either';
+export { Either as E };
+import * as Equal from 'effect/Equal';
+export { Equal };
+import * as Function$1 from 'effect/Function';
+export { Function$1 as F };
+import * as List from 'effect/List';
+export { List };
+import * as MutableList from 'effect/MutableList';
+export { MutableList as MutList };
+import * as MutableRef from 'effect/MutableRef';
+export { MutableRef as MutRef };
+import * as Option from 'effect/Option';
+export { Option as O };
+import * as ReadonlyRecord from 'effect/ReadonlyRecord';
+export { ReadonlyRecord as Record };
+
+/**
+ * Returns the element type of an array.
+ * @since 0.4.0
+ * @template T type of the array elements.
+ * @param arr The array to get the element type from.
+ * @returns The element type of the array.
+ */
+type ArrayElement<A> = A extends readonly (infer T)[] ? T : never;
+/**
+ * Returns a new array with unique values based on the given function.
+ * @since 0.0.1
+ * @template T type of the array elements.
+ * @param arr The array to filter.
+ * @param fn The function to get the value to compare.
+ * @returns new array with unique values.
+ */
+declare function uniqueBy<T>(arr: T[], fn: (x: T) => unknown): T[];
+
+/**
+ * @since 0.0.1
+ */
+declare const noop: () => void;
+/**
+ * @since 0.0.1
+ * @param a The value to return.
+ */
+declare const identity: <T>(a: T) => T;
+/**
+ * @param a The value to infer.
+ * @since 0.0.1
+ */
+declare const asConst: <const T>(a: T) => T;
+
+/**
+ * @since 0.4.0
+ */
+type Cast<X, Y> = X extends Y ? X : Y;
+/**
+ * @since 0.0.1
+ */
+type Remap<T> = {
+    [P in keyof T]: T[P];
+};
+/**
+ * @since 0.0.1
+ */
+type Pretty<T> = {
+    [P in keyof T]: T[P];
+} & {};
+
+/**
+ * Infers embedded primitive type of any type
+ * @since 0.0.1
+ * @param T Type to infer
+ * @returns Embedded type of {@link TType}
+ * @example
+ * type Result = Narrow<['foo', 'bar', 1]>
+ * @see https://twitter.com/hd_nvim/status/1578567206190780417
+ */
+type Narrow<TType> = {
+    [K in keyof TType]: Narrow<TType[K]>;
+} | (TType extends [] ? [] : never) | (TType extends Function ? TType : never) | (TType extends bigint | boolean | number | string ? TType : never);
+/**
+ * Infers embedded primitive type of any type
+ * Same as `as const` but without setting the object as readonly and without needing the user to use it.
+ * @since 0.0.1
+ * @param a Value to infer
+ * @returns Value with embedded type inferred
+ * @example
+ * const result = narrow(['foo', 'bar', 1])
+ */
+declare const narrow: <TType>(a: Narrow<TType>) => Narrow<TType>;
+
+/**
+ * @since 0.3.4
+ */
+type FieldDiff<T1, T2> = Omit<T1, keyof T2> | Omit<T2, keyof T1>;
+/**
+ * @since 0.3.4
+ */
+type Combine<T1, T2> = Pretty<{
+    [K in keyof (T1 | T2)]: T1[K] | T2[K];
+} & Partial<T1 & T2>>;
+/**
+ * A record with loose keys.
+ * @template T The type of the values.
+ * @since 0.4.0
+ */
+type LooseRecord<T> = Record<PropertyKey, T>;
+type DeepWriteable<T> = {
+    -readonly [P in keyof T]: DeepWriteable<T[P]>;
+};
+type FromEntries<T> = T extends [infer Key, unknown][] ? {
+    [K in Cast<Key, string>]: Extract<ArrayElement<T>, [K, unknown]>[1];
+} : {
+    [key in string]: unknown;
+};
+type FromEntriesWithReadOnly<T> = FromEntries<DeepWriteable<T>>;
+/**
+ * type-safe version of Object.fromEntries
+ * @param entries The entries to create the object from.
+ * @returns The object created from the entries.
+ * @since 0.4.0
+ */
+declare const fromEntries: <T extends [PropertyKey, unknown][]>(entries: T) => FromEntries<T>;
+/**
+ * type-safe version of Object.fromEntries
+ * @param entries The entries to create the object from.
+ * @returns The object created from the entries.
+ * @since 0.4.0
+ */
+declare const fromEntriesWithReadOnly: <T extends [PropertyKey, unknown][]>(entries: T) => FromEntries<DeepWriteable<T>>;
+/**
+ * type-safe version of Object.entries
+ * @param value The value to get the entries from.
+ * @returns The entries of the value.
+ * @since 0.4.0
+ */
+declare const entries: <T extends LooseRecord<unknown>>(value: T) => { [K in keyof T]-?: [K, T[K]]; }[keyof T][];
+/**
+ * type-safe version of Object.keys
+ * @param value The value to get the keys from.
+ * @returns The keys of the value.
+ * @since 0.4.0
+ */
+declare const keys: <T extends LooseRecord<unknown>>(value: T) => (keyof T)[];
+/**
+ * type-safe version of Object.values
+ * @param value The value to get the values from.
+ * @returns The values of the value.
+ * @since 0.4.0
+ */
+declare const values: <T extends LooseRecord<unknown>>(value: T) => T[keyof T][];
+
+/**
+ * @since 0.0.1
+ * @template T The type to get the union from
+ * @example
+ * type Result = UnionFromTuple<['foo', 'bar', 1]>
+ * // Result = 'foo' | 'bar' | 1
+ */
+type UnionFromTuple<T> = T extends (infer U)[] ? U : never;
+/**
+ * @since 0.0.1
+ * @template T The type to get the intersection from
+ * @example
+ * type Result = IntersectionFromTuple<['foo', 'bar', 1]>
+ * // Result = 'foo' & 'bar' & 1
+ */
+type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
+
+export { type ArrayElement, type Cast, type Combine, type DeepWriteable, type FieldDiff, type FromEntries, type FromEntriesWithReadOnly, type LooseRecord, type Narrow, type Pretty, type Remap, type UnionFromTuple, type UnionToIntersection, asConst, entries, fromEntries, fromEntriesWithReadOnly, identity, keys, narrow, noop, uniqueBy, values };