@field/cascade 0.8.0 → 0.11.0

package/dist/cli/chunk-A4OAMOZH.js

@@ -0,0 +1,310 @@
+import {
+  isGeometrySerialized
+} from "./chunk-J7VK7MNF.js";
+import {
+  CORE_TYPES
+} from "./chunk-BIJO5OFS.js";
+
+// packages/contracts/src/validate.ts
+var IDENTIFIER = /^[A-Za-z][A-Za-z0-9_]*$/;
+var NAMESPACED = /^[a-z][a-z0-9-]*(?:\.[A-Za-z][A-Za-z0-9_]*)+$/;
+var RESERVED = /* @__PURE__ */ new Set(["__proto__", "prototype", "constructor"]);
+var CORE = new Set(CORE_TYPES);
+var CONTROLS = /* @__PURE__ */ new Set(["number", "slider", "range", "int", "boolean", "text", "textarea", "select", "vector", "matrix", "color", "image", "asset"]);
+var CAPABILITIES_BY_ENVIRONMENT = {
+  portable: ["assets", "media", "gpu"],
+  browser: ["assets", "media", "gpu"],
+  server: ["files", "assets", "media", "python", "shell", "gpu"]
+};
+var ALLOWED = CAPABILITIES_BY_ENVIRONMENT;
+var fields = (names) => new Set(names.split(" "));
+var TOP_FIELDS = fields(
+  "apiVersion runsOn container capabilities source label description icon inputs outputs props"
+);
+var DATA_FIELDS = fields(
+  "kind type default description variadic min max step accept control options schema fields"
+);
+var OUTPUT_FIELDS = fields("kind type description schema fields");
+var PROP_FIELDS = fields(
+  "type default label description min max step accept control options expression action"
+);
+function diagnostic(code, message, path) {
+  return { phase: "definition", code: `definition/${code}`, message, path };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validType(type) {
+  return typeof type === "string" && (CORE.has(type) || NAMESPACED.test(type));
+}
+function finiteJson(value) {
+  if (value === null || typeof value === "string" || typeof value === "boolean")
+    return true;
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value)) return value.every(finiteJson);
+  return isRecord(value) && Object.values(value).every(finiteJson);
+}
+function unknownFields(value, allowed, path) {
+  return Object.keys(value).filter((key) => !allowed.has(key)).map(
+    (key) => diagnostic(
+      "unknown-field",
+      `${path}.${key} is not allowed`,
+      `${path}.${key}`
+    )
+  );
+}
+function defaultMatches(type, value) {
+  if (!finiteJson(value)) return false;
+  if (type === "geometry") return isGeometrySerialized(value);
+  if (type === "float") return typeof value === "number";
+  if (type === "int") return typeof value === "number";
+  if (type === "bool") return typeof value === "boolean";
+  if (type === "string") return typeof value === "string";
+  const lengths = {
+    vec2: 2,
+    vec3: 3,
+    vec4: 4,
+    vec2i: 2,
+    vec3i: 3,
+    vec4i: 4,
+    mat2: 4,
+    mat3: 9,
+    mat4: 16,
+    color: 4
+  };
+  const length = lengths[type];
+  return length === void 0 || Array.isArray(value) && value.length === length && value.every(
+    (item) => type.endsWith("i") ? Number.isInteger(item) : typeof item === "number"
+  );
+}
+function validateNodeDefinition(value) {
+  if (!isRecord(value))
+    return [diagnostic("not-object", "Definition must be an object")];
+  const result = unknownFields(value, TOP_FIELDS, "definition");
+  const add = (code, message, path) => result.push(diagnostic(code, message, path));
+  const environment = value.runsOn;
+  if (value.apiVersion !== 1)
+    add("api-version", "apiVersion must be 1", "apiVersion");
+  if (!Object.prototype.hasOwnProperty.call(ALLOWED, String(environment)))
+    add("environment", "runsOn must be portable, browser, or server", "runsOn");
+  if (value.container !== void 0 && value.container !== "subnet" && value.container !== "feedback")
+    add("invalid-container", "container must be subnet or feedback", "container");
+  if (value.source !== void 0 && value.source !== "live")
+    add("invalid-source", 'source must be "live" when present', "source");
+  const allowed = ALLOWED[environment] ?? [];
+  if (value.capabilities !== void 0 && !Array.isArray(value.capabilities))
+    add(
+      "invalid-capabilities",
+      "capabilities must be an array",
+      "capabilities"
+    );
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, capability] of (Array.isArray(value.capabilities) ? value.capabilities : []).entries()) {
+    const path = `capabilities.${index}`;
+    if (!seen.has(capability) && !allowed.includes(capability))
+      add(
+        "capability-not-allowed",
+        `${String(capability)} is not available on ${String(environment)}`,
+        path
+      );
+    if (seen.has(capability))
+      add("duplicate-capability", `${String(capability)} is duplicated`, path);
+    seen.add(capability);
+  }
+  const inward = /* @__PURE__ */ new Map();
+  const outward = /* @__PURE__ */ new Map();
+  for (const section of ["inputs", "outputs", "props"]) {
+    const entries = value[section];
+    if (entries === void 0) continue;
+    if (!isRecord(entries)) {
+      add("invalid-section", `${section} must be an object`, section);
+      continue;
+    }
+    for (const [name, raw] of Object.entries(entries)) {
+      const path = `${section}.${name}`;
+      if (!IDENTIFIER.test(name))
+        add("invalid-name", `${name} is not a valid identifier`, path);
+      if (RESERVED.has(name)) add("reserved-name", `${name} is reserved`, path);
+      const names = section === "outputs" ? outward : inward;
+      const previous = names.get(name);
+      if (previous)
+        add(
+          "name-collision",
+          `${name} is declared in ${previous} and ${section}`,
+          path
+        );
+      else names.set(name, section);
+      if (!isRecord(raw)) {
+        add("invalid-entry", `${path} must be an object`, path);
+        continue;
+      }
+      const fields2 = section === "props" ? PROP_FIELDS : section === "outputs" ? OUTPUT_FIELDS : DATA_FIELDS;
+      if (section !== "props" && raw.kind !== "data" && raw.kind !== "trigger") {
+        add(
+          "invalid-kind",
+          `${path}.kind must be data or trigger`,
+          `${path}.kind`
+        );
+        result.push(...unknownFields(raw, fields2, path));
+        continue;
+      }
+      if (section !== "props" && raw.kind === "trigger") {
+        if (Object.keys(raw).some(
+          (key) => key !== "kind" && key !== "description"
+        ))
+          add(
+            "trigger-extra",
+            "Trigger ports allow only kind and description",
+            path
+          );
+        continue;
+      }
+      result.push(...unknownFields(raw, fields2, path));
+      if ("control" in raw && (typeof raw.control !== "string" || !CONTROLS.has(raw.control)))
+        add(
+          "invalid-control",
+          `${String(raw.control)} is not a Cascade control`,
+          `${path}.control`
+        );
+      if ("options" in raw && raw.control !== "select")
+        add(
+          "options-without-select",
+          "options require the select control",
+          `${path}.options`
+        );
+      if (Array.isArray(raw.options))
+        for (const [index, option] of raw.options.entries()) {
+          if (option === null || typeof option !== "object") continue;
+          const entry = option;
+          if (!("value" in entry))
+            add(
+              "invalid-option",
+              "a labelled option needs a value",
+              `${path}.options[${index}]`
+            );
+          if (typeof entry.label !== "string" || !entry.label)
+            add(
+              "invalid-option",
+              "a labelled option needs a non-empty label",
+              `${path}.options[${index}].label`
+            );
+          if ("disabled" in entry && typeof entry.disabled !== "boolean")
+            add(
+              "invalid-option",
+              "disabled must be a boolean",
+              `${path}.options[${index}].disabled`
+            );
+        }
+      const type = raw.type;
+      if (!validType(type)) {
+        add(
+          "invalid-type",
+          `${String(type)} is not a Cascade type`,
+          `${path}.type`
+        );
+        continue;
+      }
+      if (section !== "props") result.push(...bundleDiagnostics(raw, type, section, path));
+      if (type === "texture" && environment !== "browser")
+        add("texture-not-portable", "texture is browser-only", `${path}.type`);
+      if (type === "texture" && "default" in raw)
+        add(
+          "texture-default",
+          "texture cannot have a default",
+          `${path}.default`
+        );
+      if (section === "props" && !("default" in raw))
+        add("missing-default", "Props require defaults", `${path}.default`);
+      if ("default" in raw && !finiteJson(raw.default))
+        add(
+          "invalid-default",
+          "Default must be finite JSON",
+          `${path}.default`
+        );
+      else if ("default" in raw && !defaultMatches(type, raw.default))
+        add(
+          "default-type",
+          `Default does not match ${type}`,
+          `${path}.default`
+        );
+      if (type === "int" && "default" in raw && (!Number.isFinite(raw.default) || !Number.isInteger(raw.default)))
+        add(
+          "non-integer",
+          "Integer defaults must be finite integers",
+          `${path}.default`
+        );
+      if ("step" in raw && (typeof raw.step !== "number" || !Number.isFinite(raw.step) || raw.step <= 0))
+        add("invalid-step", "step must be greater than zero", `${path}.step`);
+      if (section === "props" && "expression" in raw && (typeof raw.expression !== "string" || raw.expression.length === 0))
+        add(
+          "invalid-expression",
+          "expression must be a non-empty string",
+          `${path}.expression`
+        );
+      for (const field of ["min", "max"]) {
+        if (field in raw && (typeof raw[field] !== "number" || !Number.isFinite(raw[field])))
+          add(
+            `invalid-${field}`,
+            `${field} must be a finite number`,
+            `${path}.${field}`
+          );
+      }
+      if (typeof raw.min === "number" && typeof raw.max === "number" && raw.min > raw.max)
+        add("invalid-range", "min must not exceed max", path);
+    }
+  }
+  return result;
+}
+function bundleDiagnostics(raw, type, section, path) {
+  const result = [];
+  const add = (code, message, at) => result.push(diagnostic(code, message, at));
+  for (const key of ["schema", "fields"])
+    if (key in raw && type !== "bundle")
+      add("bundle-metadata", `${key} is only valid on a bundle port`, `${path}.${key}`);
+  if (type !== "bundle") return result;
+  if ("schema" in raw && (typeof raw.schema !== "string" || !IDENTIFIER.test(raw.schema)))
+    add("invalid-schema", "schema must be an identifier", `${path}.schema`);
+  if (!("fields" in raw)) return result;
+  const declared = raw.fields;
+  if (section === "inputs") {
+    if (!Array.isArray(declared)) {
+      add("invalid-fields", "an input's fields list the field names it reads", `${path}.fields`);
+      return result;
+    }
+    const seen = /* @__PURE__ */ new Set();
+    for (const [index, field] of declared.entries()) {
+      if (typeof field !== "string" || !IDENTIFIER.test(field))
+        add("invalid-field", `${String(field)} is not a valid field name`, `${path}.fields[${index}]`);
+      else if (seen.has(field))
+        add("duplicate-field", `${field} is listed twice`, `${path}.fields[${index}]`);
+      else seen.add(field);
+    }
+    return result;
+  }
+  if (!isRecord(declared)) {
+    add("invalid-fields", "an output's fields map each field name to its type", `${path}.fields`);
+    return result;
+  }
+  for (const [field, definition] of Object.entries(declared)) {
+    const at = `${path}.fields.${field}`;
+    if (!IDENTIFIER.test(field) || RESERVED.has(field))
+      add("invalid-field", `${field} is not a valid field name`, at);
+    const fieldType = typeof definition === "string" ? definition : isRecord(definition) ? definition.type : void 0;
+    if (isRecord(definition)) {
+      for (const key of Object.keys(definition))
+        if (key !== "type" && key !== "description")
+          add("unknown-field", `${at}.${key} is not allowed`, `${at}.${key}`);
+    }
+    if (!validType(fieldType))
+      add("invalid-type", `${String(fieldType)} is not a Cascade type`, at);
+    else if (fieldType === "texture")
+      add("texture-not-portable", "a bundle field cannot hold a texture", at);
+  }
+  return result;
+}
+
+export {
+  CAPABILITIES_BY_ENVIRONMENT,
+  validateNodeDefinition
+};
+//# sourceMappingURL=chunk-A4OAMOZH.js.map

package/dist/cli/chunk-BIJO5OFS.js

@@ -0,0 +1,71 @@
+// packages/contracts/src/values.ts
+var CORE_TYPES = [
+  "float",
+  "int",
+  "bool",
+  "string",
+  "vec2",
+  "vec3",
+  "vec4",
+  "vec2i",
+  "vec3i",
+  "vec4i",
+  "mat2",
+  "mat3",
+  "mat4",
+  "image",
+  "texture",
+  "geometry",
+  "points",
+  "lines",
+  "polyline",
+  "mesh",
+  "rects",
+  "color",
+  "camera",
+  "scene",
+  "light",
+  "asset",
+  "array",
+  "object",
+  "bundle",
+  "any"
+];
+var TYPE_ALIASES = {
+  number: "float",
+  boolean: "bool",
+  curves: "polyline"
+};
+var IMPLICIT_TYPE_CONVERSIONS = {
+  int: ["float", "string"],
+  float: ["string"],
+  bool: ["int", "float", "string"],
+  vec2i: ["vec2"],
+  vec3i: ["vec3"],
+  vec4i: ["vec4"],
+  /**
+   * A geometry *is* a scene — one with the viewport's own camera and no lights.
+   * So the wire is legal and nothing is lost, which is the widening rule this
+   * table already follows. Every consumer of a `scene` input reads it through
+   * `asScene`, which performs the promotion; see `scene.ts`.
+   */
+  geometry: ["scene"],
+  vec4: ["color"],
+  color: ["vec4"]
+};
+function normalizeCascadeType(type) {
+  if (!type) return "any";
+  return TYPE_ALIASES[type] ?? type;
+}
+function canConnectTypes(source, target) {
+  const from = normalizeCascadeType(source);
+  const to = normalizeCascadeType(target);
+  return from === to || from === "any" || to === "any" || (IMPLICIT_TYPE_CONVERSIONS[from]?.includes(to) ?? false);
+}
+
+export {
+  CORE_TYPES,
+  normalizeCascadeType,
+  canConnectTypes
+};
+//# sourceMappingURL=chunk-BIJO5OFS.js.map