@layerzerolabs/typescript-utils 0.2.68 → 0.2.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/typescript-utils",
-  "version": "0.2.68",
+  "version": "0.2.70",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -13,11 +13,14 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.68",
-    "@layerzerolabs/typescript-configuration": "0.2.68"
+    "@layerzerolabs/tsup-configuration": "0.2.70",
+    "@layerzerolabs/typescript-configuration": "0.2.70"
   },
   "publishConfig": {
     "access": "public",

package/.turbo/turbo-build.log

@@ -1,178 +0,0 @@
- WARN  Issue while reading "/home/runner/work/monorepo-internal/monorepo-internal/.npmrc". Failed to replace env in config: ${NPM_TOKEN}
-
-> @layerzerolabs/typescript-utils@0.0.0 build /home/runner/work/monorepo-internal/monorepo-internal/packages/typescript-utils
-> tsup
-
-CLI Building entry: src/advancedRecord.ts, src/asyncify.ts, src/branded.ts, src/constructor.ts, src/deep.test-d.ts, src/deep.ts, src/disallowedAny.ts, src/identity.ts, src/index.ts, src/lastOf.ts, src/maybeUndefined.ts, src/merge.ts, src/methodOf.ts, src/removeNever.ts, src/strings.test-d.ts, src/strings.ts, src/tuples.ts, src/valueOf.ts, src/viem.ts, src/withRequired.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/work/monorepo-internal/monorepo-internal/packages/typescript-utils/tsup.config.ts
-CLI Target: ES2023
-CLI Cleaning output folder
-CJS Build start
-ESM Build start
-Entry module "dist/EUBM3LSR.cjs" is using named and default exports together. Consumers of your bundle will have to use `chunk.default` to access the default export, which may not be what you want. Use `output.exports: "named"` to disable this warning.
-"default" is imported from external module "path" but never used in "dist/6AHA7PAZ.js".
-"fileURLToPath" is imported from external module "url" but never used in "dist/6AHA7PAZ.js".
-CJS dist/valueOf.cjs            143.00 B
-CJS dist/withRequired.cjs       153.00 B
-CJS dist/index.cjs              639.00 B
-CJS dist/viem.cjs               137.00 B
-CJS dist/KQUDWU4T.cjs           187.00 B
-CJS dist/tuples.cjs             141.00 B
-CJS dist/2MZ52QXI.cjs           188.00 B
-CJS dist/EUBM3LSR.cjs           42.53 KB
-CJS dist/B4TXK443.cjs           185.00 B
-CJS dist/4W25K7RR.cjs           193.00 B
-CJS dist/lastOf.cjs             141.00 B
-CJS dist/2OSBYVBM.cjs           187.00 B
-CJS dist/7RPBI4LQ.cjs           195.00 B
-CJS dist/maybeUndefined.cjs     157.00 B
-CJS dist/merge.cjs              139.00 B
-CJS dist/AKBGASRF.cjs           186.00 B
-CJS dist/methodOf.cjs           145.00 B
-CJS dist/removeNever.cjs        151.00 B
-CJS dist/NKWLAYNJ.cjs           189.00 B
-CJS dist/K3FZ3EZT.cjs           188.00 B
-CJS dist/strings.cjs            143.00 B
-CJS dist/Q35ZNXMT.cjs           192.00 B
-CJS dist/advancedRecord.cjs     157.00 B
-CJS dist/C7GMKBCN.cjs           195.00 B
-CJS dist/asyncify.cjs           145.00 B
-CJS dist/strings.test-d.cjs     893.00 B
-CJS dist/WPET3HPL.cjs           189.00 B
-CJS dist/53OHF4EH.cjs           192.00 B
-CJS dist/branded.cjs            143.00 B
-CJS dist/2SJJDCZI.cjs           188.00 B
-CJS dist/constructor.cjs        151.00 B
-CJS dist/deep.test-d.cjs        574.00 B
-CJS dist/deep.cjs               137.00 B
-CJS dist/MLSONTXK.cjs           185.00 B
-CJS dist/disallowedAny.cjs      155.00 B
-CJS dist/574X5FJM.cjs           194.00 B
-CJS dist/identity.cjs           145.00 B
-CJS dist/TVCGTTL5.cjs           189.00 B
-CJS dist/24WEKBY3.cjs           2.10 KB
-CJS dist/QXEVXGNQ.cjs           301.19 KB
-CJS dist/valueOf.cjs.map        72.00 B
-CJS dist/withRequired.cjs.map   77.00 B
-CJS dist/index.cjs.map          665.00 B
-CJS dist/tuples.cjs.map         71.00 B
-CJS dist/KQUDWU4T.cjs.map       2.68 KB
-CJS dist/2MZ52QXI.cjs.map       538.00 B
-CJS dist/viem.cjs.map           69.00 B
-CJS dist/B4TXK443.cjs.map       8.26 KB
-CJS dist/EUBM3LSR.cjs.map       100.19 KB
-CJS dist/4W25K7RR.cjs.map       299.00 B
-CJS dist/lastOf.cjs.map         71.00 B
-CJS dist/7RPBI4LQ.cjs.map       642.00 B
-CJS dist/2OSBYVBM.cjs.map       659.00 B
-CJS dist/maybeUndefined.cjs.map 79.00 B
-CJS dist/merge.cjs.map          70.00 B
-CJS dist/AKBGASRF.cjs.map       469.00 B
-CJS dist/methodOf.cjs.map       73.00 B
-CJS dist/removeNever.cjs.map    76.00 B
-CJS dist/strings.cjs.map        72.00 B
-CJS dist/NKWLAYNJ.cjs.map       399.00 B
-CJS dist/Q35ZNXMT.cjs.map       252.00 B
-CJS dist/K3FZ3EZT.cjs.map       1.42 KB
-CJS dist/C7GMKBCN.cjs.map       906.00 B
-CJS dist/advancedRecord.cjs.map 79.00 B
-CJS dist/WPET3HPL.cjs.map       341.00 B
-CJS dist/53OHF4EH.cjs.map       214.00 B
-CJS dist/asyncify.cjs.map       73.00 B
-CJS dist/2SJJDCZI.cjs.map       719.00 B
-CJS dist/deep.test-d.cjs.map    1.47 KB
-CJS dist/deep.cjs.map           69.00 B
-CJS dist/constructor.cjs.map    76.00 B
-CJS dist/branded.cjs.map        72.00 B
-CJS dist/identity.cjs.map       73.00 B
-CJS dist/24WEKBY3.cjs.map       923.00 B
-CJS dist/TVCGTTL5.cjs.map       265.00 B
-CJS dist/MLSONTXK.cjs.map       780.00 B
-CJS dist/disallowedAny.cjs.map  78.00 B
-CJS dist/574X5FJM.cjs.map       390.00 B
-CJS dist/strings.test-d.cjs.map 1.70 KB
-CJS dist/QXEVXGNQ.cjs.map       762.74 KB
-CJS ⚡️ Build success in 2406ms
-ESM dist/tuples.js             117.00 B
-ESM dist/valueOf.js            119.00 B
-ESM dist/viem.js               113.00 B
-ESM dist/withRequired.js       129.00 B
-ESM dist/GGKJNPTT.js           42.15 KB
-ESM dist/TQNP6GIE.js           158.00 B
-ESM dist/index.js              558.00 B
-ESM dist/EM7SXG4B.js           157.00 B
-ESM dist/62TVLGZP.js           163.00 B
-ESM dist/J7BAXUWJ.js           155.00 B
-ESM dist/KZQATXOW.js           157.00 B
-ESM dist/lastOf.js             117.00 B
-ESM dist/maybeUndefined.js     133.00 B
-ESM dist/merge.js              115.00 B
-ESM dist/Q6UBIYTZ.js           165.00 B
-ESM dist/DDDCRYAA.js           156.00 B
-ESM dist/methodOf.js           121.00 B
-ESM dist/KEJFF7VD.js           159.00 B
-ESM dist/removeNever.js        127.00 B
-ESM dist/I5NXBMAF.js           162.00 B
-ESM dist/strings.test-d.js     745.00 B
-ESM dist/strings.js            119.00 B
-ESM dist/CFTTK4D6.js           165.00 B
-ESM dist/advancedRecord.js     133.00 B
-ESM dist/B5GSIBEU.js           158.00 B
-ESM dist/asyncify.js           121.00 B
-ESM dist/TP4DJK6G.js           159.00 B
-ESM dist/6IUBP3YE.js           158.00 B
-ESM dist/constructor.js        127.00 B
-ESM dist/deep.test-d.js        491.00 B
-ESM dist/branded.js            119.00 B
-ESM dist/deep.js               113.00 B
-ESM dist/X6GYSLZB.js           162.00 B
-ESM dist/FQ2L5NQU.js           155.00 B
-ESM dist/V353KAGF.js           164.00 B
-ESM dist/disallowedAny.js      131.00 B
-ESM dist/identity.js           121.00 B
-ESM dist/P3JODCMF.js           159.00 B
-ESM dist/6AHA7PAZ.js           1.87 KB
-ESM dist/QDQO2ODJ.js           295.28 KB
-ESM dist/tuples.js.map         70.00 B
-ESM dist/viem.js.map           68.00 B
-ESM dist/valueOf.js.map        71.00 B
-ESM dist/withRequired.js.map   76.00 B
-ESM dist/GGKJNPTT.js.map       100.16 KB
-ESM dist/TQNP6GIE.js.map       517.00 B
-ESM dist/index.js.map          644.00 B
-ESM dist/EM7SXG4B.js.map       2.66 KB
-ESM dist/62TVLGZP.js.map       278.00 B
-ESM dist/KZQATXOW.js.map       638.00 B
-ESM dist/lastOf.js.map         70.00 B
-ESM dist/J7BAXUWJ.js.map       8.24 KB
-ESM dist/maybeUndefined.js.map 78.00 B
-ESM dist/Q6UBIYTZ.js.map       621.00 B
-ESM dist/merge.js.map          69.00 B
-ESM dist/DDDCRYAA.js.map       448.00 B
-ESM dist/methodOf.js.map       72.00 B
-ESM dist/KEJFF7VD.js.map       378.00 B
-ESM dist/removeNever.js.map    75.00 B
-ESM dist/I5NXBMAF.js.map       231.00 B
-ESM dist/strings.test-d.js.map 1.68 KB
-ESM dist/strings.js.map        71.00 B
-ESM dist/CFTTK4D6.js.map       885.00 B
-ESM dist/advancedRecord.js.map 78.00 B
-ESM dist/asyncify.js.map       72.00 B
-ESM dist/TP4DJK6G.js.map       320.00 B
-ESM dist/B5GSIBEU.js.map       1.40 KB
-ESM dist/6IUBP3YE.js.map       698.00 B
-ESM dist/constructor.js.map    75.00 B
-ESM dist/deep.test-d.js.map    1.45 KB
-ESM dist/deep.js.map           68.00 B
-ESM dist/branded.js.map        71.00 B
-ESM dist/X6GYSLZB.js.map       193.00 B
-ESM dist/FQ2L5NQU.js.map       759.00 B
-ESM dist/V353KAGF.js.map       369.00 B
-ESM dist/identity.js.map       72.00 B
-ESM dist/disallowedAny.js.map  77.00 B
-ESM dist/P3JODCMF.js.map       244.00 B
-ESM dist/6AHA7PAZ.js.map       666.00 B
-ESM dist/QDQO2ODJ.js.map       761.96 KB
-ESM ⚡️ Build success in 2409ms

package/.turbo/turbo-lint.log

@@ -1,8 +0,0 @@
-
-> @layerzerolabs/typescript-utils@0.0.0 lint /home/runner/work/monorepo-internal/monorepo-internal/packages/typescript-utils
-> eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)
-
-(node:67741) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/monorepo-internal/monorepo-internal/eslint.config.js?mtime=1775694520701 is not specified and it doesn't parse as CommonJS.
-Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
-To eliminate this warning, add "type": "module" to /home/runner/work/monorepo-internal/monorepo-internal/package.json.
-(Use `node --trace-warnings ...` to show where the warning was created)

package/src/advancedRecord.ts

@@ -1,23 +0,0 @@
-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]
-              ? // Distribute on K
-                K extends unknown
-                  ? KeyToFind extends DeepWritable<K>
-                      ? V
-                      : DeepWritable<K> extends KeyToFind
-                        ? V
-                        : never
-                  : never
-              : never;
-      }[keyof AR]
-    : never;

package/src/asyncify.ts

@@ -1,5 +0,0 @@
-export type AsyncifyDeep<T> = T extends (...args: infer A) => infer R
-    ? (...args: A) => Promise<R>
-    : T extends object
-      ? { [K in keyof T]: AsyncifyDeep<T[K]> }
-      : T;

package/src/branded.ts

@@ -1,19 +0,0 @@
-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

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

package/src/deep.test-d.ts

@@ -1,33 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

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

package/src/index.ts

@@ -1,17 +0,0 @@
-export * from './advancedRecord';
-export * from './asyncify';
-export * from './branded';
-export * from './constructor';
-export * from './deep';
-export * from './disallowedAny';
-export * from './identity';
-export * from './lastOf';
-export * from './maybeUndefined';
-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

@@ -1,15 +0,0 @@
-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/maybeUndefined.ts

@@ -1,16 +0,0 @@
-/**
- * @description Maps the result type `R` to `R | undefined` when the input type `T` includes `undefined`,
- * preserving the undefined-ness of the input in the output type.
- *
- * @example
- * MaybeUndefinedMapped<string | undefined, number>
- * => number | undefined
- *
- * MaybeUndefinedMapped<string, number>
- * => number
- */
-export type MaybeUndefinedMapped<T, R> = undefined extends T
-    ? T extends undefined
-        ? undefined
-        : R | undefined
-    : R;

package/src/merge.ts

@@ -1,13 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

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

package/src/strings.test-d.ts

@@ -1,32 +0,0 @@
-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

@@ -1,42 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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];
-};
-
-export type TuplePrefixUnion<T extends any[]> =
-    | []
-    | (Required<T> extends [...infer Init, any] ? Required<T> | TuplePrefixUnion<Init> : never);
-
-export type SubtractTuple<Minuend extends any[], Subtrahend extends any[]> = Subtrahend extends [
-    any,
-    ...infer S,
-]
-    ? Minuend extends [any, ...infer M]
-        ? // keep subtracting
-          SubtractTuple<M, S>
-        : // subtrahend has a cardinality less than minuend
-          never
-    : // we fully subtracted already
-      Minuend;

package/src/valueOf.ts

@@ -1,16 +0,0 @@
-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

@@ -1,275 +0,0 @@
-/**
- * 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 compare 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

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

package/test/disallowedAny.test.ts

@@ -1,54 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-
-import type { DisallowedAny } from '../src/disallowedAny';
-
-describe('DisallowedAny type utility', () => {
-    it('disallows bare any', () => {
-        type R = DisallowedAny<any>;
-        expectTypeOf<R>().toEqualTypeOf<never>();
-    });
-
-    it('passes through primitives', () => {
-        expectTypeOf<DisallowedAny<string>>().toEqualTypeOf<string>();
-        expectTypeOf<DisallowedAny<number>>().toEqualTypeOf<number>();
-        expectTypeOf<DisallowedAny<boolean>>().toEqualTypeOf<boolean>();
-        expectTypeOf<DisallowedAny<symbol>>().toEqualTypeOf<symbol>();
-        expectTypeOf<DisallowedAny<bigint>>().toEqualTypeOf<bigint>();
-        expectTypeOf<DisallowedAny<null>>().toEqualTypeOf<null>();
-        expectTypeOf<DisallowedAny<undefined>>().toEqualTypeOf<undefined>();
-    });
-
-    it('does not treat unknown as any', () => {
-        expectTypeOf<DisallowedAny<unknown>>().toEqualTypeOf<unknown>();
-    });
-
-    it('disallows unions that include any (any absorbs the union)', () => {
-        type U1 = DisallowedAny<any | string>;
-        expectTypeOf<U1>().toEqualTypeOf<never>();
-
-        type U2 = DisallowedAny<string | number>;
-        expectTypeOf<U2>().toEqualTypeOf<string | number>();
-    });
-
-    it('disallows intersections that include any (any absorbs the intersection)', () => {
-        type I1 = DisallowedAny<any & { a: 1 }>;
-        expectTypeOf<I1>().toEqualTypeOf<never>();
-    });
-
-    it('works with generics: when T is any it becomes never; otherwise it passes through', () => {
-        type Wrap<T> = DisallowedAny<T>;
-
-        type G1 = Wrap<any>;
-        expectTypeOf<G1>().toEqualTypeOf<never>();
-
-        type G2 = Wrap<{ x: string }>; // non-any generic
-        expectTypeOf<G2>().toEqualTypeOf<{ x: string }>();
-    });
-
-    it('allows type constraints', () => {
-        const myFunc = <T extends number>(_: DisallowedAny<T>): void => {};
-        myFunc(5);
-        //@ts-expect-error
-        myFunc(5 as any);
-    });
-});

package/test/merge.test.ts

@@ -1,27 +0,0 @@
-import { describe, expectTypeOf, it } from 'vitest';
-
-import type { Merge } from '../src/merge';
-
-describe('Merge type utility', () => {
-    it('should handle empty object edge cases correctly', () => {
-        // Test the main fix: empty objects should be handled properly
-        type EmptyLeftMerge = Merge<{}, { a: string; b: number }>;
-        expectTypeOf<EmptyLeftMerge>().toEqualTypeOf<{ a: string; b: number }>();
-
-        type EmptyRightMerge = Merge<{ a: string; b: number }, {}>;
-        expectTypeOf<EmptyRightMerge>().toEqualTypeOf<{ a: string; b: number }>();
-
-        type BothEmptyMerge = Merge<{}, {}>;
-        expectTypeOf<BothEmptyMerge>().toEqualTypeOf<{}>();
-    });
-
-    it('should merge types correctly for non-empty objects', () => {
-        // Basic functionality should still work
-        type BasicMerge = Merge<{ a: string }, { b: number }>;
-        expectTypeOf<BasicMerge>().toEqualTypeOf<{ a: string; b: number }>();
-
-        // Property override should work
-        type OverrideMerge = Merge<{ a: string; b: string }, { b: number; c: boolean }>;
-        expectTypeOf<OverrideMerge>().toEqualTypeOf<{ a: string; b: number; c: boolean }>();
-    });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-    "extends": "@layerzerolabs/typescript-configuration/tsconfig.base.json",
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "strictPropertyInitialization": false,
-        "noUnusedLocals": false,
-        "noUnusedParameters": false,
-        "jsx": "react-jsx"
-    },
-    "exclude": [
-        "node_modules",
-        "**/__mocks__/*",
-        "**/__tests__/*",
-        "**/*.spec.ts",
-        "**/*.test.ts",
-        "dist"
-    ],
-    "include": ["src/**/*"]
-}

package/tsup.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'tsup';
-
-import { createPackageTsupConfig } from '@layerzerolabs/tsup-configuration';
-
-export default defineConfig(({ watch }) => ({
-    ...createPackageTsupConfig(),
-    clean: !watch,
-}));