@latticexyz/schema-type 2.0.12-main-2f436a5c → 2.0.12-type-resolutions-effc7ab1

package/src/typescript/exports/internal.ts

@@ -1,6 +0,0 @@
-export * from "../arrayAbiTypes";
-export * from "../dynamicAbiTypes";
-export * from "../schemaAbiTypes";
-export * from "../schemaAbiTypeToDefaultValue";
-export * from "../staticAbiTypes";
-export * from "../schemaAbiTypeToPrimitiveType";

package/src/typescript/schemaAbiTypeToDefaultValue.ts

@@ -1,8 +0,0 @@
-import { SchemaAbiType } from "./schemaAbiTypes";
-import { DynamicAbiTypeToPrimitiveType, dynamicAbiTypeToDefaultValue } from "./dynamicAbiTypes";
-import { StaticAbiTypeToPrimitiveType, staticAbiTypeToDefaultValue } from "./staticAbiTypes";
-
-export const schemaAbiTypeToDefaultValue = {
-  ...staticAbiTypeToDefaultValue,
-  ...dynamicAbiTypeToDefaultValue,
-} as const satisfies Record<SchemaAbiType, StaticAbiTypeToPrimitiveType | DynamicAbiTypeToPrimitiveType>;

package/src/typescript/schemaAbiTypeToPrimitiveType.ts

@@ -1,7 +0,0 @@
-import { schemaAbiTypeToDefaultValue } from "./schemaAbiTypeToDefaultValue";
-import { SchemaAbiType } from "./schemaAbiTypes";
-import { LiteralToBroad } from "./utils";
-
-export type SchemaAbiTypeToPrimitiveType<T extends SchemaAbiType> = LiteralToBroad<
-  (typeof schemaAbiTypeToDefaultValue)[T]
->;

package/src/typescript/schemaAbiTypes.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "vitest";
-import fs from "node:fs/promises";
-import { schemaAbiTypes } from "./schemaAbiTypes";
-
-describe("schemaAbiTypes", () => {
-  it("should be in sync with SchemaType.sol", async () => {
-    const source = await fs.readFile(`${__dirname}/../solidity/SchemaType.sol`, "utf8");
-    const matches = source.match(/enum SchemaType \{([\s\S]+?)\}/);
-    const soliditySchemaTypes = matches?.[1].replace(/\s/g, "").split(",") ?? [];
-
-    const soliditySchemaTypesAsAbiTypes = soliditySchemaTypes.map((soliditySchemaType) =>
-      soliditySchemaType.replace(/_ARRAY$/, "[]").toLowerCase(),
-    );
-
-    expect(soliditySchemaTypesAsAbiTypes).toStrictEqual(schemaAbiTypes);
-  });
-});

package/src/typescript/schemaAbiTypes.ts

@@ -1,219 +0,0 @@
-import { AbiType } from "abitype";
-import { TupleSplit } from "./utils";
-
-// Keep this array in sync with SchemaType.sol enum
-export const schemaAbiTypes = [
-  "uint8",
-  "uint16",
-  "uint24",
-  "uint32",
-  "uint40",
-  "uint48",
-  "uint56",
-  "uint64",
-  "uint72",
-  "uint80",
-  "uint88",
-  "uint96",
-  "uint104",
-  "uint112",
-  "uint120",
-  "uint128",
-  "uint136",
-  "uint144",
-  "uint152",
-  "uint160",
-  "uint168",
-  "uint176",
-  "uint184",
-  "uint192",
-  "uint200",
-  "uint208",
-  "uint216",
-  "uint224",
-  "uint232",
-  "uint240",
-  "uint248",
-  "uint256",
-  "int8",
-  "int16",
-  "int24",
-  "int32",
-  "int40",
-  "int48",
-  "int56",
-  "int64",
-  "int72",
-  "int80",
-  "int88",
-  "int96",
-  "int104",
-  "int112",
-  "int120",
-  "int128",
-  "int136",
-  "int144",
-  "int152",
-  "int160",
-  "int168",
-  "int176",
-  "int184",
-  "int192",
-  "int200",
-  "int208",
-  "int216",
-  "int224",
-  "int232",
-  "int240",
-  "int248",
-  "int256",
-  "bytes1",
-  "bytes2",
-  "bytes3",
-  "bytes4",
-  "bytes5",
-  "bytes6",
-  "bytes7",
-  "bytes8",
-  "bytes9",
-  "bytes10",
-  "bytes11",
-  "bytes12",
-  "bytes13",
-  "bytes14",
-  "bytes15",
-  "bytes16",
-  "bytes17",
-  "bytes18",
-  "bytes19",
-  "bytes20",
-  "bytes21",
-  "bytes22",
-  "bytes23",
-  "bytes24",
-  "bytes25",
-  "bytes26",
-  "bytes27",
-  "bytes28",
-  "bytes29",
-  "bytes30",
-  "bytes31",
-  "bytes32",
-  "bool",
-  "address",
-  "uint8[]",
-  "uint16[]",
-  "uint24[]",
-  "uint32[]",
-  "uint40[]",
-  "uint48[]",
-  "uint56[]",
-  "uint64[]",
-  "uint72[]",
-  "uint80[]",
-  "uint88[]",
-  "uint96[]",
-  "uint104[]",
-  "uint112[]",
-  "uint120[]",
-  "uint128[]",
-  "uint136[]",
-  "uint144[]",
-  "uint152[]",
-  "uint160[]",
-  "uint168[]",
-  "uint176[]",
-  "uint184[]",
-  "uint192[]",
-  "uint200[]",
-  "uint208[]",
-  "uint216[]",
-  "uint224[]",
-  "uint232[]",
-  "uint240[]",
-  "uint248[]",
-  "uint256[]",
-  "int8[]",
-  "int16[]",
-  "int24[]",
-  "int32[]",
-  "int40[]",
-  "int48[]",
-  "int56[]",
-  "int64[]",
-  "int72[]",
-  "int80[]",
-  "int88[]",
-  "int96[]",
-  "int104[]",
-  "int112[]",
-  "int120[]",
-  "int128[]",
-  "int136[]",
-  "int144[]",
-  "int152[]",
-  "int160[]",
-  "int168[]",
-  "int176[]",
-  "int184[]",
-  "int192[]",
-  "int200[]",
-  "int208[]",
-  "int216[]",
-  "int224[]",
-  "int232[]",
-  "int240[]",
-  "int248[]",
-  "int256[]",
-  "bytes1[]",
-  "bytes2[]",
-  "bytes3[]",
-  "bytes4[]",
-  "bytes5[]",
-  "bytes6[]",
-  "bytes7[]",
-  "bytes8[]",
-  "bytes9[]",
-  "bytes10[]",
-  "bytes11[]",
-  "bytes12[]",
-  "bytes13[]",
-  "bytes14[]",
-  "bytes15[]",
-  "bytes16[]",
-  "bytes17[]",
-  "bytes18[]",
-  "bytes19[]",
-  "bytes20[]",
-  "bytes21[]",
-  "bytes22[]",
-  "bytes23[]",
-  "bytes24[]",
-  "bytes25[]",
-  "bytes26[]",
-  "bytes27[]",
-  "bytes28[]",
-  "bytes29[]",
-  "bytes30[]",
-  "bytes31[]",
-  "bytes32[]",
-  "bool[]",
-  "address[]",
-  "bytes",
-  "string",
-] as const satisfies readonly AbiType[];
-
-export type SchemaAbiType = (typeof schemaAbiTypes)[number];
-
-// These are defined here to keep the index position (98) consolidated, since we use it both in runtime code and type definition
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const staticAbiTypes = schemaAbiTypes.slice(0, 98) as any as TupleSplit<typeof schemaAbiTypes, 98>[0];
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export const dynamicAbiTypes = schemaAbiTypes.slice(98) as any as TupleSplit<typeof schemaAbiTypes, 98>[1];
-
-export type StaticAbiType = (typeof staticAbiTypes)[number];
-export type DynamicAbiType = (typeof dynamicAbiTypes)[number];
-
-export function isSchemaAbiType(abiType: unknown): abiType is SchemaAbiType {
-  return schemaAbiTypes.includes(abiType as SchemaAbiType);
-}

package/src/typescript/staticAbiTypes.test-d.ts

@@ -1,58 +0,0 @@
-import { describe, expectTypeOf, it } from "vitest";
-import { Hex } from "viem";
-import { StaticAbiTypeToPrimitiveType } from "./staticAbiTypes";
-
-describe("StaticAbiTypeToPrimitiveType", () => {
-  it("maps uint8 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint8">>().toBeNumber();
-  });
-  it("maps uint32 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint32">>().toBeNumber();
-  });
-  it("maps uint48 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint48">>().toBeNumber();
-  });
-  it("maps uint56 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint56">>().toMatchTypeOf<bigint>();
-  });
-  it("maps uint256 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"uint256">>().toMatchTypeOf<bigint>();
-  });
-
-  it("maps int8 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"int8">>().toBeNumber();
-  });
-  it("maps int32 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"int32">>().toBeNumber();
-  });
-  it("maps int48 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"int48">>().toBeNumber();
-  });
-  it("maps int56 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"int56">>().toMatchTypeOf<bigint>();
-  });
-  it("maps int256 to number", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"int256">>().toMatchTypeOf<bigint>();
-  });
-
-  it("maps bytes1 to hex", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes1">>().toMatchTypeOf<Hex>();
-  });
-  it("maps bytes2 to hex", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes2">>().toMatchTypeOf<Hex>();
-  });
-  it("maps bytes8 to hex", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes8">>().toMatchTypeOf<Hex>();
-  });
-  it("maps bytes32 to hex", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"bytes32">>().toMatchTypeOf<Hex>();
-  });
-
-  it("maps bool to boolean", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"bool">>().toBeBoolean();
-  });
-
-  it("maps address to hex", () => {
-    expectTypeOf<StaticAbiTypeToPrimitiveType<"address">>().toMatchTypeOf<Hex>();
-  });
-});

package/src/typescript/staticAbiTypes.ts

@@ -1,223 +0,0 @@
-import { Hex } from "viem";
-import { StaticAbiType, staticAbiTypes } from "./schemaAbiTypes";
-import { LiteralToBroad } from "./utils";
-
-// Fixed-length ABI types
-
-export type StaticPrimitiveType = number | bigint | boolean | Hex;
-
-export const staticAbiTypeToDefaultValue = {
-  uint8: 0,
-  uint16: 0,
-  uint24: 0,
-  uint32: 0,
-  uint40: 0,
-  uint48: 0,
-  uint56: 0n,
-  uint64: 0n,
-  uint72: 0n,
-  uint80: 0n,
-  uint88: 0n,
-  uint96: 0n,
-  uint104: 0n,
-  uint112: 0n,
-  uint120: 0n,
-  uint128: 0n,
-  uint136: 0n,
-  uint144: 0n,
-  uint152: 0n,
-  uint160: 0n,
-  uint168: 0n,
-  uint176: 0n,
-  uint184: 0n,
-  uint192: 0n,
-  uint200: 0n,
-  uint208: 0n,
-  uint216: 0n,
-  uint224: 0n,
-  uint232: 0n,
-  uint240: 0n,
-  uint248: 0n,
-  uint256: 0n,
-
-  int8: 0,
-  int16: 0,
-  int24: 0,
-  int32: 0,
-  int40: 0,
-  int48: 0,
-  int56: 0n,
-  int64: 0n,
-  int72: 0n,
-  int80: 0n,
-  int88: 0n,
-  int96: 0n,
-  int104: 0n,
-  int112: 0n,
-  int120: 0n,
-  int128: 0n,
-  int136: 0n,
-  int144: 0n,
-  int152: 0n,
-  int160: 0n,
-  int168: 0n,
-  int176: 0n,
-  int184: 0n,
-  int192: 0n,
-  int200: 0n,
-  int208: 0n,
-  int216: 0n,
-  int224: 0n,
-  int232: 0n,
-  int240: 0n,
-  int248: 0n,
-  int256: 0n,
-
-  bytes1: "0x00",
-  bytes2: "0x0000",
-  bytes3: "0x000000",
-  bytes4: "0x00000000",
-  bytes5: "0x0000000000",
-  bytes6: "0x000000000000",
-  bytes7: "0x00000000000000",
-  bytes8: "0x0000000000000000",
-  bytes9: "0x000000000000000000",
-  bytes10: "0x00000000000000000000",
-  bytes11: "0x0000000000000000000000",
-  bytes12: "0x000000000000000000000000",
-  bytes13: "0x00000000000000000000000000",
-  bytes14: "0x0000000000000000000000000000",
-  bytes15: "0x000000000000000000000000000000",
-  bytes16: "0x00000000000000000000000000000000",
-  bytes17: "0x0000000000000000000000000000000000",
-  bytes18: "0x000000000000000000000000000000000000",
-  bytes19: "0x00000000000000000000000000000000000000",
-  bytes20: "0x0000000000000000000000000000000000000000",
-  bytes21: "0x000000000000000000000000000000000000000000",
-  bytes22: "0x00000000000000000000000000000000000000000000",
-  bytes23: "0x0000000000000000000000000000000000000000000000",
-  bytes24: "0x000000000000000000000000000000000000000000000000",
-  bytes25: "0x00000000000000000000000000000000000000000000000000",
-  bytes26: "0x0000000000000000000000000000000000000000000000000000",
-  bytes27: "0x000000000000000000000000000000000000000000000000000000",
-  bytes28: "0x00000000000000000000000000000000000000000000000000000000",
-  bytes29: "0x0000000000000000000000000000000000000000000000000000000000",
-  bytes30: "0x000000000000000000000000000000000000000000000000000000000000",
-  bytes31: "0x00000000000000000000000000000000000000000000000000000000000000",
-  bytes32: "0x0000000000000000000000000000000000000000000000000000000000000000",
-
-  bool: false,
-  address: "0x0000000000000000000000000000000000000000",
-} as const satisfies Record<StaticAbiType, StaticPrimitiveType>;
-
-export type StaticAbiTypeToPrimitiveType<TStaticAbiType extends StaticAbiType = StaticAbiType> = LiteralToBroad<
-  (typeof staticAbiTypeToDefaultValue)[TStaticAbiType]
->;
-
-export const staticAbiTypeToByteLength = {
-  uint8: 1,
-  uint16: 2,
-  uint24: 3,
-  uint32: 4,
-  uint40: 5,
-  uint48: 6,
-  uint56: 7,
-  uint64: 8,
-  uint72: 9,
-  uint80: 10,
-  uint88: 11,
-  uint96: 12,
-  uint104: 13,
-  uint112: 14,
-  uint120: 15,
-  uint128: 16,
-  uint136: 17,
-  uint144: 18,
-  uint152: 19,
-  uint160: 20,
-  uint168: 21,
-  uint176: 22,
-  uint184: 23,
-  uint192: 24,
-  uint200: 25,
-  uint208: 26,
-  uint216: 27,
-  uint224: 28,
-  uint232: 29,
-  uint240: 30,
-  uint248: 31,
-  uint256: 32,
-
-  int8: 1,
-  int16: 2,
-  int24: 3,
-  int32: 4,
-  int40: 5,
-  int48: 6,
-  int56: 7,
-  int64: 8,
-  int72: 9,
-  int80: 10,
-  int88: 11,
-  int96: 12,
-  int104: 13,
-  int112: 14,
-  int120: 15,
-  int128: 16,
-  int136: 17,
-  int144: 18,
-  int152: 19,
-  int160: 20,
-  int168: 21,
-  int176: 22,
-  int184: 23,
-  int192: 24,
-  int200: 25,
-  int208: 26,
-  int216: 27,
-  int224: 28,
-  int232: 29,
-  int240: 30,
-  int248: 31,
-  int256: 32,
-
-  bytes1: 1,
-  bytes2: 2,
-  bytes3: 3,
-  bytes4: 4,
-  bytes5: 5,
-  bytes6: 6,
-  bytes7: 7,
-  bytes8: 8,
-  bytes9: 9,
-  bytes10: 10,
-  bytes11: 11,
-  bytes12: 12,
-  bytes13: 13,
-  bytes14: 14,
-  bytes15: 15,
-  bytes16: 16,
-  bytes17: 17,
-  bytes18: 18,
-  bytes19: 19,
-  bytes20: 20,
-  bytes21: 21,
-  bytes22: 22,
-  bytes23: 23,
-  bytes24: 24,
-  bytes25: 25,
-  bytes26: 26,
-  bytes27: 27,
-  bytes28: 28,
-  bytes29: 29,
-  bytes30: 30,
-  bytes31: 31,
-  bytes32: 32,
-
-  bool: 1,
-  address: 20,
-} as const satisfies Record<StaticAbiType, number>;
-
-export function isStaticAbiType(abiType: unknown): abiType is StaticAbiType {
-  return staticAbiTypes.includes(abiType as StaticAbiType);
-}

package/src/typescript/utils.ts

@@ -1,25 +0,0 @@
-import { Hex } from "viem";
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type TupleSplit<T, N extends number, O extends readonly any[] = readonly []> = O["length"] extends N
-  ? [O, T]
-  : T extends readonly [infer F, ...infer R]
-    ? TupleSplit<readonly [...R], N, readonly [...O, F]>
-    : [O, T];
-
-export type LiteralToBroad<T> =
-  T extends Readonly<Array<infer Element>>
-    ? readonly LiteralToBroad<Element>[]
-    : T extends Array<infer Element>
-      ? LiteralToBroad<Element>[]
-      : T extends number
-        ? number
-        : T extends bigint
-          ? bigint
-          : T extends Hex
-            ? Hex
-            : T extends boolean
-              ? boolean
-              : T extends string
-                ? string
-                : never;