@layerzerolabs/typescript-utils 0.0.0

package/dist/withRequired.d.ts

@@ -0,0 +1,7 @@
+export type WithRequired<T, K extends keyof T> = T & {
+    [P in K]-?: T[P];
+};
+export type AllRequired<T> = {
+    [K in keyof T]-?: T[K];
+};
+//# sourceMappingURL=withRequired.d.ts.map

package/dist/withRequired.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withRequired.d.ts","sourceRoot":"","sources":["../src/withRequired.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,CAAC,IAAI,CAAC,GAAG;KAAG,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CAAE,CAAC;AAE1E,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;KACxB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;CACzB,CAAC"}

package/dist/withRequired.js

@@ -0,0 +1,4 @@
+import './62A6WP5R.js';
+import './4RNWLMHM.js';
+//# sourceMappingURL=withRequired.js.map
+//# sourceMappingURL=withRequired.js.map

package/dist/withRequired.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"withRequired.js"}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@layerzerolabs/typescript-utils",
+  "version": "0.0.0",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "require": "./dist/index.cjs",
+    "import": "./dist/index.js",
+    "default": "./dist/index.cjs"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "devDependencies": {
+    "tsup": "^8.4.0",
+    "vitest": "^3.2.3",
+    "@layerzerolabs/tsup-configuration": "0.0.1",
+    "@layerzerolabs/typescript-configuration": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "checkdeps": "pnpm --filter @layerzerolabs/depcheck run depcheck validate --catalog --missing-dependencies --only $npm_package_name",
+    "clean": "rm -rf ./node_modules .turbo ./dist",
+    "lint": "eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)"
+  }
+}

package/src/advancedRecord.ts

@@ -0,0 +1,20 @@
+export type AdvancedRecord<T = any, U = any> = {
+    readonly [key: string]: readonly [T, U];
+};
+
+export type DeepWritable<T> = { -readonly [P in keyof T]: DeepWritable<T[P]> };
+
+export type AdvancedRecordLookup<
+    AR extends AdvancedRecord | undefined,
+    KeyToFind,
+> = AR extends AdvancedRecord
+    ? {
+          [P in keyof AR]: AR[P] extends readonly [infer K, infer V]
+              ? KeyToFind extends DeepWritable<K>
+                  ? V
+                  : DeepWritable<K> extends KeyToFind
+                    ? V
+                    : never
+              : never;
+      }[keyof AR]
+    : never;

package/src/branded.ts

@@ -0,0 +1,19 @@
+const tag = '___tag___';
+/**
+ * Creates a branded type of {@link T} with the brand {@link U}.
+ *
+ * @param T - Type to brand
+ * @param U - Label
+ * @returns Branded type
+ *
+ * @example
+ * type Result = Branded<string, 'foo'>
+ * //   ^? type Result = string & { [symbol]: 'foo' }
+ */
+export type Branded<T, U> = T & { [tag]: U };
+/**
+ * Represents a percentage as a decimal value. For example, 25% is represented as 0.25
+ */
+export type Percent = number; // Branded<number, 'percent'>
+
+export type BrandedError<T extends string> = Branded<Error, T>;

package/src/constructor.ts

@@ -0,0 +1 @@
+export type Constructor<T> = { new (...args: any[]): T };

package/src/deep.test-d.ts

@@ -0,0 +1,33 @@
+import { expectTypeOf, test } from 'vitest';
+
+import type { Branded } from './branded';
+import type { DeepOptional } from './deep';
+
+test('DeepOptional', () => {
+    // 1 level
+    type A = DeepOptional<{ a: string; b: number }>;
+    expectTypeOf<A>().toEqualTypeOf<{ a?: string; b?: number }>();
+
+    // 2 levels
+    type B = DeepOptional<{ a: { c: string }; b: number }>;
+    expectTypeOf<B>().toEqualTypeOf<{ a?: { c?: string }; b?: number }>();
+
+    // 1 level with brand tag
+    type obj = { a: string; b: number };
+    type branded = Branded<obj, 'foo'>;
+    type C = DeepOptional<branded>;
+    expectTypeOf<C>().toEqualTypeOf<{ a?: string; b?: number; ___tag___: 'foo' }>();
+
+    // 2 levels with brand tag
+    type obj2 = { a: branded; b: number };
+    type D = DeepOptional<Branded<obj2, 'foo2'>>;
+    expectTypeOf<D>().toEqualTypeOf<{
+        a?: {
+            a?: string;
+            b?: number;
+            ___tag___: 'foo';
+        };
+        b?: number;
+        ___tag___: 'foo2';
+    }>();
+});

package/src/deep.ts

@@ -0,0 +1,26 @@
+import type { Prettify } from './viem';
+
+/**
+ * Copy the brand tag from the branded.ts file, can't import it to keep it hidden from library users
+ */
+const brandTag = '___tag___';
+
+export type DeepRequire<T> = {
+    [P in keyof T]-?: DeepRequire<T[P]>;
+};
+
+export type DeepOptional<T> = T extends { [brandTag]: infer V }
+    ? Prettify<
+          { [brandTag]: V } & {
+              [P in keyof T]?: DeepOptional<T[P]>;
+          }
+      >
+    : {
+          [P in keyof T]?: DeepOptional<T[P]>;
+      };
+
+export type DeepUnion<T, U> =
+    | {
+          [P in keyof T]: DeepUnion<T[P], U>;
+      }
+    | U;

package/src/disallowedAny.ts

@@ -0,0 +1,5 @@
+type IsAnyInner<T> = T extends never ? true : false;
+
+export type IsAny<T> =
+    IsAnyInner<T> extends true ? false : IsAnyInner<T> extends false ? false : true;
+export type DisallowedAny<T> = IsAny<T> extends true ? never : T;

package/src/identity.ts

@@ -0,0 +1,2 @@
+// Wraps types and property access with 1-arity which enables creating interfaces
+export type Identity<T> = T;

package/src/index.ts

@@ -0,0 +1,15 @@
+export * from './advancedRecord';
+export * from './branded';
+export * from './constructor';
+export * from './deep';
+export * from './disallowedAny';
+export * from './identity';
+export * from './lastOf';
+export * from './merge';
+export * from './methodOf';
+export * from './removeNever';
+export * from './strings';
+export * from './tuples';
+export * from './valueOf';
+export * from './viem';
+export * from './withRequired';

package/src/lastOf.ts

@@ -0,0 +1,15 @@
+export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (
+    k: infer I,
+) => void
+    ? I
+    : never;
+
+export type LastOf<T> =
+    UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;
+
+type Prepend<T, U extends any[]> = [T, ...U];
+
+export type UnionToArray<T, U extends any[] = []> =
+    LastOf<T> extends never ? U : UnionToArray<Exclude<T, LastOf<T>>, Prepend<LastOf<T>, U>>;
+
+export type RestOf<T> = Exclude<T, LastOf<T>>;

package/src/merge.ts

@@ -0,0 +1,13 @@
+import type { Prettify } from './viem';
+
+export type Merge<T, U> = {} extends T
+    ? U
+    : {} extends U
+      ? T
+      : Prettify<
+            {
+                [key in keyof T]: key extends keyof U ? U[key] : T[key];
+            } & {
+                [key in keyof U]: U[key];
+            }
+        >;

package/src/methodOf.ts

@@ -0,0 +1,7 @@
+export type MethodOf<T> = {
+    [key in keyof T]: T[key] extends (...args: any[]) => any ? T[key] : never;
+}[keyof T];
+
+export type MethodNameOf<T> = {
+    [key in keyof T]: T[key] extends (...args: any[]) => any ? key : never;
+}[keyof T];

package/src/removeNever.ts

@@ -0,0 +1,3 @@
+export type RemoveNever<T> = {
+    [K in keyof T as T[K] extends never ? never : K]: T[K];
+};

package/src/strings.test-d.ts

@@ -0,0 +1,32 @@
+import { expectTypeOf, test } from 'vitest';
+
+import type { HexStringIsTrimmed, StringWithoutSuffix } from './strings';
+
+test('StringWithoutSuffix', () => {
+    type A = StringWithoutSuffix<'hello', 'world'>;
+    expectTypeOf<A>().toBeString();
+
+    type B = StringWithoutSuffix<'hello', 'lo'>;
+    expectTypeOf<B>().toBeNever();
+
+    // Multiple suffixes test:
+    type C = StringWithoutSuffix<'hello', 'lo' | 'world'>;
+    expectTypeOf<C>().toBeNever();
+
+    type D = StringWithoutSuffix<'hello world', 'lo' | 'world'>;
+    expectTypeOf<D>().toBeNever();
+
+    type E = StringWithoutSuffix<'hello world!', 'lo' | 'world'>;
+    expectTypeOf<E>().toBeString();
+});
+
+test('HexStringIsTrimmed', () => {
+    type A = HexStringIsTrimmed<'0x0'>;
+    expectTypeOf<A>().toExtend<true>();
+
+    type B = HexStringIsTrimmed<'0x00'>;
+    expectTypeOf<B>().toExtend<false>();
+
+    type C = HexStringIsTrimmed<'0x'>;
+    expectTypeOf<C>().toExtend<false>();
+});

package/src/strings.ts

@@ -0,0 +1,42 @@
+import type { Branded } from './branded';
+
+/**
+ * Guarantees that a string does not end with a suffix.
+ * You can remove multiple suffixes by using a union.
+ *
+ * @example
+ * type A = StringWithoutSuffix<'hello', 'world'>; // 'hello'
+ * type B = StringWithoutSuffix<'hello', 'lo'>; // never
+ * type C = StringWithoutSuffix<'hello world', 'lo' | 'world'>; // never
+ */
+export type StringWithoutSuffix<
+    T extends string,
+    Suffix extends string,
+> = T extends `${infer _}${Suffix}` ? never : T;
+
+export type HexString = `0x${string}`;
+
+export declare const _NormalizedHexString: unique symbol;
+
+export type NormalizedHexString = Branded<typeof _NormalizedHexString, 'NormalizedHexString'>;
+
+/**
+ * Guarantees that a hex string is trimmed.
+ *
+ * @example
+ * type A = HexStringIsTrimmed<'0x0'>; // true
+ * type B = HexStringIsTrimmed<'0x00'>; // false
+ * type C = HexStringIsTrimmed<'0x'>; // false
+ * type D = HexStringIsTrimmed<'0x100'>; // true
+ */
+export type HexStringIsTrimmed<T extends HexString> = T extends '0x0'
+    ? true
+    : T extends '0x'
+      ? false
+      : T extends `0x0${string}`
+        ? false
+        : true;
+
+export declare const _NumberString: unique symbol;
+
+export type DecimalString = Branded<typeof _NumberString, 'DecimalString'>;

package/src/tuples.ts

@@ -0,0 +1,49 @@
+import type { BrandedError } from './branded';
+
+//check that the tuple T uses every type in the union K at least once
+export type IsComplete<
+    T extends readonly (string | number | symbol)[],
+    K extends string | number | symbol,
+> = Exclude<K, T[number]> extends never ? true : false;
+
+export type TryGetDuplicate<
+    T extends readonly (string | number | symbol)[],
+    Seen extends (string | number | symbol)[] = [],
+> = T extends [infer Head, ...infer Tail]
+    ? Head extends Seen[number]
+        ? Head
+        : Head extends string | number | symbol
+          ? Tail extends readonly (string | number | symbol)[]
+              ? TryGetDuplicate<Tail, [...Seen, Head]>
+              : false
+          : false
+    : false;
+
+//check that the tuple T is a valid ordering of AllKeys, using IsComplete and TryGetDuplicate
+//returns a branded error if there are missing keys or duplicates
+export type AssertUniqueCompleteSet<
+    T extends readonly (string | number | symbol)[],
+    AllKeys extends string | number | symbol,
+> =
+    IsComplete<T, AllKeys> extends false
+        ? BrandedError<`Missing key: ${Exclude<AllKeys extends Symbol ? 'ERR' : AllKeys, T[number]>}`>
+        : TryGetDuplicate<T> extends false
+          ? T
+          : BrandedError<`Duplicate key found: ${TryGetDuplicate<T>}`>;
+
+type BuildTupleHelper<
+    Element,
+    Length extends number,
+    Rest extends Element[],
+> = Rest['length'] extends Length
+    ? readonly [...Rest] // Terminate with readonly array (aka tuple)
+    : BuildTupleHelper<Element, Length, [Element, ...Rest]>;
+
+export type BuildTuple<Element, Length extends number> = number extends Length
+    ? // Because `Length extends number` and `number extends Length`, then `Length` is not a specific finite number.
+      readonly Element[] // It's not fixed length.
+    : BuildTupleHelper<Element, Length, []>; // Otherwise it is a fixed length tuple.
+
+export type TuplesToObject<T extends readonly (readonly [PropertyKey, any])[]> = {
+    [K in T[number] as K[0]]: K[1];
+};

package/src/valueOf.ts

@@ -0,0 +1,16 @@
+export type IntersectionValueOf<T> = (
+    T[keyof T] extends infer U ? (U extends any ? (x: U) => void : never) : never
+) extends (x: infer I) => void
+    ? I
+    : never;
+
+/**
+ * @description Creates a type that extracts the values of T.
+ *
+ * @example
+ * ValueOf<{ a: string, b: number }>
+ * => string | number
+ *
+ * @internal
+ */
+export type ValueOf<T> = T[keyof T];

package/src/viem.ts

@@ -0,0 +1,275 @@
+/**
+ * Filters out all members of {@link T} that are not {@link P}
+ *
+ * @param T - Items to filter
+ * @param P - Type to filter out
+ * @returns Filtered items
+ *
+ * @example
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ */
+export type Filter<
+    T extends readonly unknown[],
+    P,
+    Acc extends readonly unknown[] = [],
+> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]]
+    ? [F] extends [P]
+        ? Filter<Rest, P, [...Acc, F]>
+        : Filter<Rest, P, Acc>
+    : readonly [...Acc];
+
+/**
+ * @description Checks if {@link T} can be narrowed further than {@link U}
+ * @param T - Type to check
+ * @param U - Type to against
+ * @example
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ */
+export type IsNarrowable<T, U> =
+    IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true
+        ? false
+        : true;
+
+/**
+ * @description Checks if {@link T} is `never`
+ * @param T - Type to check
+ * @example
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+
+/** Removes `readonly` from all properties of an object. */
+export type Mutable<type extends object> = {
+    -readonly [key in keyof type]: type[key];
+};
+
+/**
+ * @description Evaluates boolean "or" condition for {@link T} properties.
+ * @param T - Type to check
+ *
+ * * @example
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ *
+ * @example
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [infer Head, ...infer Tail]
+    ? Head extends true
+        ? true
+        : Or<Tail>
+    : false;
+
+/**
+ * @description Checks if {@link T} is `undefined`
+ * @param T - Type to check
+ * @example
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false;
+
+export type MaybePromise<T> = T | Promise<T>;
+
+/**
+ * @description Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * => { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * => { a: string, b?: number }
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true
+    ? ExactRequired<T>
+    : T;
+
+/**
+ * @description Assigns the properties of U onto T.
+ *
+ * @example
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * => { a: undefined, b: number, c: boolean }
+ */
+export type Assign<T, U> = Assign_<T, U> & U;
+type Assign_<T, U> = {
+    [K in keyof T as K extends keyof U ? (U[K] extends void ? never : K) : K]: K extends keyof U
+        ? U[K]
+        : T[K];
+};
+
+// TODO: Remove when peer dep `typescript@>=4.5` (NoInfer is native)
+export type NoInfer<type> = [type][type extends any ? 0 : never];
+
+/**
+ * @description Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * NoUndefined<string | undefined>
+ * => string
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T;
+
+/** Strict version of built-in Omit type */
+export type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
+
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * => { a?: string, b: number }
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & ExactPartial<Pick<T, K>>;
+
+/**
+ * @description Combines members of an intersection into a readable type.
+ *
+ * @see {@link https://twitter.com/mattpocockuk/status/1622730173446557697?s=20&t=NdpAcmEFXY01xkqU3KO0Mg}
+ * @example
+ * Prettify<{ a: string } & { b: string } & { c: number, d: bigint }>
+ * => { a: string, b: string, c: number, d: bigint }
+ */
+export type Prettify<T> = {
+    [K in keyof T]: T[K];
+} & {};
+
+/** @internal */
+export type Evaluate<type> = {
+    [key in keyof type]: type[key];
+} & {};
+
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * => { a: string, b: number }
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & ExactRequired<Pick<T, K>>;
+
+/**
+ * @description Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * Some<[1, 2, 3], 2>
+ * => true
+ */
+export type Some<array extends readonly unknown[], value> = array extends readonly [
+    value,
+    ...unknown[],
+]
+    ? true
+    : array extends readonly [unknown, ...infer rest]
+      ? Some<rest, value>
+      : false;
+
+export type UnionToTuple<
+    union,
+    ///
+    last = LastInUnion<union>,
+> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last];
+type LastInUnion<U> =
+    UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer l) => 0
+        ? l
+        : never;
+type UnionToIntersection<union> = (union extends unknown ? (arg: union) => 0 : never) extends (
+    arg: infer i,
+) => 0
+    ? i
+    : never;
+
+export type IsUnion<
+    union,
+    ///
+    union2 = union,
+> = union extends union2 ? ([union2] extends [union] ? false : true) : never;
+
+export type MaybePartial<type, enabled extends boolean | undefined> = enabled extends true
+    ? Prettify<ExactPartial<type>>
+    : type;
+
+export type ExactPartial<type> = {
+    [key in keyof type]?: type[key] | undefined;
+};
+
+export type ExactRequired<type> = {
+    [P in keyof type]-?: Exclude<type[P], undefined>;
+};
+
+export type OneOf<
+    union extends object,
+    fallback extends object | undefined = undefined,
+    ///
+    keys extends KeyofUnion<union> = KeyofUnion<union>,
+> = union extends infer item
+    ? Prettify<
+          item & {
+              [key in Exclude<keys, keyof item>]?: fallback extends object
+                  ? key extends keyof fallback
+                      ? fallback[key]
+                      : undefined
+                  : undefined;
+          }
+      >
+    : never;
+type KeyofUnion<type> = type extends type ? keyof type : never;
+
+///////////////////////////////////////////////////////////////////////////
+// Loose types
+
+/**
+ * Loose version of {@link Omit}
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<type, Exclude<keyof type, keys>>;
+
+///////////////////////////////////////////////////////////////////////////
+// Union types
+
+export type UnionEvaluate<type> = type extends object ? Prettify<type> : type;
+
+export type UnionLooseOmit<type, keys extends string> = type extends any
+    ? LooseOmit<type, keys>
+    : never;
+
+/**
+ * @description Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { b: number } | { b: undefined, c: number }
+ */
+export type UnionOmit<type, keys extends keyof type> = type extends any ? Omit<type, keys> : never;
+
+/**
+ * @description Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { b: number } | { b: undefined, c: number }
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any ? Pick<type, keys> : never;
+
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any ? PartialBy<T, K> : never;
+
+/**
+ * @description Creates a type that is T with the required keys K.
+ *
+ * @example
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * => { a: string, b: number } | { a: string, c?: number }
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any ? RequiredBy<T, K> : never;

package/src/withRequired.ts

@@ -0,0 +1,5 @@
+export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };
+
+export type AllRequired<T> = {
+    [K in keyof T]-?: T[K];
+};