@latticexyz/store 2.0.12-type-resolutions-d4eea91b → 2.0.12

package/dist/chunk-7GE3KQCY.js

@@ -0,0 +1,2 @@
+function a(e,t){return typeof e=="object"&&e!=null&&n(e,t)?e[t]:void 0}function _(e,t){return t.length?_(a(e,t[0]),t.slice(1)):e}function n(e,t){return typeof e=="object"&&e!==null&&e.hasOwnProperty(t)}function i(e){return e!=null&&typeof e=="object"}function c(e,t){let s=[...new Set([...Object.keys(e),...Object.keys(t)])];return Object.fromEntries(s.map(o=>[o,e[o]??t[o]]))}var m={storeImportPath:"@latticexyz/store/src/",userTypesFilename:"common.sol",outputDirectory:"codegen",namespaceDirectories:!1,indexFilename:"index.sol"},y={outputDirectory:"tables",tableIdArgument:!1,storeArgument:!1},k={disabled:!1},u={namespace:"",type:"table"},l={sourceDirectory:"src",namespace:""};import{schemaAbiTypes as C}from"@latticexyz/schema-type/internal";var X={types:{}},r={types:Object.fromEntries(C.map(e=>[e,e]))};function d(e,t){return{types:{...e.types,...t}}}import{fixedArrayToArray as F,isFixedArrayAbiType as f}from"@latticexyz/schema-type/internal";function x(e,t=r){if(!i(e))throw new Error(`Expected schema, received ${JSON.stringify(e)}`);for(let s of Object.values(e))if(!f(s)&&!n(t.types,s))throw new Error(`"${String(s)}" is not a valid type in this scope.`)}function T(e,t=r){return Object.fromEntries(Object.entries(e).map(([s,o])=>[s,{type:f(o)?F(o):t.types[o],internalType:o}]))}function re(e,t=r){return x(e,t),T(e,t)}function pe(e,t=r){return typeof e=="object"&&e!=null&&Object.values(e).every(s=>f(s)||n(t.types,s))}import{isStaticAbiType as E}from"@latticexyz/schema-type/internal";import{resourceToHex as j}from"@latticexyz/common";function K(e,t=r){return Object.entries(e).filter(([,s])=>n(t.types,s)&&E(t.types[s])).map(([s])=>s)}function N(e,t,s=r){return Array.isArray(e)&&e.every(o=>n(t,o)&&n(s.types,t[o])&&E(s.types[t[o]]))}function b(e,t=r,s={inStoreContext:!1}){if(typeof e!="object"||e==null)throw new Error(`Expected full table config, got \`${JSON.stringify(e)}\``);if(!n(e,"schema"))throw new Error("Missing schema input");if(x(e.schema,t),!n(e,"key")||!N(e.key,e.schema,t))throw new Error(`Invalid key. Expected \`(${K(e.schema,t).map(o=>`"${String(o)}"`).join(" | ")})[]\`, received \`${n(e,"key")&&Array.isArray(e.key)?`[${e.key.map(o=>`"${o}"`).join(", ")}]`:String(a(e,"key"))}\``);if(s.inStoreContext&&n(e,"name")||n(e,"namespace"))throw new Error("Overrides of `name` and `namespace` are not allowed for tables in a store config.")}function P(e){let t=e.codegen;return{outputDirectory:a(t,"outputDirectory")??y.outputDirectory,tableIdArgument:a(t,"tableIdArgument")??y.tableIdArgument,storeArgument:a(t,"storeArgument")??y.storeArgument,dataStruct:a(t,"dataStruct")??Object.keys(e.schema).length-e.key.length>1}}function S(e,t=r){let s=e.name,o=e.type??u.type,p=e.namespace??u.namespace;return{tableId:e.tableId??j({type:o,namespace:p,name:s}),name:s,namespace:p,type:o,key:e.key,schema:T(e.schema,t),codegen:P(e),deploy:c(e.deploy??{},k)}}function xe(e,t=r){return b(e,t),S(e,t)}function g(e,t){if(i(e)){for(let s of Object.values(e))b(s,t,{inStoreContext:!0});return}throw new Error(`Expected store config, received ${JSON.stringify(e)}`)}function A(e,t=r){if(!i(e))throw new Error(`Expected tables config, received ${JSON.stringify(e)}`);return Object.fromEntries(Object.entries(e).map(([s,o])=>[s,S(c(o,{name:s}),t)]))}import{mapObject as $}from"@latticexyz/common/utils";import{isSchemaAbiType as B}from"@latticexyz/schema-type/internal";function G(e){return $(e,t=>t.type)}function M(e){return i(e)&&Object.values(e).every(t=>B(t.type))}function v(e,t=r){return M(e)?d(t,G(e)):t}function h(e){if(!i(e))throw new Error(`Expected userTypes, received ${JSON.stringify(e)}`);for(let{type:t}of Object.values(e))if(!n(r.types,t))throw new Error(`"${String(t)}" is not a valid ABI type.`)}import{flatMorph as I}from"@arktype/util";function V(e){return typeof e=="object"&&e!=null&&Object.values(e).every(t=>Array.isArray(t)&&t.every(s=>typeof s=="string"))}function D(e,t=r){if(V(e)){let s=Object.fromEntries(Object.keys(e).map(o=>[o,"uint8"]));return d(t,s)}return t}function W(e){return e}function O(e){return I(e,(t,s)=>[t,I(s,(o,p)=>[p,o])])}function U(e){return i(e)?c(e,m):m}import{flatMorph as J}from"@arktype/util";function L(e){return D(a(e,"enums"),v(a(e,"userTypes")))}function Y(e){let t=L(e);n(e,"tables")&&g(e.tables,t),n(e,"userTypes")&&h(e.userTypes)}function q(e){let t=U(e.codegen);return{sourceDirectory:e.sourceDirectory??l.sourceDirectory,tables:A(J(e.tables??{},(s,o)=>{let p=e.namespace;return[p?`${p}__${s}`:s,c(o,{namespace:p,name:s,codegen:c(o.codegen??{},{outputDirectory:t.namespaceDirectories&&p?.length?`${p}/tables`:"tables"})})]}),L(e)),userTypes:e.userTypes??{},enums:e.enums??{},enumValues:O(e.enums??{}),namespace:e.namespace??l.namespace,codegen:t}}function We(e){return Y(e),q(e)}export{a,_ as b,n as c,i as d,c as e,m as f,y as g,k as h,u as i,l as j,X as k,r as l,d as m,x as n,T as o,re as p,pe as q,N as r,b as s,P as t,S as u,xe as v,g as w,A as x,G as y,M as z,v as A,h as B,D as C,W as D,O as E,U as F,L as G,Y as H,q as I,We as J};
+//# sourceMappingURL=chunk-7GE3KQCY.js.map

package/dist/chunk-7GE3KQCY.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../ts/config/v2/generics.ts","../ts/config/v2/defaults.ts","../ts/config/v2/scope.ts","../ts/config/v2/schema.ts","../ts/config/v2/table.ts","../ts/config/v2/tables.ts","../ts/config/v2/userTypes.ts","../ts/config/v2/enums.ts","../ts/config/v2/codegen.ts","../ts/config/v2/store.ts"],"sourcesContent":["import { merge } from \"@arktype/util\";\n\nexport type get<input, key> = key extends keyof input ? input[key] : undefined;\n\nexport function get<input, key extends PropertyKey>(input: input, key: key): get<input, key> {\n  return (typeof input === \"object\" && input != null && hasOwnKey(input, key) ? input[key] : undefined) as never;\n}\n\nexport type getPath<input, path extends readonly PropertyKey[]> = path extends readonly [\n  infer head,\n  ...infer tail extends PropertyKey[],\n]\n  ? head extends keyof input\n    ? getPath<input[head], tail>\n    : undefined\n  : input;\n\nexport function getPath<input, path extends readonly PropertyKey[]>(input: input, path: path): getPath<input, path> {\n  return path.length ? (getPath(get(input, path[0]), path.slice(1)) as never) : (input as never);\n}\n\nexport function hasOwnKey<obj, const key extends PropertyKey>(\n  object: obj,\n  key: key,\n): object is { [k in key]: k extends keyof obj ? obj[k] : unknown } & obj {\n  // eslint-disable-next-line no-prototype-builtins\n  return typeof object === \"object\" && object !== null && object.hasOwnProperty(key);\n}\n\nexport function isObject<input>(input: input): input is input & object {\n  return input != null && typeof input === \"object\";\n}\n\nexport type mergeIfUndefined<base, merged> = merge<\n  base,\n  {\n    [key in keyof merged]: key extends keyof base\n      ? undefined extends base[key]\n        ? merged[key]\n        : base[key]\n      : merged[key];\n  }\n>;\n\nexport function mergeIfUndefined<base extends object, merged extends object>(\n  base: base,\n  merged: merged,\n): mergeIfUndefined<base, merged> {\n  const allKeys = [...new Set([...Object.keys(base), ...Object.keys(merged)])];\n  return Object.fromEntries(\n    allKeys.map((key) => [key, base[key as keyof base] ?? merged[key as keyof merged]]),\n  ) as never;\n}\n\nexport type parseNumber<T> = T extends `${infer N extends number}` ? N : never;\n","import { CodegenInput, StoreInput, TableCodegenInput, TableDeployInput, TableInput } from \"./input\";\n\nexport const CODEGEN_DEFAULTS = {\n  storeImportPath: \"@latticexyz/store/src/\",\n  userTypesFilename: \"common.sol\",\n  outputDirectory: \"codegen\",\n  // TODO: default to true if using top-level `namespaces` key (once its migrated to store)\n  namespaceDirectories: false,\n  indexFilename: \"index.sol\",\n} as const satisfies CodegenInput;\n\nexport type CODEGEN_DEFAULTS = typeof CODEGEN_DEFAULTS;\n\nexport const TABLE_CODEGEN_DEFAULTS = {\n  outputDirectory: \"tables\" as string,\n  tableIdArgument: false,\n  storeArgument: false,\n} as const satisfies TableCodegenInput;\n\nexport type TABLE_CODEGEN_DEFAULTS = typeof TABLE_CODEGEN_DEFAULTS;\n\nexport const TABLE_DEPLOY_DEFAULTS = {\n  disabled: false,\n} as const satisfies TableDeployInput;\n\nexport type TABLE_DEPLOY_DEFAULTS = typeof TABLE_DEPLOY_DEFAULTS;\n\nexport const TABLE_DEFAULTS = {\n  namespace: \"\",\n  type: \"table\",\n} as const satisfies Pick<TableInput, \"namespace\" | \"type\">;\n\nexport type TABLE_DEFAULTS = typeof TABLE_DEFAULTS;\n\nexport const CONFIG_DEFAULTS = {\n  sourceDirectory: \"src\",\n  namespace: \"\",\n} as const satisfies StoreInput;\n\nexport type CONFIG_DEFAULTS = typeof CONFIG_DEFAULTS;\n","import { Dict, evaluate } from \"@arktype/util\";\nimport { SchemaInput } from \"./input\";\nimport { StaticAbiType, schemaAbiTypes } from \"@latticexyz/schema-type/internal\";\nimport { AbiType } from \"./output\";\n\nexport const Scope = { types: {} } as const satisfies ScopeOptions;\nexport type Scope = typeof Scope;\n\nexport type AbiTypeScope = ScopeOptions<{ [t in AbiType]: t }>;\nexport const AbiTypeScope = {\n  types: Object.fromEntries(schemaAbiTypes.map((abiType) => [abiType, abiType])),\n} as AbiTypeScope;\n\nexport type ScopeOptions<types extends Dict<string, AbiType> = Dict<string, AbiType>> = {\n  types: types;\n};\n\nexport type getStaticAbiTypeKeys<\n  schema extends SchemaInput,\n  scope extends Scope = AbiTypeScope,\n> = SchemaInput extends schema\n  ? string\n  : {\n      [key in keyof schema]: scope[\"types\"] extends { [_ in schema[key]]: StaticAbiType } ? key : never;\n    }[keyof schema];\n\nexport type extendScope<scope extends ScopeOptions, additionalTypes extends Dict<string, AbiType>> = evaluate<\n  ScopeOptions<evaluate<scope[\"types\"] & additionalTypes>>\n>;\n\nexport function extendScope<scope extends ScopeOptions, additionalTypes extends Dict<string, AbiType>>(\n  scope: scope,\n  additionalTypes: additionalTypes,\n): extendScope<scope, additionalTypes> {\n  return {\n    types: {\n      ...scope.types,\n      ...additionalTypes,\n    },\n  };\n}\n","import { conform, evaluate } from \"@arktype/util\";\nimport { AbiTypeScope, Scope } from \"./scope\";\nimport { hasOwnKey, isObject } from \"./generics\";\nimport { SchemaInput } from \"./input\";\nimport { FixedArrayAbiType, fixedArrayToArray, isFixedArrayAbiType } from \"@latticexyz/schema-type/internal\";\n\nexport type validateSchema<schema, scope extends Scope = AbiTypeScope> = schema extends string\n  ? SchemaInput\n  : {\n      [key in keyof schema]: schema[key] extends FixedArrayAbiType\n        ? schema[key]\n        : conform<schema[key], keyof scope[\"types\"]>;\n    };\n\nexport function validateSchema<scope extends Scope = AbiTypeScope>(\n  schema: unknown,\n  scope: scope = AbiTypeScope as never,\n): asserts schema is SchemaInput {\n  if (!isObject(schema)) {\n    throw new Error(`Expected schema, received ${JSON.stringify(schema)}`);\n  }\n\n  for (const internalType of Object.values(schema)) {\n    if (isFixedArrayAbiType(internalType)) continue;\n    if (hasOwnKey(scope.types, internalType)) continue;\n    throw new Error(`\"${String(internalType)}\" is not a valid type in this scope.`);\n  }\n}\n\nexport type resolveSchema<schema, scope extends Scope> = evaluate<{\n  readonly [key in keyof schema]: {\n    /** the Solidity primitive ABI type */\n    readonly type: schema[key] extends FixedArrayAbiType\n      ? fixedArrayToArray<schema[key]>\n      : scope[\"types\"][schema[key] & keyof scope[\"types\"]];\n    /** the user defined type or Solidity primitive ABI type */\n    readonly internalType: schema[key];\n  };\n}>;\n\nexport function resolveSchema<schema extends SchemaInput, scope extends Scope = AbiTypeScope>(\n  schema: schema,\n  scope: scope = AbiTypeScope as unknown as scope,\n): resolveSchema<schema, scope> {\n  return Object.fromEntries(\n    Object.entries(schema).map(([key, internalType]) => [\n      key,\n      {\n        type: isFixedArrayAbiType(internalType) ? fixedArrayToArray(internalType) : scope.types[internalType as never],\n        internalType,\n      },\n    ]),\n  ) as never;\n}\n\nexport function defineSchema<schema, scope extends AbiTypeScope = AbiTypeScope>(\n  schema: validateSchema<schema, scope>,\n  scope: scope = AbiTypeScope as scope,\n): resolveSchema<schema, scope> {\n  validateSchema(schema, scope);\n  return resolveSchema(schema, scope) as never;\n}\n\nexport function isSchemaInput<scope extends Scope = AbiTypeScope>(\n  input: unknown,\n  scope: scope = AbiTypeScope as never,\n): input is SchemaInput {\n  return (\n    typeof input === \"object\" &&\n    input != null &&\n    Object.values(input).every((fieldType) => isFixedArrayAbiType(fieldType) || hasOwnKey(scope.types, fieldType))\n  );\n}\n","import { ErrorMessage, conform, evaluate, narrow, requiredKeyOf } from \"@arktype/util\";\nimport { isStaticAbiType } from \"@latticexyz/schema-type/internal\";\nimport { Hex } from \"viem\";\nimport { get, hasOwnKey, mergeIfUndefined } from \"./generics\";\nimport { resolveSchema, validateSchema } from \"./schema\";\nimport { AbiTypeScope, Scope, getStaticAbiTypeKeys } from \"./scope\";\nimport { TableCodegen } from \"./output\";\nimport { TABLE_CODEGEN_DEFAULTS, TABLE_DEFAULTS, TABLE_DEPLOY_DEFAULTS } from \"./defaults\";\nimport { resourceToHex } from \"@latticexyz/common\";\nimport { SchemaInput, TableInput } from \"./input\";\n\nexport type ValidKeys<schema extends SchemaInput, scope extends Scope> = readonly [\n  getStaticAbiTypeKeys<schema, scope>,\n  ...getStaticAbiTypeKeys<schema, scope>[],\n];\n\nfunction getValidKeys<schema extends SchemaInput, scope extends Scope = AbiTypeScope>(\n  schema: schema,\n  scope: scope = AbiTypeScope as unknown as scope,\n): ValidKeys<schema, scope> {\n  return Object.entries(schema)\n    .filter(([, internalType]) => hasOwnKey(scope.types, internalType) && isStaticAbiType(scope.types[internalType]))\n    .map(([key]) => key) as never;\n}\n\nexport function isValidPrimaryKey<schema extends SchemaInput, scope extends Scope>(\n  key: unknown,\n  schema: schema,\n  scope: scope = AbiTypeScope as unknown as scope,\n): key is ValidKeys<schema, scope> {\n  return (\n    Array.isArray(key) &&\n    key.every(\n      (key) =>\n        hasOwnKey(schema, key) && hasOwnKey(scope.types, schema[key]) && isStaticAbiType(scope.types[schema[key]]),\n    )\n  );\n}\n\nexport type validateKeys<validKeys extends PropertyKey, keys> = keys extends readonly string[]\n  ? {\n      readonly [i in keyof keys]: keys[i] extends validKeys ? keys[i] : validKeys;\n    }\n  : readonly string[];\n\nexport type ValidateTableOptions = { inStoreContext: boolean };\n\nexport type requiredTableKey<inStoreContext extends boolean> = Exclude<\n  requiredKeyOf<TableInput>,\n  inStoreContext extends true ? \"name\" | \"namespace\" : \"\"\n>;\n\nexport type validateTable<\n  input,\n  scope extends Scope = AbiTypeScope,\n  options extends ValidateTableOptions = { inStoreContext: false },\n> = {\n  [key in keyof input | requiredTableKey<options[\"inStoreContext\"]>]: key extends \"key\"\n    ? validateKeys<getStaticAbiTypeKeys<conform<get<input, \"schema\">, SchemaInput>, scope>, get<input, key>>\n    : key extends \"schema\"\n      ? validateSchema<get<input, key>, scope>\n      : key extends \"name\" | \"namespace\"\n        ? options[\"inStoreContext\"] extends true\n          ? ErrorMessage<\"Overrides of `name` and `namespace` are not allowed for tables in a store config\">\n          : key extends keyof input\n            ? narrow<input[key]>\n            : never\n        : key extends keyof TableInput\n          ? TableInput[key]\n          : ErrorMessage<`Key \\`${key & string}\\` does not exist in TableInput`>;\n};\n\nexport function validateTable<input, scope extends Scope = AbiTypeScope>(\n  input: input,\n  scope: scope = AbiTypeScope as unknown as scope,\n  options: ValidateTableOptions = { inStoreContext: false },\n): asserts input is TableInput & input {\n  if (typeof input !== \"object\" || input == null) {\n    throw new Error(`Expected full table config, got \\`${JSON.stringify(input)}\\``);\n  }\n\n  if (!hasOwnKey(input, \"schema\")) {\n    throw new Error(\"Missing schema input\");\n  }\n  validateSchema(input.schema, scope);\n\n  if (!hasOwnKey(input, \"key\") || !isValidPrimaryKey(input[\"key\"], input[\"schema\"], scope)) {\n    throw new Error(\n      `Invalid key. Expected \\`(${getValidKeys(input[\"schema\"], scope)\n        .map((item) => `\"${String(item)}\"`)\n        .join(\" | \")})[]\\`, received \\`${\n        hasOwnKey(input, \"key\") && Array.isArray(input.key)\n          ? `[${input.key.map((item) => `\"${item}\"`).join(\", \")}]`\n          : String(get(input, \"key\"))\n      }\\``,\n    );\n  }\n\n  if ((options.inStoreContext && hasOwnKey(input, \"name\")) || hasOwnKey(input, \"namespace\")) {\n    throw new Error(\"Overrides of `name` and `namespace` are not allowed for tables in a store config.\");\n  }\n}\n\nexport type resolveTableCodegen<input extends TableInput> = evaluate<{\n  [key in keyof TableCodegen]-?: key extends keyof input[\"codegen\"]\n    ? undefined extends input[\"codegen\"][key]\n      ? key extends \"dataStruct\"\n        ? boolean\n        : key extends keyof TABLE_CODEGEN_DEFAULTS\n          ? TABLE_CODEGEN_DEFAULTS[key]\n          : never\n      : input[\"codegen\"][key]\n    : // dataStruct isn't narrowed, because its value is conditional on the number of value schema fields\n      key extends \"dataStruct\"\n      ? boolean\n      : key extends keyof TABLE_CODEGEN_DEFAULTS\n        ? TABLE_CODEGEN_DEFAULTS[key]\n        : never;\n}>;\n\nexport function resolveTableCodegen<input extends TableInput>(input: input): resolveTableCodegen<input> {\n  const options = input.codegen;\n  return {\n    outputDirectory: get(options, \"outputDirectory\") ?? TABLE_CODEGEN_DEFAULTS.outputDirectory,\n    tableIdArgument: get(options, \"tableIdArgument\") ?? TABLE_CODEGEN_DEFAULTS.tableIdArgument,\n    storeArgument: get(options, \"storeArgument\") ?? TABLE_CODEGEN_DEFAULTS.storeArgument,\n    // dataStruct is true if there are at least 2 value fields\n    dataStruct: get(options, \"dataStruct\") ?? Object.keys(input.schema).length - input.key.length > 1,\n  } satisfies TableCodegen as never;\n}\n\nexport type resolveTable<input, scope extends Scope = Scope> = input extends TableInput\n  ? {\n      readonly tableId: Hex;\n      readonly name: input[\"name\"];\n      readonly namespace: undefined extends input[\"namespace\"] ? typeof TABLE_DEFAULTS.namespace : input[\"namespace\"];\n      readonly type: undefined extends input[\"type\"] ? typeof TABLE_DEFAULTS.type : input[\"type\"];\n      readonly key: Readonly<input[\"key\"]>;\n      readonly schema: resolveSchema<input[\"schema\"], scope>;\n      readonly codegen: resolveTableCodegen<input>;\n      readonly deploy: mergeIfUndefined<\n        undefined extends input[\"deploy\"] ? {} : input[\"deploy\"],\n        TABLE_DEPLOY_DEFAULTS\n      >;\n    }\n  : never;\n\nexport function resolveTable<input extends TableInput, scope extends Scope = AbiTypeScope>(\n  input: input,\n  scope: scope = AbiTypeScope as unknown as scope,\n): resolveTable<input, scope> {\n  const name = input.name;\n  const type = input.type ?? TABLE_DEFAULTS.type;\n  const namespace = input.namespace ?? TABLE_DEFAULTS.namespace;\n  const tableId = input.tableId ?? resourceToHex({ type, namespace, name });\n\n  return {\n    tableId,\n    name,\n    namespace,\n    type,\n    key: input.key,\n    schema: resolveSchema(input.schema, scope),\n    codegen: resolveTableCodegen(input),\n    deploy: mergeIfUndefined(input.deploy ?? {}, TABLE_DEPLOY_DEFAULTS),\n  } as never;\n}\n\nexport function defineTable<input, scope extends Scope = AbiTypeScope>(\n  input: validateTable<input, scope>,\n  scope: scope = AbiTypeScope as unknown as scope,\n): resolveTable<input, scope> {\n  validateTable(input, scope);\n  return resolveTable(input, scope) as never;\n}\n","import { ErrorMessage, evaluate } from \"@arktype/util\";\nimport { isObject, mergeIfUndefined } from \"./generics\";\nimport { TablesInput } from \"./input\";\nimport { Scope, AbiTypeScope } from \"./scope\";\nimport { validateTable, resolveTable } from \"./table\";\n\nexport type validateTables<tables, scope extends Scope = AbiTypeScope> = {\n  [key in keyof tables]: tables[key] extends object\n    ? validateTable<tables[key], scope, { inStoreContext: true }>\n    : ErrorMessage<`Expected full table config.`>;\n};\n\nexport function validateTables<scope extends Scope = AbiTypeScope>(\n  input: unknown,\n  scope: scope,\n): asserts input is TablesInput {\n  if (isObject(input)) {\n    for (const table of Object.values(input)) {\n      validateTable(table, scope, { inStoreContext: true });\n    }\n    return;\n  }\n  throw new Error(`Expected store config, received ${JSON.stringify(input)}`);\n}\n\nexport type resolveTables<tables, scope extends Scope = AbiTypeScope> = evaluate<{\n  readonly [key in keyof tables]: resolveTable<mergeIfUndefined<tables[key], { name: key }>, scope>;\n}>;\n\nexport function resolveTables<tables extends TablesInput, scope extends Scope = AbiTypeScope>(\n  tables: tables,\n  scope: scope = AbiTypeScope as unknown as scope,\n): resolveTables<tables, scope> {\n  if (!isObject(tables)) {\n    throw new Error(`Expected tables config, received ${JSON.stringify(tables)}`);\n  }\n\n  return Object.fromEntries(\n    Object.entries(tables).map(([key, table]) => {\n      return [key, resolveTable(mergeIfUndefined(table, { name: key }), scope)];\n    }),\n  ) as never;\n}\n","import { mapObject } from \"@latticexyz/common/utils\";\nimport { UserTypes } from \"./output\";\nimport { isSchemaAbiType } from \"@latticexyz/schema-type/internal\";\nimport { AbiTypeScope, extendScope } from \"./scope\";\nimport { hasOwnKey, isObject } from \"./generics\";\n\nexport type extractInternalType<userTypes extends UserTypes> = { [key in keyof userTypes]: userTypes[key][\"type\"] };\n\nexport function extractInternalType<userTypes extends UserTypes>(userTypes: userTypes): extractInternalType<userTypes> {\n  return mapObject(userTypes, (userType) => userType.type);\n}\n\nexport function isUserTypes(userTypes: unknown): userTypes is UserTypes {\n  return isObject(userTypes) && Object.values(userTypes).every((userType) => isSchemaAbiType(userType.type));\n}\n\nexport type scopeWithUserTypes<userTypes, scope extends AbiTypeScope = AbiTypeScope> = UserTypes extends userTypes\n  ? scope\n  : userTypes extends UserTypes\n    ? extendScope<scope, extractInternalType<userTypes>>\n    : scope;\n\nexport function scopeWithUserTypes<userTypes, scope extends AbiTypeScope = AbiTypeScope>(\n  userTypes: userTypes,\n  scope: scope = AbiTypeScope as scope,\n): scopeWithUserTypes<userTypes, scope> {\n  return (isUserTypes(userTypes) ? extendScope(scope, extractInternalType(userTypes)) : scope) as never;\n}\n\nexport function validateUserTypes(userTypes: unknown): asserts userTypes is UserTypes {\n  if (!isObject(userTypes)) {\n    throw new Error(`Expected userTypes, received ${JSON.stringify(userTypes)}`);\n  }\n\n  for (const { type } of Object.values(userTypes)) {\n    if (!hasOwnKey(AbiTypeScope.types, type)) {\n      throw new Error(`\"${String(type)}\" is not a valid ABI type.`);\n    }\n  }\n}\n","import { flatMorph } from \"@arktype/util\";\nimport { EnumsInput } from \"./input\";\nimport { AbiTypeScope, extendScope } from \"./scope\";\nimport { parseNumber } from \"./generics\";\n\nfunction isEnums(enums: unknown): enums is EnumsInput {\n  return (\n    typeof enums === \"object\" &&\n    enums != null &&\n    Object.values(enums).every((item) => Array.isArray(item) && item.every((element) => typeof element === \"string\"))\n  );\n}\n\nexport type scopeWithEnums<enums, scope extends AbiTypeScope = AbiTypeScope> = EnumsInput extends enums\n  ? scope\n  : enums extends EnumsInput\n    ? extendScope<scope, { [key in keyof enums]: \"uint8\" }>\n    : scope;\n\nexport function scopeWithEnums<enums, scope extends AbiTypeScope = AbiTypeScope>(\n  enums: enums,\n  scope: scope = AbiTypeScope as scope,\n): scopeWithEnums<enums, scope> {\n  if (isEnums(enums)) {\n    const enumScope = Object.fromEntries(Object.keys(enums).map((key) => [key, \"uint8\" as const]));\n    return extendScope(scope, enumScope) as never;\n  }\n  return scope as never;\n}\n\nexport type resolveEnums<enums> = {\n  readonly [key in keyof enums]: Readonly<enums[key]>;\n};\n\nexport function resolveEnums<enums extends EnumsInput>(enums: enums): resolveEnums<enums> {\n  return enums;\n}\n\nexport type mapEnums<enums> = {\n  readonly [key in keyof enums]: {\n    readonly [element in keyof enums[key] as enums[key][element] & string]: parseNumber<element>;\n  };\n};\n\nexport function mapEnums<enums extends EnumsInput>(enums: enums): resolveEnums<enums> {\n  return flatMorph(enums as EnumsInput, (enumName, enumElements) => [\n    enumName,\n    flatMorph(enumElements, (enumIndex, enumElement) => [enumElement, enumIndex]),\n  ]) as never;\n}\n","import { CODEGEN_DEFAULTS } from \"./defaults\";\nimport { isObject, mergeIfUndefined } from \"./generics\";\n\nexport type resolveCodegen<codegen> = codegen extends {}\n  ? mergeIfUndefined<codegen, CODEGEN_DEFAULTS>\n  : CODEGEN_DEFAULTS;\n\nexport function resolveCodegen<codegen>(codegen: codegen): resolveCodegen<codegen> {\n  return (\n    isObject(codegen) ? mergeIfUndefined(codegen, CODEGEN_DEFAULTS) : CODEGEN_DEFAULTS\n  ) as resolveCodegen<codegen>;\n}\n","import { ErrorMessage, evaluate, flatMorph, narrow } from \"@arktype/util\";\nimport { get, hasOwnKey, mergeIfUndefined } from \"./generics\";\nimport { UserTypes } from \"./output\";\nimport { CONFIG_DEFAULTS } from \"./defaults\";\nimport { StoreInput } from \"./input\";\nimport { resolveTables, validateTables } from \"./tables\";\nimport { scopeWithUserTypes, validateUserTypes } from \"./userTypes\";\nimport { mapEnums, resolveEnums, scopeWithEnums } from \"./enums\";\nimport { resolveCodegen } from \"./codegen\";\n\nexport type extendedScope<input> = scopeWithEnums<get<input, \"enums\">, scopeWithUserTypes<get<input, \"userTypes\">>>;\n\nexport function extendedScope<input>(input: input): extendedScope<input> {\n  return scopeWithEnums(get(input, \"enums\"), scopeWithUserTypes(get(input, \"userTypes\")));\n}\n\nexport type validateStore<store> = {\n  [key in keyof store]: key extends \"tables\"\n    ? validateTables<store[key], extendedScope<store>>\n    : key extends \"userTypes\"\n      ? UserTypes\n      : key extends \"enums\"\n        ? narrow<store[key]>\n        : key extends keyof StoreInput\n          ? StoreInput[key]\n          : ErrorMessage<`\\`${key & string}\\` is not a valid Store config option.`>;\n};\n\nexport function validateStore(store: unknown): asserts store is StoreInput {\n  const scope = extendedScope(store);\n  if (hasOwnKey(store, \"tables\")) {\n    validateTables(store.tables, scope);\n  }\n\n  if (hasOwnKey(store, \"userTypes\")) {\n    validateUserTypes(store.userTypes);\n  }\n}\n\ntype keyPrefix<store> = store extends { namespace: infer namespace extends string }\n  ? namespace extends \"\"\n    ? \"\"\n    : `${namespace}__`\n  : \"\";\n\nexport type resolveStore<store> = {\n  readonly sourceDirectory: \"sourceDirectory\" extends keyof store\n    ? store[\"sourceDirectory\"]\n    : CONFIG_DEFAULTS[\"sourceDirectory\"];\n  readonly tables: \"tables\" extends keyof store\n    ? resolveTables<\n        {\n          [tableKey in keyof store[\"tables\"] & string as `${keyPrefix<store>}${tableKey}`]: mergeIfUndefined<\n            store[\"tables\"][tableKey],\n            { namespace: get<store, \"namespace\">; name: tableKey }\n          >;\n        },\n        extendedScope<store>\n      >\n    : {};\n  readonly userTypes: \"userTypes\" extends keyof store ? store[\"userTypes\"] : {};\n  readonly enums: \"enums\" extends keyof store ? evaluate<resolveEnums<store[\"enums\"]>> : {};\n  readonly enumValues: \"enums\" extends keyof store ? evaluate<mapEnums<store[\"enums\"]>> : {};\n  readonly namespace: \"namespace\" extends keyof store ? store[\"namespace\"] : CONFIG_DEFAULTS[\"namespace\"];\n  readonly codegen: \"codegen\" extends keyof store ? resolveCodegen<store[\"codegen\"]> : resolveCodegen<{}>;\n};\n\nexport function resolveStore<const store extends StoreInput>(store: store): resolveStore<store> {\n  // TODO: default `namespaceDirectories` to true if using top-level `namespaces` key (once its migrated to store)\n  const codegen = resolveCodegen(store.codegen);\n  return {\n    sourceDirectory: store.sourceDirectory ?? CONFIG_DEFAULTS[\"sourceDirectory\"],\n    tables: resolveTables(\n      flatMorph(store.tables ?? {}, (name, table) => {\n        const namespace = store.namespace;\n        const key = namespace ? `${namespace}__${name}` : name;\n        return [\n          key,\n          mergeIfUndefined(table, {\n            namespace: namespace,\n            name,\n            codegen: mergeIfUndefined(table.codegen ?? {}, {\n              outputDirectory: codegen.namespaceDirectories && namespace?.length ? `${namespace}/tables` : \"tables\",\n            }),\n          }),\n        ];\n      }),\n      extendedScope(store),\n    ),\n    userTypes: store.userTypes ?? {},\n    enums: resolveEnums(store.enums ?? {}),\n    enumValues: mapEnums(store.enums ?? {}),\n    namespace: store.namespace ?? CONFIG_DEFAULTS[\"namespace\"],\n    codegen,\n  } as never;\n}\n\nexport function defineStore<const store>(store: validateStore<store>): resolveStore<store> {\n  validateStore(store);\n  return resolveStore(store) as never;\n}\n"],"mappings":"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","names":["get","input","key","hasOwnKey","getPath","path","object","isObject","mergeIfUndefined","base","merged","allKeys","CODEGEN_DEFAULTS","TABLE_CODEGEN_DEFAULTS","TABLE_DEPLOY_DEFAULTS","TABLE_DEFAULTS","CONFIG_DEFAULTS","schemaAbiTypes","Scope","AbiTypeScope","abiType","extendScope","scope","additionalTypes","fixedArrayToArray","isFixedArrayAbiType","validateSchema","schema","scope","AbiTypeScope","isObject","internalType","hasOwnKey","resolveSchema","key","defineSchema","isSchemaInput","input","fieldType","isStaticAbiType","resourceToHex","getValidKeys","schema","scope","AbiTypeScope","internalType","hasOwnKey","isStaticAbiType","key","isValidPrimaryKey","validateTable","input","options","validateSchema","item","get","resolveTableCodegen","TABLE_CODEGEN_DEFAULTS","resolveTable","name","type","TABLE_DEFAULTS","namespace","resolveSchema","mergeIfUndefined","TABLE_DEPLOY_DEFAULTS","defineTable","validateTables","input","scope","isObject","table","validateTable","resolveTables","tables","AbiTypeScope","key","resolveTable","mergeIfUndefined","mapObject","isSchemaAbiType","extractInternalType","userTypes","mapObject","userType","isUserTypes","isObject","isSchemaAbiType","scopeWithUserTypes","scope","AbiTypeScope","extendScope","validateUserTypes","type","hasOwnKey","flatMorph","isEnums","enums","item","element","scopeWithEnums","scope","AbiTypeScope","enumScope","key","extendScope","resolveEnums","mapEnums","flatMorph","enumName","enumElements","enumIndex","enumElement","resolveCodegen","codegen","isObject","mergeIfUndefined","CODEGEN_DEFAULTS","flatMorph","extendedScope","input","scopeWithEnums","get","scopeWithUserTypes","validateStore","store","scope","hasOwnKey","validateTables","validateUserTypes","resolveStore","codegen","resolveCodegen","CONFIG_DEFAULTS","resolveTables","flatMorph","name","table","namespace","mergeIfUndefined","mapEnums","defineStore"]}

package/dist/{chunk-FPBRFXSD.js → chunk-A5IJU7DR.js}

@@ -1,2 +1,2 @@
-var l={storeImportPath:"@latticexyz/store/src/",userTypesFilename:"common.sol",codegenDirectory:"codegen",codegenIndexFilename:"index.sol"},p={namespace:"",enums:{},userTypes:{}},c={directory:"tables",keySchema:{key:"bytes32"},tableIdArgument:!1,storeArgument:!1,offchainOnly:!1};import{AbiTypes as k,StaticAbiTypes as R}from"@latticexyz/schema-type/deprecated";import{z as r,ZodIssueCode as T}from"zod";import{getDuplicates as g,parseStaticArray as U,STORE_NAME_MAX_LENGTH as D,zObjectName as d,zUserEnum as z,zValueName as b,zNamespace as O,zName as L}from"@latticexyz/config/library";import{isSchemaAbiType as j,schemaAbiTypes as I}from"@latticexyz/schema-type/internal";var K=d,_=b,V=b,P=d,B=d,u=r.string(),$=r.string(),q=r.record(_,$).default(c.keySchema),h=r.record(V,u).refine(e=>Object.keys(e).length>0,"Table schema may not be empty"),H=u.transform(e=>h.parse({value:e})),M=h.or(H);function Se(e,n){let s={};for(let[t,a]of Object.entries(e))if(j(a))s[t]=a;else if(n[a]!==void 0)s[t]=n[a].internalType;else{let o=U(a);if(!o)throw new Error(`Unexpected type: ${a}`);s[t]=`${o.elementType}[]`}return s}var x=r.object({directory:r.string().default(c.directory),name:L.optional(),tableIdArgument:r.boolean().default(c.tableIdArgument),storeArgument:r.boolean().default(c.storeArgument),dataStruct:r.boolean().optional(),keySchema:q,valueSchema:M,offchainOnly:r.boolean().default(c.offchainOnly)}).transform(e=>(Object.keys(e.valueSchema).length===1?e.dataStruct??=!1:e.dataStruct??=!0,e)),w=u.transform(e=>x.parse({valueSchema:{value:e}})),G=x.or(w),X=r.record(K,G).transform(e=>{for(let n of Object.keys(e)){let s=e[n];s.name=n.slice(0,D),e[n]=s}return e}),Z=r.object({enums:r.record(P,z).default(p.enums)}),J=r.object({filePath:r.string(),internalType:r.enum(I)}),Q=r.object({userTypes:r.record(B,J).default(p.userTypes)}),C=r.object({namespace:O.default(p.namespace),storeImportPath:r.string().default(l.storeImportPath),tables:X,userTypesFilename:r.string().default(l.userTypesFilename),codegenDirectory:r.string().default(l.codegenDirectory),codegenIndexFilename:r.string().default(l.codegenIndexFilename)}).merge(Z).merge(Q),fe=C.superRefine(E),Ue=C.catchall(r.any()).superRefine(E);function E(e,n){for(let i of Object.values(e.tables)){let y=Object.keys(i.keySchema),v=Object.keys(i.valueSchema),f=g([...y,...v]);f.length>0&&n.addIssue({code:T.custom,message:`Field and key names within one table must be unique: ${f.join(", ")}`})}let s=Object.keys(e.tables),t=[...Object.keys(e.enums),...Object.keys(e.userTypes)],a=t,o=[...s,...a],m=g(o);m.length>0&&n.addIssue({code:T.custom,message:`Table library names, enum names, user type names must be globally unique: ${m.join(", ")}`});let A=Object.values(e.tables).map(({name:i})=>i),S=g(A);S.length>0&&n.addIssue({code:T.custom,message:`Table names must be unique: ${S.join(", ")}`});for(let i of Object.values(e.tables)){for(let y of Object.values(i.keySchema))F(t,y,n);for(let y of Object.values(i.valueSchema))W(a,t,y,n)}}function W(e,n,s,t){if(!k.includes(s)&&!e.includes(s)){let a=U(s);a?Y(n,a.elementType,a.staticLength,t):t.addIssue({code:T.custom,message:`${s} is not a valid abi type, and is not defined in userTypes`})}}function F(e,n,s){!R.includes(n)&&!e.includes(n)&&s.addIssue({code:T.custom,message:`${n} is not a static type`})}function Y(e,n,s,t){F(e,n,t),s===0?t.addIssue({code:T.custom,message:"Static array length must not be 0"}):s>=2**16&&t.addIssue({code:T.custom,message:"Static array length must be less than 2**16"})}import{mapObject as ee}from"@latticexyz/common/utils";import{resourceToHex as ne}from"@latticexyz/common";function Ce(e){let n={};for(let s of Object.keys(e.tables))n[s]=se(e.tables[s],e.userTypes,Object.keys(e.enums),e.namespace,s);return{tables:n}}function se(e,n,s,t,a){let{keySchema:o,valueSchema:m}=e;return{keySchema:te(o,n,s),valueSchema:re(m,n,s),namespace:t,name:a,tableId:ne({type:e.offchainOnly?"offchainTable":"table",namespace:t,name:a})}}function te(e,n,s){let t=e==null?{key:"bytes32"}:typeof e=="string"?{key:e}:e;return N(t,n,s)}function re(e,n,s){return N(typeof e=="string"?{value:e}:e,n,s)}function N(e,n,s){return ee(e,(t,a)=>{let o=n&&t in n,m=s.includes(t);return{type:o?n[t].internalType:m?"uint8":t,internalType:t}})}export{l as a,p as b,c,M as d,Se as e,G as f,X as g,Z as h,Q as i,fe as j,Ue as k,Ce as l};
-//# sourceMappingURL=chunk-FPBRFXSD.js.map
+var l={storeImportPath:"@latticexyz/store/src/",userTypesFilename:"common.sol",codegenDirectory:"codegen",codegenIndexFilename:"index.sol"},p={namespace:"",enums:{},userTypes:{}},c={directory:"tables",keySchema:{key:"bytes32"},tableIdArgument:!1,storeArgument:!1,offchainOnly:!1};import{AbiTypes as k,StaticAbiTypes as R}from"@latticexyz/schema-type/deprecated";import{z as r,ZodIssueCode as T}from"zod";import{getDuplicates as g,parseStaticArray as U,STORE_NAME_MAX_LENGTH as D,zObjectName as d,zUserEnum as z,zValueName as b,zNamespace as O,zName as j}from"@latticexyz/config/library";import{isSchemaAbiType as L,schemaAbiTypes as I}from"@latticexyz/schema-type/internal";var K=d,_=b,V=b,P=d,B=d,u=r.string(),$=r.string(),q=r.record(_,$).default(c.keySchema),h=r.record(V,u).refine(e=>Object.keys(e).length>0,"Table schema may not be empty"),H=u.transform(e=>h.parse({value:e})),M=h.or(H);function Se(e,n){let s={};for(let[t,a]of Object.entries(e))if(L(a))s[t]=a;else if(n[a]!==void 0)s[t]=n[a].internalType;else{let o=U(a);if(!o)throw new Error(`Unexpected type: ${a}`);s[t]=`${o.elementType}[]`}return s}var x=r.object({directory:r.string().default(c.directory),name:j.optional(),tableIdArgument:r.boolean().default(c.tableIdArgument),storeArgument:r.boolean().default(c.storeArgument),dataStruct:r.boolean().optional(),keySchema:q,valueSchema:M,offchainOnly:r.boolean().default(c.offchainOnly)}).transform(e=>(Object.keys(e.valueSchema).length===1?e.dataStruct??=!1:e.dataStruct??=!0,e)),w=u.transform(e=>x.parse({valueSchema:{value:e}})),G=x.or(w),X=r.record(K,G).transform(e=>{for(let n of Object.keys(e)){let s=e[n];s.name=n.slice(0,D),e[n]=s}return e}),Z=r.object({enums:r.record(P,z).default(p.enums)}),J=r.object({filePath:r.string(),internalType:r.enum(I)}),Q=r.object({userTypes:r.record(B,J).default(p.userTypes)}),C=r.object({namespace:O.default(p.namespace),storeImportPath:r.string().default(l.storeImportPath),tables:X,userTypesFilename:r.string().default(l.userTypesFilename),codegenDirectory:r.string().default(l.codegenDirectory),codegenIndexFilename:r.string().default(l.codegenIndexFilename)}).merge(Z).merge(Q),fe=C.superRefine(E),Ue=C.catchall(r.any()).superRefine(E);function E(e,n){for(let i of Object.values(e.tables)){let y=Object.keys(i.keySchema),A=Object.keys(i.valueSchema),f=g([...y,...A]);f.length>0&&n.addIssue({code:T.custom,message:`Field and key names within one table must be unique: ${f.join(", ")}`})}let s=Object.keys(e.tables),t=[...Object.keys(e.enums),...Object.keys(e.userTypes)],a=t,o=[...s,...a],m=g(o);m.length>0&&n.addIssue({code:T.custom,message:`Table library names, enum names, user type names must be globally unique: ${m.join(", ")}`});let v=Object.values(e.tables).map(({name:i})=>i),S=g(v);S.length>0&&n.addIssue({code:T.custom,message:`Table names must be unique: ${S.join(", ")}`});for(let i of Object.values(e.tables)){for(let y of Object.values(i.keySchema))F(t,y,n);for(let y of Object.values(i.valueSchema))W(a,t,y,n)}}function W(e,n,s,t){if(!k.includes(s)&&!e.includes(s)){let a=U(s);a?Y(n,a.elementType,a.staticLength,t):t.addIssue({code:T.custom,message:`${s} is not a valid abi type, and is not defined in userTypes`})}}function F(e,n,s){!R.includes(n)&&!e.includes(n)&&s.addIssue({code:T.custom,message:`${n} is not a static type`})}function Y(e,n,s,t){F(e,n,t),s===0?t.addIssue({code:T.custom,message:"Static array length must not be 0"}):s>=2**16&&t.addIssue({code:T.custom,message:"Static array length must be less than 2**16"})}import{mapObject as ee}from"@latticexyz/common/utils";import{resourceToHex as ne}from"@latticexyz/common";function Ce(e){let n={};for(let s of Object.keys(e.tables))n[s]=se(e.tables[s],e.userTypes,Object.keys(e.enums),e.namespace,s);return{tables:n}}function se(e,n,s,t,a){let{keySchema:o,valueSchema:m}=e;return{keySchema:te(o,n,s),valueSchema:re(m,n,s),namespace:t,name:a,tableId:ne({type:e.offchainOnly?"offchainTable":"table",namespace:t,name:a})}}function te(e,n,s){let t=e==null?{key:"bytes32"}:typeof e=="string"?{key:e}:e;return N(t,n,s)}function re(e,n,s){return N(typeof e=="string"?{value:e}:e,n,s)}function N(e,n,s){return ee(e,(t,a)=>{let o=n&&t in n,m=s.includes(t);return{type:o?n[t].internalType:m?"uint8":t,internalType:t}})}export{l as a,p as b,c,M as d,Se as e,G as f,X as g,Z as h,Q as i,fe as j,Ue as k,Ce as l};
+//# sourceMappingURL=chunk-A5IJU7DR.js.map

package/dist/chunk-A5IJU7DR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../ts/config/defaults.ts","../ts/config/storeConfig.ts","../ts/config/experimental/resolveConfig.ts"],"sourcesContent":["export const PATH_DEFAULTS = {\n  storeImportPath: \"@latticexyz/store/src/\",\n  userTypesFilename: \"common.sol\",\n  codegenDirectory: \"codegen\",\n  codegenIndexFilename: \"index.sol\",\n} as const;\n\nexport type PATH_DEFAULTS = typeof PATH_DEFAULTS;\n\nexport const DEFAULTS = {\n  namespace: \"\",\n  enums: {},\n  userTypes: {},\n} as const;\n\nexport type DEFAULTS = typeof DEFAULTS;\n\nexport const TABLE_DEFAULTS = {\n  directory: \"tables\",\n  keySchema: { key: \"bytes32\" },\n  tableIdArgument: false,\n  storeArgument: false,\n  offchainOnly: false,\n} as const;\n\nexport type TABLE_DEFAULTS = typeof TABLE_DEFAULTS;\n","import { AbiType, AbiTypes, StaticAbiType, StaticAbiTypes, StaticArray } from \"@latticexyz/schema-type/deprecated\";\nimport { RefinementCtx, z, ZodIssueCode } from \"zod\";\nimport type {\n  AsDependent,\n  ExtractUserTypes,\n  OrDefaults,\n  RequireKeys,\n  StringForUnion,\n} from \"@latticexyz/common/type-utils\";\nimport {\n  // validation utils\n  getDuplicates,\n  parseStaticArray,\n  STORE_NAME_MAX_LENGTH,\n  // config\n  MUDCoreUserConfig,\n  // schemas\n  zObjectName,\n  zUserEnum,\n  zValueName,\n  zNamespace,\n  zName,\n} from \"@latticexyz/config/library\";\nimport { DEFAULTS, PATH_DEFAULTS, TABLE_DEFAULTS } from \"./defaults\";\nimport { UserType } from \"@latticexyz/common/codegen\";\nimport { SchemaAbiType, isSchemaAbiType, schemaAbiTypes } from \"@latticexyz/schema-type/internal\";\n\nconst zTableName = zObjectName;\nconst zKeyName = zValueName;\nconst zColumnName = zValueName;\nconst zUserEnumName = zObjectName;\nconst zUserTypeName = zObjectName;\n\n// Fields can use AbiType or one of user-defined wrapper types\n// (user types are refined later, based on the appropriate config options)\nconst zFieldData = z.string();\n\nexport type FieldData<UserTypes extends StringForUnion> = AbiType | StaticArray | UserTypes;\n\n// Primary keys allow only static types\n// (user types are refined later, based on the appropriate config options)\nconst zKeyElementSchema = z.string();\nconst zKeySchema = z.record(zKeyName, zKeyElementSchema).default(TABLE_DEFAULTS.keySchema);\n\ntype KeySchema<StaticUserTypes extends StringForUnion> = StaticAbiType | StaticUserTypes;\n\n/************************************************************************\n *\n *    TABLE SCHEMA\n *\n ************************************************************************/\n\nexport type FullSchemaConfig<UserTypes extends StringForUnion = StringForUnion> = Record<string, FieldData<UserTypes>>;\nexport type ShorthandSchemaConfig<UserTypes extends StringForUnion = StringForUnion> = FieldData<UserTypes>;\nexport type SchemaConfig<UserTypes extends StringForUnion = StringForUnion> =\n  | FullSchemaConfig<UserTypes>\n  | ShorthandSchemaConfig<UserTypes>;\n\nexport type ExpandSchemaConfig<TSchemaConfig extends SchemaConfig<string>> =\n  TSchemaConfig extends ShorthandSchemaConfig<string> ? { value: TSchemaConfig } : TSchemaConfig;\n\nconst zFullSchemaConfig = z\n  .record(zColumnName, zFieldData)\n  .refine((arg) => Object.keys(arg).length > 0, \"Table schema may not be empty\");\n\nconst zShorthandSchemaConfig = zFieldData.transform((fieldData) => {\n  return zFullSchemaConfig.parse({\n    value: fieldData,\n  });\n});\n\nexport const zSchemaConfig = zFullSchemaConfig.or(zShorthandSchemaConfig);\n\ntype ResolvedSchema<\n  TSchema extends Record<string, string>,\n  TUserTypes extends Record<string, Pick<UserType, \"internalType\">>,\n> = {\n  [key in keyof TSchema]: TSchema[key] extends keyof TUserTypes\n    ? TUserTypes[TSchema[key]][\"internalType\"]\n    : TSchema[key];\n};\n\n// TODO: add strong types to UserTypes config and use them here\n// (see https://github.com/latticexyz/mud/pull/1588)\nexport function resolveUserTypes<\n  TSchema extends Record<string, string>,\n  TUserTypes extends Record<string, Pick<UserType, \"internalType\">>,\n>(schema: TSchema, userTypes: TUserTypes): ResolvedSchema<TSchema, TUserTypes> {\n  const resolvedSchema: Record<string, SchemaAbiType> = {};\n  for (const [key, value] of Object.entries(schema)) {\n    if (isSchemaAbiType(value)) {\n      resolvedSchema[key] = value;\n    } else if (userTypes[value] !== undefined) {\n      resolvedSchema[key] = userTypes[value].internalType as SchemaAbiType;\n    } else {\n      const staticArray = parseStaticArray(value);\n      if (!staticArray) throw new Error(`Unexpected type: ${value}`);\n      resolvedSchema[key] = `${staticArray.elementType as StaticAbiType}[]`;\n    }\n  }\n  return resolvedSchema as ResolvedSchema<TSchema, TUserTypes>;\n}\n\n/************************************************************************\n *\n *    TABLE\n *\n ************************************************************************/\n\nexport interface TableConfig<\n  UserTypes extends StringForUnion = StringForUnion,\n  StaticUserTypes extends StringForUnion = StringForUnion,\n> {\n  /** Output directory path for the file. Default is \"tables\" */\n  directory?: string;\n  /** Make methods accept `tableId` argument instead of it being a hardcoded constant. Default is false */\n  tableIdArgument?: boolean;\n  /** Include methods that accept a manual `IStore` argument. Default is true. */\n  storeArgument?: boolean;\n  /** Include a data struct and methods for it. Default is false for 1-column tables; true for multi-column tables. */\n  dataStruct?: boolean;\n  /** Offchain tables don't write to onchain storage, but only emit events for offchain clients. Default is false. */\n  offchainOnly?: boolean;\n  /**\n   * Table's key names mapped to their types.\n   * Default is `{ key: \"bytes32\" }`\n   * Key names' first letter should be lowercase.\n   */\n  keySchema?: Record<string, KeySchema<StaticUserTypes>>;\n  /**\n   * Table's field names mapped to their types.\n   * Field names' first letter should be lowercase.\n   */\n  valueSchema: SchemaConfig<UserTypes>;\n}\n\nexport type FullTableConfig<\n  UserTypes extends StringForUnion = StringForUnion,\n  StaticUserTypes extends StringForUnion = StringForUnion,\n> = Required<TableConfig<UserTypes, StaticUserTypes>> & {\n  valueSchema: FullSchemaConfig<UserTypes>;\n};\n\nexport interface ExpandTableConfig<T extends TableConfig<string, string>, TableName extends string>\n  extends OrDefaults<\n    T,\n    {\n      directory: string;\n      name: TableName;\n      tableIdArgument: typeof TABLE_DEFAULTS.tableIdArgument;\n      storeArgument: typeof TABLE_DEFAULTS.storeArgument;\n      // dataStruct isn't expanded, because its value is conditional on the number of value schema fields\n      dataStruct: boolean;\n      keySchema: typeof TABLE_DEFAULTS.keySchema;\n      offchainOnly: typeof TABLE_DEFAULTS.offchainOnly;\n    }\n  > {\n  valueSchema: ExpandSchemaConfig<T[\"valueSchema\"]>;\n}\n\nconst zFullTableConfig = z\n  .object({\n    directory: z.string().default(TABLE_DEFAULTS.directory),\n    name: zName.optional(),\n    tableIdArgument: z.boolean().default(TABLE_DEFAULTS.tableIdArgument),\n    storeArgument: z.boolean().default(TABLE_DEFAULTS.storeArgument),\n    dataStruct: z.boolean().optional(),\n    keySchema: zKeySchema,\n    valueSchema: zSchemaConfig,\n    offchainOnly: z.boolean().default(TABLE_DEFAULTS.offchainOnly),\n  })\n  .transform((arg) => {\n    // default dataStruct value depends on value schema's length\n    if (Object.keys(arg.valueSchema).length === 1) {\n      arg.dataStruct ??= false;\n    } else {\n      arg.dataStruct ??= true;\n    }\n    return arg as RequireKeys<typeof arg, \"dataStruct\">;\n  });\n\nconst zShorthandTableConfig = zFieldData.transform((fieldData) => {\n  return zFullTableConfig.parse({\n    valueSchema: {\n      value: fieldData,\n    },\n  });\n});\n\nexport const zTableConfig = zFullTableConfig.or(zShorthandTableConfig);\n\n/************************************************************************\n *\n *    TABLES\n *\n ************************************************************************/\n\nexport type TablesConfig<\n  UserTypes extends StringForUnion = StringForUnion,\n  StaticUserTypes extends StringForUnion = StringForUnion,\n> = Record<string, TableConfig<UserTypes, StaticUserTypes> | FieldData<UserTypes>>;\n\nexport const zTablesConfig = z.record(zTableName, zTableConfig).transform((tables) => {\n  // default name depends on tableName\n  for (const tableName of Object.keys(tables)) {\n    const table = tables[tableName];\n    table.name = tableName.slice(0, STORE_NAME_MAX_LENGTH);\n\n    tables[tableName] = table;\n  }\n  return tables as Record<string, RequireKeys<(typeof tables)[string], \"name\">>;\n});\n\nexport type FullTablesConfig<\n  UserTypes extends StringForUnion = StringForUnion,\n  StaticUserTypes extends StringForUnion = StringForUnion,\n> = Record<string, FullTableConfig<UserTypes, StaticUserTypes>>;\n\nexport type ExpandTablesConfig<T extends TablesConfig<string, string>> = {\n  [TableName in keyof T]: T[TableName] extends FieldData<string>\n    ? ExpandTableConfig<{ valueSchema: { value: T[TableName] } }, TableName extends string ? TableName : never>\n    : T[TableName] extends TableConfig<string, string>\n      ? ExpandTableConfig<T[TableName], TableName extends string ? TableName : never>\n      : // Weakly typed values get a weakly typed expansion.\n        // This shouldn't normally happen within `mudConfig`, but can be manually triggered via `ExpandMUDUserConfig`\n        ExpandTableConfig<TableConfig<string, string>, TableName extends string ? TableName : string>;\n};\n\n/************************************************************************\n *\n *    ENUMS\n *\n ************************************************************************/\n\nexport type EnumsConfig<EnumNames extends StringForUnion> = never extends EnumNames\n  ? {\n      /**\n       * Enum names mapped to lists of their member names\n       *\n       * (enums are inferred to be absent)\n       */\n      enums?: Record<EnumNames, string[]>;\n    }\n  : StringForUnion extends EnumNames\n    ? {\n        /**\n         * Enum names mapped to lists of their member names\n         *\n         * (enums aren't inferred - use `mudConfig` or `storeConfig` helper, and `as const` for variables)\n         */\n        enums?: Record<EnumNames, string[]>;\n      }\n    : {\n        /**\n         * Enum names mapped to lists of their member names\n         *\n         * Enums defined here can be used as types in table schemas/keys\n         */\n        enums: Record<EnumNames, string[]>;\n      };\n\nexport type FullEnumsConfig<EnumNames extends StringForUnion> = {\n  enums: Record<EnumNames, string[]>;\n};\n\nexport const zEnumsConfig = z.object({\n  enums: z.record(zUserEnumName, zUserEnum).default(DEFAULTS.enums),\n});\n\n/************************************************************************\n *\n *    USER TYPES\n *\n ************************************************************************/\n\nexport type UserTypesConfig<UserTypeNames extends StringForUnion = StringForUnion> = never extends UserTypeNames\n  ? {\n      /**\n       * User types mapped to file paths from which to import them.\n       * Paths are treated as relative to root.\n       * Paths that don't start with a \".\" have foundry remappings applied to them first.\n       *\n       * (user types are inferred to be absent)\n       */\n      userTypes?: Record<UserTypeNames, UserType>;\n    }\n  : StringForUnion extends UserTypeNames\n    ? {\n        /**\n         * User types mapped to file paths from which to import them.\n         * Paths are treated as relative to root.\n         * Paths that don't start with a \".\" have foundry remappings applied to them first.\n         *\n         * (user types aren't inferred - use `mudConfig` or `storeConfig` helper, and `as const` for variables)\n         */\n        userTypes?: Record<UserTypeNames, UserType>;\n      }\n    : {\n        /**\n         * User types mapped to file paths from which to import them.\n         * Paths are treated as relative to root.\n         * Paths that don't start with a \".\" have foundry remappings applied to them first.\n         *\n         * User types defined here can be used as types in table schemas/keys\n         */\n        userTypes: Record<UserTypeNames, UserType>;\n      };\n\nconst zUserTypeConfig = z.object({\n  filePath: z.string(),\n  internalType: z.enum(schemaAbiTypes),\n});\n\nexport const zUserTypesConfig = z.object({\n  userTypes: z.record(zUserTypeName, zUserTypeConfig).default(DEFAULTS.userTypes),\n});\n\n/************************************************************************\n *\n *    FINAL\n *\n ************************************************************************/\n\n// zod doesn't preserve doc comments\n/** MUDCoreUserConfig wrapper to use generics in some options for better type inference */\nexport type MUDUserConfig<\n  T extends MUDCoreUserConfig = MUDCoreUserConfig,\n  EnumNames extends StringForUnion = StringForUnion,\n  UserTypeNames extends StringForUnion = StringForUnion,\n  StaticUserTypes extends ExtractUserTypes<EnumNames | UserTypeNames> = ExtractUserTypes<EnumNames | UserTypeNames>,\n> = T &\n  EnumsConfig<EnumNames> &\n  UserTypesConfig<UserTypeNames> & {\n    /**\n     * Configuration for each table.\n     *\n     * The key is the table name (capitalized).\n     *\n     * The value:\n     *  - abi or user type for a single-value table.\n     *  - FullTableConfig object for multi-value tables (or for customizable options).\n     */\n    tables: TablesConfig<AsDependent<StaticUserTypes>, AsDependent<StaticUserTypes>>;\n    /** The namespace for table ids. Default is \"\" (ROOT) */\n    namespace?: string;\n    /** Path for store package imports. Default is \"@latticexyz/store/src/\" */\n    storeImportPath?: string;\n    /** Filename where common user types will be generated and imported from. Default is \"common.sol\" */\n    userTypesFilename?: string;\n    /** Path to the directory where generated files will be placed. (Default is \"codegen\") */\n    codegenDirectory?: string;\n    /** Filename where codegen index will be generated. Default is \"index.sol\" */\n    codegenIndexFilename?: string;\n  };\n\nconst StoreConfigUnrefined = z\n  .object({\n    namespace: zNamespace.default(DEFAULTS.namespace),\n    storeImportPath: z.string().default(PATH_DEFAULTS.storeImportPath),\n    tables: zTablesConfig,\n    userTypesFilename: z.string().default(PATH_DEFAULTS.userTypesFilename),\n    codegenDirectory: z.string().default(PATH_DEFAULTS.codegenDirectory),\n    codegenIndexFilename: z.string().default(PATH_DEFAULTS.codegenIndexFilename),\n  })\n  .merge(zEnumsConfig)\n  .merge(zUserTypesConfig);\n\n// finally validate global conditions\nexport const zStoreConfig = StoreConfigUnrefined.superRefine(validateStoreConfig);\n\nexport type StoreUserConfig = z.input<typeof zStoreConfig>;\nexport type StoreConfig = z.output<typeof zStoreConfig>;\n\n// Catchall preserves other plugins' options\nexport const zPluginStoreConfig = StoreConfigUnrefined.catchall(z.any()).superRefine(validateStoreConfig);\n\n/************************************************************************\n *\n *    HELPERS\n *\n ************************************************************************/\n\n// Validate conditions that check multiple different config options simultaneously\nfunction validateStoreConfig(config: z.output<typeof StoreConfigUnrefined>, ctx: RefinementCtx) {\n  // Local table variables must be unique within the table\n  for (const table of Object.values(config.tables)) {\n    const keySchemaNames = Object.keys(table.keySchema);\n    const fieldNames = Object.keys(table.valueSchema);\n    const duplicateVariableNames = getDuplicates([...keySchemaNames, ...fieldNames]);\n    if (duplicateVariableNames.length > 0) {\n      ctx.addIssue({\n        code: ZodIssueCode.custom,\n        message: `Field and key names within one table must be unique: ${duplicateVariableNames.join(\", \")}`,\n      });\n    }\n  }\n  // Global names must be unique\n  const tableLibraryNames = Object.keys(config.tables);\n  const staticUserTypeNames = [...Object.keys(config.enums), ...Object.keys(config.userTypes)];\n  const userTypeNames = staticUserTypeNames;\n  const globalNames = [...tableLibraryNames, ...userTypeNames];\n  const duplicateGlobalNames = getDuplicates(globalNames);\n  if (duplicateGlobalNames.length > 0) {\n    ctx.addIssue({\n      code: ZodIssueCode.custom,\n      message: `Table library names, enum names, user type names must be globally unique: ${duplicateGlobalNames.join(\n        \", \",\n      )}`,\n    });\n  }\n  // Table names used for tableId must be unique\n  const tableNames = Object.values(config.tables).map(({ name }) => name);\n  const duplicateTableNames = getDuplicates(tableNames);\n  if (duplicateTableNames.length > 0) {\n    ctx.addIssue({\n      code: ZodIssueCode.custom,\n      message: `Table names must be unique: ${duplicateTableNames.join(\", \")}`,\n    });\n  }\n  // User types must exist\n  for (const table of Object.values(config.tables)) {\n    for (const keySchemaType of Object.values(table.keySchema)) {\n      validateStaticAbiOrUserType(staticUserTypeNames, keySchemaType, ctx);\n    }\n    for (const fieldType of Object.values(table.valueSchema)) {\n      validateAbiOrUserType(userTypeNames, staticUserTypeNames, fieldType, ctx);\n    }\n  }\n}\n\nfunction validateAbiOrUserType(\n  userTypeNames: string[],\n  staticUserTypeNames: string[],\n  type: string,\n  ctx: RefinementCtx,\n) {\n  if (!(AbiTypes as string[]).includes(type) && !userTypeNames.includes(type)) {\n    const staticArray = parseStaticArray(type);\n    if (staticArray) {\n      validateStaticArray(staticUserTypeNames, staticArray.elementType, staticArray.staticLength, ctx);\n    } else {\n      ctx.addIssue({\n        code: ZodIssueCode.custom,\n        message: `${type} is not a valid abi type, and is not defined in userTypes`,\n      });\n    }\n  }\n}\n\nfunction validateStaticAbiOrUserType(staticUserTypeNames: string[], type: string, ctx: RefinementCtx) {\n  if (!(StaticAbiTypes as string[]).includes(type) && !staticUserTypeNames.includes(type)) {\n    ctx.addIssue({\n      code: ZodIssueCode.custom,\n      message: `${type} is not a static type`,\n    });\n  }\n}\n\nfunction validateStaticArray(\n  staticUserTypeNames: string[],\n  elementType: string,\n  staticLength: number,\n  ctx: RefinementCtx,\n) {\n  validateStaticAbiOrUserType(staticUserTypeNames, elementType, ctx);\n\n  if (staticLength === 0) {\n    ctx.addIssue({\n      code: ZodIssueCode.custom,\n      message: `Static array length must not be 0`,\n    });\n  } else if (staticLength >= 2 ** 16) {\n    ctx.addIssue({\n      code: ZodIssueCode.custom,\n      message: `Static array length must be less than 2**16`,\n    });\n  }\n}\n","import { StringForUnion } from \"@latticexyz/common/type-utils\";\nimport { StoreConfig, TableConfig, UserTypesConfig } from \"../storeConfig\";\nimport { UserType } from \"@latticexyz/common/codegen\";\nimport { mapObject } from \"@latticexyz/common/utils\";\nimport { resourceToHex } from \"@latticexyz/common\";\nimport { SchemaAbiType } from \"@latticexyz/schema-type/internal\";\n\n/**\n * @internal Internal only\n * @deprecated Internal only\n */\nexport type ResolvedStoreConfig<TStoreConfig extends StoreConfig> = {\n  tables: {\n    [TableKey in keyof TStoreConfig[\"tables\"] & string]: ResolvedTableConfig<\n      TStoreConfig[\"tables\"][TableKey],\n      TStoreConfig[\"userTypes\"],\n      keyof TStoreConfig[\"enums\"] & string,\n      TStoreConfig[\"namespace\"],\n      TableKey\n    >;\n  };\n};\n\ntype ResolvedTableConfig<\n  TTableConfig extends TableConfig,\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnumNames extends StringForUnion,\n  TNamespace extends string = string,\n  TName extends string = string,\n> = {\n  keySchema: ResolvedKeySchema<TTableConfig[\"keySchema\"], TUserTypes, TEnumNames>;\n  valueSchema: ResolvedValueSchema<TTableConfig[\"valueSchema\"], TUserTypes, TEnumNames>;\n  namespace: TNamespace;\n  name: TName;\n  tableId: `0x${string}`;\n};\n\ntype ResolvedKeySchema<\n  TKeySchema extends TableConfig[\"keySchema\"],\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnumNames extends StringForUnion,\n> = ResolvedSchema<TKeySchema, TUserTypes, TEnumNames>;\n\ntype ResolvedValueSchema<\n  TValueSchema extends TableConfig[\"valueSchema\"],\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnumNames extends StringForUnion,\n> = ResolvedSchema<Exclude<TValueSchema, string>, TUserTypes, TEnumNames>;\n\ntype ResolvedSchema<\n  TSchema extends Exclude<TableConfig[\"keySchema\"] | TableConfig[\"valueSchema\"], string>,\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnumNames extends StringForUnion,\n> = {\n  [key in keyof TSchema]: {\n    type: TSchema[key] extends SchemaAbiType\n      ? TSchema[key]\n      : TSchema[key] extends keyof TUserTypes\n        ? TUserTypes[TSchema[key]] extends UserType\n          ? // Note: we mistakenly named the plain ABI type \"internalType\",\n            // while in Solidity ABIs the plain ABI type is called \"type\" and\n            // and the custom type \"internalType\". We're planning to\n            // change our version and align with Solidity ABIs going forward.\n            TUserTypes[TSchema[key]][\"internalType\"]\n          : never\n        : TSchema[key] extends TEnumNames\n          ? \"uint8\"\n          : never;\n    internalType: TSchema[key];\n  };\n};\n\n/**\n * @internal Internal only\n * @deprecated Internal only\n */\nexport function resolveConfig<TStoreConfig extends StoreConfig>(\n  config: TStoreConfig,\n): ResolvedStoreConfig<TStoreConfig> {\n  const resolvedTables: Record<string, ReturnType<typeof resolveTable>> = {};\n\n  for (const key of Object.keys(config.tables)) {\n    resolvedTables[key] = resolveTable(\n      config.tables[key],\n      config.userTypes,\n      Object.keys(config.enums),\n      config.namespace,\n      key,\n    ) as ReturnType<typeof resolveTable>;\n  }\n\n  return {\n    tables: resolvedTables as ResolvedStoreConfig<TStoreConfig>[\"tables\"],\n  };\n}\n\nfunction resolveTable<\n  TTableConfig extends TableConfig,\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnums extends StringForUnion[],\n  TNamespace extends string,\n  TName extends string,\n>(\n  tableConfig: TTableConfig,\n  userTypes: TUserTypes,\n  enums: TEnums,\n  namespace: TNamespace,\n  name: TName,\n): ResolvedTableConfig<typeof tableConfig, TUserTypes, TEnums[number]> {\n  const { keySchema, valueSchema } = tableConfig;\n\n  return {\n    keySchema: resolveKeySchema(keySchema, userTypes, enums),\n    valueSchema: resolveValueSchema(valueSchema, userTypes, enums) as ResolvedSchema<\n      Exclude<TTableConfig[\"valueSchema\"], string>,\n      TUserTypes,\n      TEnums[number]\n    >,\n    namespace,\n    name,\n    tableId: resourceToHex({ type: tableConfig.offchainOnly ? \"offchainTable\" : \"table\", namespace, name }),\n  };\n}\n\nfunction resolveKeySchema<\n  TKeySchema extends TableConfig[\"keySchema\"],\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnums extends StringForUnion[],\n>(\n  keySchema: TKeySchema,\n  userTypes: TUserTypes,\n  enums: TEnums,\n): ResolvedKeySchema<TKeySchema extends undefined ? { key: \"bytes32\" } : TKeySchema, TUserTypes, TEnums[number]> {\n  const schema = (\n    keySchema == null ? { key: \"bytes32\" } : typeof keySchema === \"string\" ? { key: keySchema } : keySchema\n  ) as TKeySchema extends undefined ? { key: \"bytes32\" } : TKeySchema;\n  return resolveSchema(schema, userTypes, enums);\n}\n\nfunction resolveValueSchema<\n  TValueSchema extends TableConfig[\"valueSchema\"],\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnums extends StringForUnion[],\n>(\n  valueSchema: TValueSchema,\n  userTypes: TUserTypes,\n  enums: TEnums,\n): ResolvedValueSchema<TValueSchema, TUserTypes, TEnums[number]> {\n  const schema = (\n    typeof valueSchema === \"string\" ? ({ value: valueSchema } as unknown as TValueSchema) : valueSchema\n  ) as Exclude<TValueSchema, string>;\n  return resolveSchema(schema, userTypes, enums);\n}\n\nfunction resolveSchema<\n  TSchema extends Exclude<NonNullable<TableConfig[\"keySchema\"]> | TableConfig[\"valueSchema\"], string>,\n  TUserTypes extends UserTypesConfig[\"userTypes\"],\n  TEnums extends StringForUnion[],\n>(schema: TSchema, userTypes: TUserTypes, enums: TEnums): ResolvedSchema<TSchema, TUserTypes, TEnums[number]> {\n  return mapObject<TSchema, ResolvedSchema<TSchema, TUserTypes, TEnums[number]>>(schema, (value, key) => {\n    const isUserType = userTypes && value in userTypes;\n    const isEnum = enums.includes(value);\n    return {\n      type: (isUserType ? userTypes[value].internalType : isEnum ? (\"uint8\" as const) : value) as ResolvedSchema<\n        TSchema,\n        TUserTypes,\n        TEnums[number]\n      >[typeof key][\"type\"],\n      internalType: value,\n    };\n  });\n}\n"],"mappings":"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","names":["PATH_DEFAULTS","DEFAULTS","TABLE_DEFAULTS","AbiTypes","StaticAbiTypes","z","ZodIssueCode","getDuplicates","parseStaticArray","STORE_NAME_MAX_LENGTH","zObjectName","zUserEnum","zValueName","zNamespace","zName","isSchemaAbiType","schemaAbiTypes","zTableName","zObjectName","zKeyName","zValueName","zColumnName","zUserEnumName","zUserTypeName","zFieldData","z","zKeyElementSchema","zKeySchema","TABLE_DEFAULTS","zFullSchemaConfig","arg","zShorthandSchemaConfig","fieldData","zSchemaConfig","resolveUserTypes","schema","userTypes","resolvedSchema","key","value","staticArray","parseStaticArray","zFullTableConfig","zName","zShorthandTableConfig","zTableConfig","zTablesConfig","tables","tableName","table","STORE_NAME_MAX_LENGTH","zEnumsConfig","zUserEnum","DEFAULTS","zUserTypeConfig","zUserTypesConfig","StoreConfigUnrefined","zNamespace","PATH_DEFAULTS","zStoreConfig","validateStoreConfig","zPluginStoreConfig","config","ctx","keySchemaNames","fieldNames","duplicateVariableNames","getDuplicates","ZodIssueCode","tableLibraryNames","staticUserTypeNames","userTypeNames","globalNames","duplicateGlobalNames","tableNames","name","duplicateTableNames","keySchemaType","validateStaticAbiOrUserType","fieldType","validateAbiOrUserType","type","AbiTypes","validateStaticArray","StaticAbiTypes","elementType","staticLength","mapObject","resourceToHex","resolveConfig","config","resolvedTables","key","resolveTable","tableConfig","userTypes","enums","namespace","name","keySchema","valueSchema","resolveKeySchema","resolveValueSchema","schema","resolveSchema","value","isUserType","isEnum"]}

package/dist/{chunk-TDVY6TEY.js → chunk-VK6EP5GU.js}

@@ -1,2 +1,2 @@
-import{mapObject as r}from"@latticexyz/common/utils";import{getKeySchema as s,getValueSchema as c}from"@latticexyz/protocol-parser/internal";function l(t){let n=r(t.userTypes,({type:e,filePath:o})=>({internalType:e,filePath:o})),a=Object.fromEntries(Object.values(t.tables).map(e=>[e.name,{directory:e.codegen.outputDirectory,dataStruct:e.codegen.dataStruct,tableIdArgument:e.codegen.tableIdArgument,storeArgument:e.codegen.storeArgument,keySchema:r(s(e),o=>o.internalType),valueSchema:r(c(e),o=>o.internalType),offchainOnly:e.type==="offchainTable",name:e.name}]));return{namespace:t.namespace,enums:t.enums,userTypes:n,storeImportPath:t.codegen.storeImportPath,userTypesFilename:t.codegen.userTypesFilename,codegenDirectory:t.codegen.outputDirectory,codegenIndexFilename:t.codegen.indexFilename,tables:a,v2:t}}export{l as a};
-//# sourceMappingURL=chunk-TDVY6TEY.js.map
+import{mapObject as n}from"@latticexyz/common/utils";import{getKeySchema as s,getValueSchema as m}from"@latticexyz/protocol-parser/internal";function l(t){let o=n(t.userTypes,({type:e,filePath:r})=>({internalType:e,filePath:r})),a=Object.fromEntries(Object.values(t.tables).map(e=>[e.name,{directory:e.codegen.outputDirectory,dataStruct:e.codegen.dataStruct,tableIdArgument:e.codegen.tableIdArgument,storeArgument:e.codegen.storeArgument,keySchema:n(s(e),r=>r.internalType),valueSchema:n(m(e),r=>r.internalType),offchainOnly:e.type==="offchainTable",name:e.name}]));return{namespace:t.namespace,enums:t.enums,userTypes:o,storeImportPath:t.codegen.storeImportPath,userTypesFilename:t.codegen.userTypesFilename,codegenDirectory:t.codegen.outputDirectory,codegenIndexFilename:t.codegen.indexFilename,tables:a,v2:t}}export{l as a};
+//# sourceMappingURL=chunk-VK6EP5GU.js.map

package/dist/chunk-VK6EP5GU.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../ts/config/v2/compat.ts"],"sourcesContent":["import { conform } from \"@arktype/util\";\nimport { Schema, Store, Table } from \"./output\";\nimport { mapObject } from \"@latticexyz/common/utils\";\nimport { getKeySchema, getValueSchema } from \"@latticexyz/protocol-parser/internal\";\n\nexport type storeToV1<store> = store extends Store\n  ? {\n      namespace: store[\"namespace\"] extends \"\" ? \"\" : string;\n      enums: { [key in keyof store[\"enums\"]]: string[] };\n      userTypes: {\n        [key in keyof store[\"userTypes\"]]: {\n          internalType: store[\"userTypes\"][key][\"type\"];\n          filePath: string;\n        };\n      };\n      storeImportPath: store[\"codegen\"][\"storeImportPath\"];\n      userTypesFilename: store[\"codegen\"][\"userTypesFilename\"];\n      codegenDirectory: store[\"codegen\"][\"outputDirectory\"];\n      codegenIndexFilename: store[\"codegen\"][\"indexFilename\"];\n      tables: {\n        [key in keyof store[\"tables\"] as store[\"tables\"][key][\"name\"]]: tableToV1<store[\"tables\"][key]>;\n      };\n      v2: store;\n    }\n  : never;\n\ntype schemaToV1<schema extends Schema> = { [key in keyof schema]: schema[key][\"internalType\"] };\n\nexport type tableToV1<table extends Table> = {\n  directory: string;\n  dataStruct: table[\"codegen\"][\"dataStruct\"];\n  tableIdArgument: table[\"codegen\"][\"tableIdArgument\"];\n  storeArgument: table[\"codegen\"][\"storeArgument\"];\n  keySchema: schemaToV1<getKeySchema<table>>;\n  valueSchema: schemaToV1<getValueSchema<table>>;\n  offchainOnly: Table extends table ? boolean : table[\"type\"] extends \"table\" ? false : true;\n  name: table[\"name\"];\n};\n\nexport function storeToV1<store>(store: conform<store, Store>): storeToV1<store> {\n  const resolvedUserTypes = mapObject(store.userTypes, ({ type, filePath }) => ({\n    internalType: type,\n    filePath,\n  }));\n\n  const resolvedTables = Object.fromEntries(\n    Object.values(store.tables).map((table) => {\n      return [\n        table.name,\n        {\n          directory: table.codegen.outputDirectory,\n          dataStruct: table.codegen.dataStruct,\n          tableIdArgument: table.codegen.tableIdArgument,\n          storeArgument: table.codegen.storeArgument,\n          keySchema: mapObject(getKeySchema(table), (field) => field.internalType),\n          valueSchema: mapObject(getValueSchema(table), (field) => field.internalType),\n          offchainOnly: table.type === \"offchainTable\",\n          name: table.name,\n        },\n      ];\n    }),\n  );\n\n  return {\n    namespace: store.namespace,\n    enums: store.enums,\n    userTypes: resolvedUserTypes,\n    storeImportPath: store.codegen.storeImportPath,\n    userTypesFilename: store.codegen.userTypesFilename,\n    codegenDirectory: store.codegen.outputDirectory,\n    codegenIndexFilename: store.codegen.indexFilename,\n    tables: resolvedTables,\n    v2: store,\n  } as never;\n}\n"],"mappings":"AAEA,OAAS,aAAAA,MAAiB,2BAC1B,OAAS,gBAAAC,EAAc,kBAAAC,MAAsB,uCAoCtC,SAASC,EAAiBC,EAAgD,CAC/E,IAAMC,EAAoBL,EAAUI,EAAM,UAAW,CAAC,CAAE,KAAAE,EAAM,SAAAC,CAAS,KAAO,CAC5E,aAAcD,EACd,SAAAC,CACF,EAAE,EAEIC,EAAiB,OAAO,YAC5B,OAAO,OAAOJ,EAAM,MAAM,EAAE,IAAKK,GACxB,CACLA,EAAM,KACN,CACE,UAAWA,EAAM,QAAQ,gBACzB,WAAYA,EAAM,QAAQ,WAC1B,gBAAiBA,EAAM,QAAQ,gBAC/B,cAAeA,EAAM,QAAQ,cAC7B,UAAWT,EAAUC,EAAaQ,CAAK,EAAIC,GAAUA,EAAM,YAAY,EACvE,YAAaV,EAAUE,EAAeO,CAAK,EAAIC,GAAUA,EAAM,YAAY,EAC3E,aAAcD,EAAM,OAAS,gBAC7B,KAAMA,EAAM,IACd,CACF,CACD,CACH,EAEA,MAAO,CACL,UAAWL,EAAM,UACjB,MAAOA,EAAM,MACb,UAAWC,EACX,gBAAiBD,EAAM,QAAQ,gBAC/B,kBAAmBA,EAAM,QAAQ,kBACjC,iBAAkBA,EAAM,QAAQ,gBAChC,qBAAsBA,EAAM,QAAQ,cACpC,OAAQI,EACR,GAAIJ,CACN,CACF","names":["mapObject","getKeySchema","getValueSchema","storeToV1","store","resolvedUserTypes","type","filePath","resolvedTables","table","field"]}

package/dist/{chunk-5WZCFAPD.js → chunk-YMY764S5.js}

@@ -1,2 +1,2 @@
-import{G as h,H as S,I as y,a as s,c as r,d as n,l as a,q as p,s as l}from"./chunk-KY6TJF77.js";import{isFixedArrayAbiType as x,isStaticAbiType as T}from"@latticexyz/schema-type/internal";var F="Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.";function d(e){return typeof e=="string"||n(e)&&Object.values(e).every(t=>typeof t=="string")}function b(e,t=a){if(typeof e=="string"){if(x(e)||r(t.types,e))return;throw new Error(`Invalid ABI type. \`${e}\` not found in scope.`)}if(typeof e=="object"&&e!==null){if(p(e,t)){if(r(e,"id")&&T(t.types[e.id]))return;throw new Error("Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.")}throw new Error("Invalid schema. Are you using invalid types or missing types in your scope?")}throw new Error("Invalid table shorthand.")}function c(e,t=a){return p(e,t)?{schema:e,key:["id"]}:{schema:{id:"bytes32",value:e},key:["id"]}}function j(e,t=a){return b(e,t),c(e,t)}function u(e,t){if(n(e))for(let o of Object.keys(e))d(s(e,o))?b(s(e,o),t):l(s(e,o),t)}import{mapObject as f}from"@latticexyz/common/utils";function v(e){let t=h(e);r(e,"tables")&&n(e.tables)&&u(e.tables,t)}function m(e){let t=h(e),o={...e,tables:f(e.tables,i=>d(i)?c(i,t):i)};return S(o),y(o)}function q(e){return v(e),m(e)}export{F as a,d as b,b as c,c as d,j as e,u as f,v as g,m as h,q as i};
-//# sourceMappingURL=chunk-5WZCFAPD.js.map
+import{G as h,H as S,I as y,a as s,c as r,d as n,l as a,q as p,s as l}from"./chunk-7GE3KQCY.js";import{isFixedArrayAbiType as x,isStaticAbiType as T}from"@latticexyz/schema-type/internal";var F="Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.";function d(e){return typeof e=="string"||n(e)&&Object.values(e).every(t=>typeof t=="string")}function b(e,t=a){if(typeof e=="string"){if(x(e)||r(t.types,e))return;throw new Error(`Invalid ABI type. \`${e}\` not found in scope.`)}if(typeof e=="object"&&e!==null){if(p(e,t)){if(r(e,"id")&&T(t.types[e.id]))return;throw new Error("Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.")}throw new Error("Invalid schema. Are you using invalid types or missing types in your scope?")}throw new Error("Invalid table shorthand.")}function c(e,t=a){return p(e,t)?{schema:e,key:["id"]}:{schema:{id:"bytes32",value:e},key:["id"]}}function j(e,t=a){return b(e,t),c(e,t)}function u(e,t){if(n(e))for(let o of Object.keys(e))d(s(e,o))?b(s(e,o),t):l(s(e,o),t)}import{mapObject as f}from"@latticexyz/common/utils";function v(e){let t=h(e);r(e,"tables")&&n(e.tables)&&u(e.tables,t)}function m(e){let t=h(e),o={...e,tables:f(e.tables,i=>d(i)?c(i,t):i)};return S(o),y(o)}function q(e){return v(e),m(e)}export{F as a,d as b,b as c,c as d,j as e,u as f,v as g,m as h,q as i};
+//# sourceMappingURL=chunk-YMY764S5.js.map

package/dist/codegen.d.ts

@@ -1,6 +1,6 @@
 import { ImportDatum, StaticResourceData, RenderKeyTuple, RenderField, RenderStaticField, RenderDynamicField, RenderType, SolidityUserDefinedType } from '@latticexyz/common/codegen';
-import { S as StoreConfig } from './storeConfig-6d2b4bea.js';
-import { S as Store } from './output-a86744d2.js';
+import { S as StoreConfig } from './storeConfig-b753c8ed.js';
+import { S as Store } from './output-abc5735c.js';
 import { SchemaType } from '@latticexyz/schema-type/deprecated';
 import 'zod';
 import '@latticexyz/common/type-utils';
@@ -89,7 +89,12 @@ declare function renderTable(options: RenderTableOptions): string;
  */
 declare function renderTypesFromConfig(config: StoreConfig): string;
 
-declare function tablegen(configV2: Store, outputBaseDirectory: string, remappings: [string, string][]): Promise<void>;
+type TablegenOptions = {
+    configPath: string;
+    config: Store;
+    remappings: [string, string][];
+};
+declare function tablegen({ configPath, config, remappings }: TablegenOptions): Promise<void>;
 
 interface TableOptions {
     /** Path where the file is expected to be written (relative to project root) */
@@ -102,7 +107,7 @@ interface TableOptions {
 /**
  * Transforms store config and available solidity user types into useful options for `tablegen` and `renderTable`
  */
-declare function getTableOptions(config: StoreConfig, solidityUserTypes: Record<string, SolidityUserDefinedType>): TableOptions[];
+declare function getTableOptions(config: Store, solidityUserTypes: Record<string, SolidityUserDefinedType>): TableOptions[];
 
 /**
  * Renders `DecodeSlice` library with the necessary header and imports,
@@ -153,4 +158,4 @@ declare function getUserTypeInfo(userType: string, config: StoreConfig, solidity
     renderType: RenderType;
 };
 
-export { RenderTableOptions, TableOptions, getSchemaTypeInfo, getTableOptions, getUserTypeInfo, importForAbiOrUserType, renderDecodeSlice, renderDecodeValueType, renderDeleteRecordMethods, renderEncodeArray, renderEncodeFieldSingle, renderFieldMethods, renderRecordData, renderRecordMethods, renderTable, renderTightCoderAutoTest, renderTightCoderAutoTestFunction, renderTightCoderDecode, renderTightCoderEncode, renderTypesFromConfig, resolveAbiOrUserType, tablegen };
+export { RenderTableOptions, TableOptions, TablegenOptions, getSchemaTypeInfo, getTableOptions, getUserTypeInfo, importForAbiOrUserType, renderDecodeSlice, renderDecodeValueType, renderDeleteRecordMethods, renderEncodeArray, renderEncodeFieldSingle, renderFieldMethods, renderRecordData, renderRecordMethods, renderTable, renderTightCoderAutoTest, renderTightCoderAutoTestFunction, renderTightCoderDecode, renderTightCoderEncode, renderTypesFromConfig, resolveAbiOrUserType, tablegen };