@layerzerolabs/typescript-utils 0.0.0

package/test/disallowedAny.test.ts

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

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

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

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