@latticexyz/store 2.2.18-ebe1aea8d4afb690ce1c7c2bcb42dc0f1faf6e77 → 2.2.18

package/dist/chunk-FULF4J63.js

@@ -0,0 +1,460 @@
+// ts/config/v2/generics.ts
+function get(input, key) {
+  return typeof input === "object" && input != null && hasOwnKey(input, key) ? input[key] : void 0;
+}
+function getPath(input, path) {
+  return path.length ? getPath(get(input, path[0]), path.slice(1)) : input;
+}
+function hasOwnKey(object, key) {
+  return typeof object === "object" && object !== null && object.hasOwnProperty(key);
+}
+function isObject(input) {
+  return input != null && typeof input === "object";
+}
+function mergeIfUndefined(base, defaults) {
+  const keys = [.../* @__PURE__ */ new Set([...Object.keys(base), ...Object.keys(defaults)])];
+  return Object.fromEntries(
+    keys.map((key) => [
+      key,
+      typeof base[key] === "undefined" ? defaults[key] : base[key]
+    ])
+  );
+}
+
+// ts/config/v2/defaults.ts
+var CODEGEN_DEFAULTS = {
+  storeImportPath: "@latticexyz/store/src",
+  userTypesFilename: "common.sol",
+  outputDirectory: "codegen",
+  indexFilename: "index.sol"
+};
+var TABLE_CODEGEN_DEFAULTS = {
+  outputDirectory: "tables",
+  tableIdArgument: false,
+  storeArgument: false
+};
+var TABLE_DEPLOY_DEFAULTS = {
+  disabled: false
+};
+var TABLE_DEFAULTS = {
+  namespaceLabel: "",
+  type: "table"
+};
+var CONFIG_DEFAULTS = {
+  sourceDirectory: "src",
+  namespace: ""
+};
+
+// ts/config/v2/scope.ts
+import { schemaAbiTypes } from "@latticexyz/schema-type/internal";
+var Scope = { types: {} };
+var AbiTypeScope = {
+  types: Object.fromEntries(schemaAbiTypes.map((abiType) => [abiType, abiType]))
+};
+function extendScope(scope, additionalTypes) {
+  return {
+    types: {
+      ...scope.types,
+      ...additionalTypes
+    }
+  };
+}
+
+// ts/config/v2/schema.ts
+import { fixedArrayToArray, isFixedArrayAbiType } from "@latticexyz/schema-type/internal";
+function validateSchema(schema, scope = AbiTypeScope) {
+  if (!isObject(schema)) {
+    throw new Error(`Expected schema, received ${JSON.stringify(schema)}`);
+  }
+  for (const internalType of Object.values(schema)) {
+    if (isFixedArrayAbiType(internalType)) continue;
+    if (hasOwnKey(scope.types, internalType)) continue;
+    throw new Error(`"${String(internalType)}" is not a valid type in this scope.`);
+  }
+}
+function resolveSchema(schema, scope = AbiTypeScope) {
+  return Object.fromEntries(
+    Object.entries(schema).map(([key, internalType]) => [
+      key,
+      {
+        type: isFixedArrayAbiType(internalType) ? fixedArrayToArray(internalType) : scope.types[internalType],
+        internalType
+      }
+    ])
+  );
+}
+function defineSchema(schema, scope = AbiTypeScope) {
+  validateSchema(schema, scope);
+  return resolveSchema(schema, scope);
+}
+function isSchemaInput(input, scope = AbiTypeScope) {
+  return typeof input === "object" && input != null && Object.values(input).every((fieldType) => isFixedArrayAbiType(fieldType) || hasOwnKey(scope.types, fieldType));
+}
+
+// ts/config/v2/table.ts
+import { isStaticAbiType } from "@latticexyz/schema-type/internal";
+import { resourceToHex } from "@latticexyz/common";
+function getValidKeys(schema, scope = AbiTypeScope) {
+  return Object.entries(schema).filter(([, internalType]) => hasOwnKey(scope.types, internalType) && isStaticAbiType(scope.types[internalType])).map(([key]) => key);
+}
+function isValidPrimaryKey(key, schema, scope = AbiTypeScope) {
+  return Array.isArray(key) && key.every(
+    (key2) => hasOwnKey(schema, key2) && hasOwnKey(scope.types, schema[key2]) && isStaticAbiType(scope.types[schema[key2]])
+  );
+}
+function validateTable(input, scope = AbiTypeScope, options = { inStoreContext: false }) {
+  if (typeof input !== "object" || input == null) {
+    throw new Error(`Expected full table config, got \`${JSON.stringify(input)}\``);
+  }
+  if (!hasOwnKey(input, "schema")) {
+    throw new Error("Missing schema input");
+  }
+  validateSchema(input.schema, scope);
+  if (!hasOwnKey(input, "key") || !isValidPrimaryKey(input["key"], input["schema"], scope)) {
+    throw new Error(
+      `Invalid key. Expected \`(${getValidKeys(input["schema"], scope).map((item) => `"${String(item)}"`).join(" | ")})[]\`, received \`${hasOwnKey(input, "key") && Array.isArray(input.key) ? `[${input.key.map((item) => `"${item}"`).join(", ")}]` : String(get(input, "key"))}\``
+    );
+  }
+  if (hasOwnKey(input, "namespace") && typeof input.namespace === "string" && input.namespace.length > 14) {
+    throw new Error(`Table \`namespace\` must fit into a \`bytes14\`, but "${input.namespace}" is too long.`);
+  }
+  if (hasOwnKey(input, "namespaceLabel") && typeof input.namespaceLabel === "string" && (!hasOwnKey(input, "namespace") || typeof input.namespace !== "string") && input.namespaceLabel.length > 14) {
+    throw new Error(
+      `Table \`namespace\` defaults to \`namespaceLabel\`, but must fit into a \`bytes14\` and "${input.namespaceLabel}" is too long. Provide explicit \`namespace\` override.`
+    );
+  }
+  if (hasOwnKey(input, "name") && typeof input.name === "string" && input.name.length > 16) {
+    throw new Error(`Table \`name\` must fit into a \`bytes16\`, but "${input.name}" is too long.`);
+  }
+  if (options.inStoreContext && (hasOwnKey(input, "label") || hasOwnKey(input, "namespaceLabel") || hasOwnKey(input, "namespace"))) {
+    throw new Error(
+      "Overrides of `label`, `namespaceLabel`, and `namespace` are not allowed for tables in this context."
+    );
+  }
+}
+function resolveTableCodegen(input) {
+  const options = input.codegen;
+  return {
+    outputDirectory: get(options, "outputDirectory") ?? TABLE_CODEGEN_DEFAULTS.outputDirectory,
+    tableIdArgument: get(options, "tableIdArgument") ?? TABLE_CODEGEN_DEFAULTS.tableIdArgument,
+    storeArgument: get(options, "storeArgument") ?? TABLE_CODEGEN_DEFAULTS.storeArgument,
+    // dataStruct is true if there are at least 2 value fields
+    dataStruct: get(options, "dataStruct") ?? Object.keys(input.schema).length - input.key.length > 1
+  };
+}
+function resolveTable(input, scope = AbiTypeScope) {
+  const namespaceLabel = input.namespaceLabel ?? TABLE_DEFAULTS.namespaceLabel;
+  const namespace = input.namespace ?? namespaceLabel;
+  const label = input.label;
+  const name = input.name ?? label.slice(0, 16);
+  const type = input.type ?? TABLE_DEFAULTS.type;
+  const tableId = resourceToHex({ type, namespace, name });
+  return {
+    label,
+    type,
+    namespace,
+    namespaceLabel,
+    name,
+    tableId,
+    schema: resolveSchema(input.schema, scope),
+    key: input.key,
+    codegen: resolveTableCodegen(input),
+    deploy: mergeIfUndefined(input.deploy ?? {}, TABLE_DEPLOY_DEFAULTS)
+  };
+}
+function defineTable(input, scope = AbiTypeScope) {
+  validateTable(input, scope);
+  return resolveTable(input, scope);
+}
+
+// ts/config/v2/tableShorthand.ts
+import { isFixedArrayAbiType as isFixedArrayAbiType2, isStaticAbiType as isStaticAbiType2 } from "@latticexyz/schema-type/internal";
+var NoStaticKeyFieldError = "Invalid schema. Expected an `id` field with a static ABI type or an explicit `key` option.";
+function isTableShorthandInput(shorthand) {
+  return typeof shorthand === "string" || isObject(shorthand) && Object.values(shorthand).every((value) => typeof value === "string");
+}
+function validateTableShorthand(shorthand, scope = AbiTypeScope) {
+  if (typeof shorthand === "string") {
+    if (isFixedArrayAbiType2(shorthand) || hasOwnKey(scope.types, shorthand)) {
+      return;
+    }
+    throw new Error(`Invalid ABI type. \`${shorthand}\` not found in scope.`);
+  }
+  if (typeof shorthand === "object" && shorthand !== null) {
+    if (isSchemaInput(shorthand, scope)) {
+      if (hasOwnKey(shorthand, "id") && isStaticAbiType2(scope.types[shorthand.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 expandTableShorthand(shorthand, scope) {
+  if (typeof shorthand === "string") {
+    return {
+      schema: {
+        id: "bytes32",
+        value: shorthand
+      },
+      key: ["id"]
+    };
+  }
+  if (isSchemaInput(shorthand, scope)) {
+    return {
+      schema: shorthand,
+      key: ["id"]
+    };
+  }
+  return shorthand;
+}
+function defineTableShorthand(input, scope = AbiTypeScope) {
+  validateTableShorthand(input, scope);
+  return expandTableShorthand(input, scope);
+}
+
+// ts/config/v2/tables.ts
+function validateTables(input, scope) {
+  if (isObject(input)) {
+    for (const table of Object.values(input)) {
+      if (isTableShorthandInput(table)) {
+        validateTableShorthand(table, scope);
+      } else {
+        validateTable(table, scope, { inStoreContext: true });
+      }
+    }
+    return;
+  }
+  throw new Error(`Expected tables config, received ${JSON.stringify(input)}`);
+}
+function resolveTables(tables, scope) {
+  return Object.fromEntries(
+    Object.entries(tables).map(([label, table]) => {
+      return [label, resolveTable(mergeIfUndefined(expandTableShorthand(table, scope), { label }), scope)];
+    })
+  );
+}
+function defineTables(input, scope = AbiTypeScope) {
+  validateTables(input, scope);
+  return resolveTables(input, scope);
+}
+
+// ts/config/v2/userTypes.ts
+import { mapObject } from "@latticexyz/common/utils";
+import { isSchemaAbiType } from "@latticexyz/schema-type/internal";
+function extractInternalType(userTypes) {
+  return mapObject(userTypes, (userType) => userType.type);
+}
+function isUserTypes(userTypes) {
+  return isObject(userTypes) && Object.values(userTypes).every((userType) => isSchemaAbiType(userType.type));
+}
+function scopeWithUserTypes(userTypes, scope = AbiTypeScope) {
+  return isUserTypes(userTypes) ? extendScope(scope, extractInternalType(userTypes)) : scope;
+}
+function validateUserTypes(userTypes) {
+  if (!isObject(userTypes)) {
+    throw new Error(`Expected userTypes, received ${JSON.stringify(userTypes)}`);
+  }
+  for (const { type } of Object.values(userTypes)) {
+    if (!hasOwnKey(AbiTypeScope.types, type)) {
+      throw new Error(`"${String(type)}" is not a valid ABI type.`);
+    }
+  }
+}
+
+// ts/config/v2/enums.ts
+import { flatMorph } from "@ark/util";
+function isEnums(enums) {
+  return typeof enums === "object" && enums != null && Object.values(enums).every((item) => Array.isArray(item) && item.every((element) => typeof element === "string"));
+}
+function scopeWithEnums(enums, scope = AbiTypeScope) {
+  if (isEnums(enums)) {
+    const enumScope = Object.fromEntries(Object.keys(enums).map((key) => [key, "uint8"]));
+    return extendScope(scope, enumScope);
+  }
+  return scope;
+}
+function resolveEnums(enums) {
+  return enums;
+}
+function mapEnums(enums) {
+  return flatMorph(enums, (enumName, enumElements) => [
+    enumName,
+    flatMorph(enumElements, (enumIndex, enumElement) => [enumElement, enumIndex])
+  ]);
+}
+
+// ts/config/v2/codegen.ts
+function resolveCodegen(codegen) {
+  return isObject(codegen) ? mergeIfUndefined(codegen, CODEGEN_DEFAULTS) : CODEGEN_DEFAULTS;
+}
+
+// ts/config/v2/namespace.ts
+import { flatMorph as flatMorph2 } from "@ark/util";
+function validateNamespace(input, scope) {
+  if (hasOwnKey(input, "namespace") && typeof input.namespace === "string" && input.namespace.length > 14) {
+    throw new Error(`\`namespace\` must fit into a \`bytes14\`, but "${input.namespace}" is too long.`);
+  }
+  if (hasOwnKey(input, "tables")) {
+    validateTables(input.tables, scope);
+  }
+}
+function resolveNamespace(input, scope = AbiTypeScope) {
+  const namespaceLabel = input.label;
+  const namespace = input.namespace ?? namespaceLabel.slice(0, 14);
+  return {
+    label: namespaceLabel,
+    namespace,
+    tables: resolveTables(
+      flatMorph2(input.tables ?? {}, (label, table) => {
+        return [label, mergeIfUndefined(expandTableShorthand(table, scope), { namespace, namespaceLabel })];
+      }),
+      scope
+    )
+  };
+}
+
+// ts/config/v2/namespaces.ts
+import { flatMorph as flatMorph3 } from "@ark/util";
+import { groupBy } from "@latticexyz/common/utils";
+function validateNamespaces(namespaces, scope) {
+  if (!isObject(namespaces)) {
+    throw new Error(`Expected namespaces, received ${JSON.stringify(namespaces)}`);
+  }
+  for (const namespace of Object.values(namespaces)) {
+    validateNamespace(namespace, scope);
+  }
+}
+function resolveNamespaces(input, scope) {
+  if (!isObject(input)) {
+    throw new Error(`Expected namespaces config, received ${JSON.stringify(input)}`);
+  }
+  const namespaces = flatMorph3(input, (label, namespace) => [
+    label,
+    resolveNamespace(mergeIfUndefined(namespace, { label }), scope)
+  ]);
+  const duplicates = Array.from(groupBy(Object.values(namespaces), (namespace) => namespace.namespace).entries()).filter(([, entries]) => entries.length > 1).map(([namespace]) => namespace);
+  if (duplicates.length > 0) {
+    throw new Error(`Found namespaces defined more than once in config: ${duplicates.join(", ")}`);
+  }
+  return namespaces;
+}
+function defineNamespaces(input, scope = AbiTypeScope) {
+  validateNamespaces(input, scope);
+  return resolveNamespaces(input, scope);
+}
+
+// ts/config/v2/flattenNamespacedTables.ts
+function flattenNamespacedTables(config) {
+  return Object.fromEntries(
+    Object.entries(config.namespaces).flatMap(
+      ([namespaceLabel, namespace]) => Object.entries(namespace.tables).map(([tableLabel, table]) => [
+        namespaceLabel === "" ? tableLabel : `${namespaceLabel}__${tableLabel}`,
+        table
+      ])
+    )
+  );
+}
+
+// ts/config/v2/store.ts
+function extendedScope(input) {
+  return scopeWithEnums(get(input, "enums"), scopeWithUserTypes(get(input, "userTypes")));
+}
+function validateStore(input) {
+  const scope = extendedScope(input);
+  if (hasOwnKey(input, "namespaces")) {
+    if (hasOwnKey(input, "namespace") || hasOwnKey(input, "tables")) {
+      throw new Error("Cannot use `namespaces` with `namespace` or `tables` keys.");
+    }
+    validateNamespaces(input.namespaces, scope);
+  }
+  if (hasOwnKey(input, "namespace") && typeof input.namespace === "string" && input.namespace.length > 14) {
+    throw new Error(`\`namespace\` must fit into a \`bytes14\`, but "${input.namespace}" is too long.`);
+  }
+  if (hasOwnKey(input, "tables")) {
+    validateTables(input.tables, scope);
+  }
+  if (hasOwnKey(input, "userTypes")) {
+    validateUserTypes(input.userTypes);
+  }
+}
+function resolveStore(input) {
+  const scope = extendedScope(input);
+  const baseNamespace = input.namespace ?? CONFIG_DEFAULTS["namespace"];
+  const namespaces = input.namespaces ? {
+    multipleNamespaces: true,
+    namespace: null,
+    namespaces: resolveNamespaces(input.namespaces, scope)
+  } : {
+    multipleNamespaces: false,
+    namespace: baseNamespace,
+    namespaces: resolveNamespaces({ [baseNamespace]: input }, scope)
+  };
+  const tables = flattenNamespacedTables(namespaces);
+  return {
+    ...namespaces,
+    tables,
+    sourceDirectory: input.sourceDirectory ?? CONFIG_DEFAULTS["sourceDirectory"],
+    userTypes: input.userTypes ?? {},
+    enums: resolveEnums(input.enums ?? {}),
+    enumValues: mapEnums(input.enums ?? {}),
+    codegen: resolveCodegen(input.codegen)
+  };
+}
+function defineStore(input) {
+  validateStore(input);
+  return resolveStore(input);
+}
+
+export {
+  get,
+  getPath,
+  hasOwnKey,
+  isObject,
+  mergeIfUndefined,
+  CODEGEN_DEFAULTS,
+  TABLE_CODEGEN_DEFAULTS,
+  TABLE_DEPLOY_DEFAULTS,
+  TABLE_DEFAULTS,
+  CONFIG_DEFAULTS,
+  Scope,
+  AbiTypeScope,
+  extendScope,
+  validateSchema,
+  resolveSchema,
+  defineSchema,
+  isSchemaInput,
+  isValidPrimaryKey,
+  validateTable,
+  resolveTableCodegen,
+  resolveTable,
+  defineTable,
+  NoStaticKeyFieldError,
+  isTableShorthandInput,
+  validateTableShorthand,
+  expandTableShorthand,
+  defineTableShorthand,
+  validateTables,
+  resolveTables,
+  defineTables,
+  extractInternalType,
+  isUserTypes,
+  scopeWithUserTypes,
+  validateUserTypes,
+  scopeWithEnums,
+  resolveEnums,
+  mapEnums,
+  resolveCodegen,
+  validateNamespace,
+  resolveNamespace,
+  validateNamespaces,
+  resolveNamespaces,
+  defineNamespaces,
+  flattenNamespacedTables,
+  extendedScope,
+  validateStore,
+  resolveStore,
+  defineStore
+};
+//# sourceMappingURL=chunk-FULF4J63.js.map