create-stacki 0.1.61 → 0.1.64

package/dist/cli.mjs

@@ -133,6 +133,12 @@ function toRecord(input) {
   }
   return input;
 }
+function toArray(input) {
+  if (!Array.isArray(input)) {
+    return void 0;
+  }
+  return input;
+}
 
 // studio/vendor/stacki/shared/core/boundary.ts
 var BOUNDARY_LIMITS = {
@@ -141,6 +147,36 @@ var BOUNDARY_LIMITS = {
   itemsMax: LIMITS.ipcItemsMax,
   depthMax: LIMITS.ipcDepthMax
 };
+function text(input) {
+  if (typeof input !== "string") {
+    throw new Error("Expected string");
+  }
+  if (input.length > BOUNDARY_LIMITS.textLengthMax) {
+    throw new Error("String exceeds limit");
+  }
+  return input;
+}
+function boolean(input) {
+  if (typeof input !== "boolean") {
+    throw new Error("Expected boolean");
+  }
+  return input;
+}
+function optional(parse) {
+  return (input) => input === void 0 ? void 0 : parse(input);
+}
+function list(parse) {
+  return (input) => {
+    const values = toArray(input);
+    if (!values) {
+      throw new Error("Expected array");
+    }
+    if (values.length > BOUNDARY_LIMITS.itemsMax) {
+      throw new Error("Array exceeds limit");
+    }
+    return values.map(parse);
+  };
+}
 function record(input) {
   const value = toRecord(input);
   if (!value) {
@@ -151,6 +187,19 @@ function record(input) {
   }
   return value;
 }
+function object(shape) {
+  return (input) => {
+    const source = record(input);
+    const result = {};
+    for (const [key, parse] of Object.entries(shape)) {
+      const value = parse(source[key]);
+      if (value !== void 0) {
+        result[key] = value;
+      }
+    }
+    return result;
+  };
+}
 
 // studio/vendor/stacki/shared/ipc/studioValidation.ts
 function string(value, maximum = 1e6) {
@@ -384,7 +433,7 @@ function requireSupportedNode(version) {
 import { lstat as lstat2, open as open2, realpath } from "node:fs/promises";
 import path2 from "node:path";
 
-// studio/src/shared/validation.ts
+// studio/src/shared/primitiveValidation.ts
 var MAX_SOURCE = 1e6;
 function record2(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -399,6 +448,206 @@ function string2(value, maximum = MAX_SOURCE) {
   return value;
 }
 
+// studio/vendor/stacki/shared/core/assert.ts
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(`Assertion failed: ${message}`);
+  }
+}
+
+// studio/vendor/stacki/shared/properties/componentDefaults.ts
+var DEFAULT_LIMITS = {
+  componentsMax: 512,
+  childrenMax: 32,
+  depthMax: 12,
+  nodesMax: 256,
+  propsMax: 64,
+  textCharsMax: 16384,
+  sourceCharsMax: 262144,
+  storedNodesMax: 4096
+};
+function componentFile(input) {
+  const value = text(input);
+  if (value.length > 500 || !/^src\/[\w./ -]+\.astro$/.test(value)) {
+    throw new Error("Component defaults: expected a project-relative .astro path under src/");
+  }
+  if (value.split("/").some((part) => part.startsWith(".") || part === "")) {
+    throw new Error("Component defaults: invalid path segment");
+  }
+  return value;
+}
+function parseComponentDefaults(input) {
+  const value = record(input);
+  if (value["version"] !== 1) {
+    throw new Error("Component defaults: unsupported version");
+  }
+  const entries = Object.entries(record(value["components"]));
+  if (entries.length > DEFAULT_LIMITS.componentsMax) {
+    throw new Error("Component defaults: too many components");
+  }
+  let nodes = 0;
+  const takeNode = () => {
+    nodes += 1;
+    if (nodes > DEFAULT_LIMITS.storedNodesMax) {
+      throw new Error("Component defaults exceed the stored node limit");
+    }
+  };
+  const components = Object.fromEntries(
+    entries.map(([file, recipe]) => [componentFile(file), parseRecipe(recipe, 0, takeNode)])
+  );
+  assert(Object.keys(components).length === entries.length, "Recipe parsing preserves every owner");
+  assert(nodes <= DEFAULT_LIMITS.storedNodesMax, "Parsed recipes fit the total node budget");
+  return { version: 1, components };
+}
+var parseDefaultComponent = object({
+  file: componentFile,
+  name: text,
+  props: list(text),
+  slots: list(text),
+  slotText: boolean
+});
+var parseDefaultsSnapshot = object({
+  source: optional(text),
+  config: parseComponentDefaults,
+  catalog: list(parseDefaultComponent)
+});
+var parseDefaultsSave = object({
+  source: optional(text),
+  config: parseComponentDefaults
+});
+function defaultValue(input) {
+  if (typeof input === "boolean") {
+    return input;
+  }
+  if (typeof input === "number") {
+    if (!Number.isFinite(input)) {
+      throw new Error("Default number must be finite");
+    }
+    return input;
+  }
+  const value = text(input);
+  if (value.length > DEFAULT_LIMITS.textCharsMax) {
+    throw new Error("Default text exceeds 16 KiB");
+  }
+  return value;
+}
+function parseRecipe(input, depth, takeNode) {
+  takeNode();
+  if (depth > DEFAULT_LIMITS.depthMax) {
+    throw new Error("Component defaults exceed the nesting limit");
+  }
+  const value = record(input);
+  const props = value["props"];
+  const content = value["text"];
+  const children = value["children"];
+  if (content !== void 0 && children !== void 0) {
+    throw new Error("Choose text or children for a recipe, not both");
+  }
+  return {
+    ...props === void 0 ? {} : { props: parseRecipeProps(props) },
+    ...content === void 0 ? {} : { text: parseRecipeText(content) },
+    ...children === void 0 ? {} : { children: parseRecipeChildren(children, depth, takeNode) }
+  };
+}
+function parseRecipeText(input) {
+  const value = defaultValue(input);
+  if (typeof value !== "string") {
+    throw new Error("Default text must be a string");
+  }
+  return value;
+}
+function parseRecipeProps(input) {
+  const entries = Object.entries(record(input));
+  if (entries.length > DEFAULT_LIMITS.propsMax) {
+    throw new Error("Too many default props");
+  }
+  return Object.fromEntries(
+    entries.map(([name, value]) => {
+      if (!/^[A-Za-z_][\w:-]{0,99}$/.test(name)) {
+        throw new Error("Invalid default prop name");
+      }
+      return [name, defaultValue(value)];
+    })
+  );
+}
+function parseRecipeChildren(input, depth, takeNode) {
+  const values = list(record)(input);
+  if (values.length > DEFAULT_LIMITS.childrenMax) {
+    throw new Error("Too many default children");
+  }
+  return values.map((value) => {
+    if (depth + 1 > DEFAULT_LIMITS.depthMax) {
+      throw new Error("Default children exceed the depth limit");
+    }
+    const kinds = ["literal", "element", "component"].filter((key) => value[key] !== void 0);
+    if (kinds.length !== 1) {
+      throw new Error("A default child must name exactly one component, element, or literal");
+    }
+    if (value["literal"] !== void 0) {
+      takeNode();
+      return { literal: parseRecipeText(value["literal"]) };
+    }
+    const recipe = parseRecipe(value, depth + 1, takeNode);
+    if (value["element"] !== void 0) {
+      const element = text(value["element"]);
+      if (!/^[a-z][a-z0-9-]{0,99}$/.test(element)) {
+        throw new Error("Invalid default HTML element");
+      }
+      return { element, ...recipe };
+    }
+    if (value["inherit"] !== void 0 && value["inherit"] !== false) {
+      throw new Error("Captured child defaults use inherit: false");
+    }
+    return {
+      component: componentFile(value["component"]),
+      ...recipe,
+      ...value["inherit"] === false ? { inherit: false } : {}
+    };
+  });
+}
+
+// studio/vendor/stacki/shared/properties/projectMetadata.ts
+function metadataKind(input) {
+  if (input === "components" || input === "guide" || input === "publish") {
+    return input;
+  }
+  throw new Error("Unknown project metadata file");
+}
+function metadataSource(input) {
+  const source = text(input);
+  if (source.length > DEFAULT_LIMITS.sourceCharsMax) {
+    throw new Error("Project metadata exceeds 256 KiB");
+  }
+  return source;
+}
+var parseMetadataFile = object({ source: optional(metadataSource) });
+var parseMetadataWrite = object({
+  kind: metadataKind,
+  source: metadataSource,
+  base: optional(metadataSource)
+});
+
+// studio/vendor/stacki/shared/properties/defaultsCanvas.ts
+function isDefaultsCanvas(file) {
+  return /^\.stacki\/canvas\/[a-f0-9-]{36}\.astro$/.test(file);
+}
+function defaultsCanvasFile(input) {
+  const file = text(input);
+  if (!isDefaultsCanvas(file)) {
+    throw new Error("Invalid component defaults canvas path");
+  }
+  return file;
+}
+function defaultsCanvasSource(input) {
+  const source = text(input);
+  if (source.length > DEFAULT_LIMITS.sourceCharsMax) {
+    throw new Error("Component defaults canvas exceeds 256 KiB");
+  }
+  return source;
+}
+var parseCanvasCreate = object({ file: defaultsCanvasFile, source: defaultsCanvasSource });
+var parseCanvasFile = object({ file: defaultsCanvasFile });
+
 // studio/scripts/createStacki/project.ts
 async function readJson(file, maximum) {
   const handle = await open2(file, "r");