lineadraw 0.9.0 → 0.10.0

package/dist/sdk.js

@@ -17,7 +17,6 @@ import {
   EXTRACTED_EXTRAS,
   EXTRACTED_RANGES,
   FONTS,
-  HEX_COLOR,
   HatchPatternSchema,
   LineTypeSchema,
   MAX_HATCH_SEGMENTS,
@@ -28,6 +27,7 @@ import {
   TextStyleSchema,
   Vec2Schema,
   aciToHex,
+  acquireInputTable,
   add,
   angle,
   approximateTextMeasurer,
@@ -37,6 +37,7 @@ import {
   blockPivot,
   blockScriptId,
   bytesToDataUrl,
+  checkNamedInputs,
   cleanRichText,
   cleanText,
   closestPointOnSegment,
@@ -50,9 +51,10 @@ import {
   dimensionRawToLabels,
   dimensionRawToOffset,
   dist,
+  documentBlocks,
   documentObjectResolver,
   dot,
-  dryRunBlockInputs,
+  dryRunBlockPlacement,
   dryRunObjectResolver,
   effectiveTextFont,
   ellipseArcToBeziers,
@@ -73,14 +75,20 @@ import {
   hashAsset,
   hatchPatternKey,
   hexToRgb,
+  hostedClosure,
   imagePixelSize,
+  inputLabel,
+  inputPoints,
+  inputRefs,
   invalidateBlockCache,
+  isRequiredInput,
   len,
   lineSegments,
   lineTypeKey,
   lineWeightToMm,
   linearAxis,
   listBlockMeta,
+  mapInputValues,
   matApply,
   matIdentity,
   matMultiply,
@@ -92,7 +100,9 @@ import {
   norm,
   normAngle,
   normalizeSpans,
+  paramMismatch,
   parseFontFace,
+  parseInputTable,
   parseParamsExport,
   perp,
   realFace,
@@ -107,7 +117,9 @@ import {
   rotateObject,
   scale,
   scaleObjectUniform,
+  scanScriptId,
   scriptTranspilerReady,
+  selectionFits,
   signedArcSweep,
   sub,
   tableLayout,
@@ -121,8 +133,9 @@ import {
   textStyleFor,
   textWidth,
   translateObject,
-  valueParams
-} from "./chunk-BQCSFVAF.js";
+  valueParams,
+  withEmptyLists
+} from "./chunk-YYJAXJOY.js";
 import {
   embeddedPdfFonts
 } from "./chunk-L4FNH35X.js";
@@ -1682,10 +1695,8 @@ var buildEntry = (obj, ctx) => {
       };
     }
     case "block": {
-      const inputPoints = obj.inputs.filter(
-        (v) => typeof v !== "string"
-      );
-      const points = (inputPoints.length > 0 ? inputPoints : [blockPivot(obj)]).map((p) => ({ p, type: "endpoint" }));
+      const pts = inputPoints(obj.inputs);
+      const points = (pts.length > 0 ? pts : inputRefs(obj.inputs).length > 0 ? [] : [blockPivot(obj)]).map((p) => ({ p, type: "endpoint" }));
       const segments = [];
       const arcs = [];
       const ellipses = [];
@@ -4983,7 +4994,10 @@ var contentFromDocument = (doc, refId, bounds = emptyBounds()) => {
     (o) => o.type === "block" ? {
       ...o,
       id: prefix + o.id,
-      inputs: o.inputs.map((v) => typeof v === "string" ? prefix + v : v)
+      inputs: mapInputValues(
+        o.inputs,
+        (v) => typeof v === "string" ? prefix + v : v
+      )
     } : { ...o, id: prefix + o.id }
   );
   const byId = new Map(objects.map((o) => [o.id, o]));
@@ -5344,7 +5358,7 @@ var renderBlockThumbnailSvg = async (script, {
 } = {}) => {
   await ensureScriptTranspiler();
   const defId = getBlockMeta(script).id;
-  const inputs = await dryRunBlockInputs(script);
+  const { inputs, params } = await dryRunBlockPlacement(script);
   const defs = [script];
   const present = /* @__PURE__ */ new Set([defId]);
   for (const extra of definitions) {
@@ -5360,7 +5374,7 @@ var renderBlockThumbnailSvg = async (script, {
     definitionId: defId,
     rotation: 0,
     scale: 1,
-    params: {},
+    params,
     inputs
   };
   const env = {
@@ -5526,8 +5540,23 @@ var OptionalMetaSchema = z3.object({
   version: z3.string().optional(),
   authors: z3.array(z3.string()).optional(),
   tags: z3.array(z3.string()).optional(),
-  inputs: z3.array(z3.string().min(1)).optional()
+  requiresEditor: z3.boolean().optional()
 });
+var isInputTable = (inputs) => inputs !== void 0 && inputs.length > 0 && typeof inputs[0] !== "string";
+var parseCommandInputs = (raw, params) => {
+  if (raw === void 0) return void 0;
+  if (Array.isArray(raw) && raw.every((l) => typeof l === "string")) {
+    if (raw.some((l) => l === ""))
+      throw new Error("Invalid command metadata \u2014 inputs: empty label");
+    return raw;
+  }
+  const table = parseInputTable(raw, params);
+  if (table?.some((d) => d.type === "host"))
+    throw new Error(
+      "Invalid command metadata \u2014 inputs: `host` is a block input (a command has no frame to live in)"
+    );
+  return table;
+};
 var extractCommandMeta = (mod) => {
   if (typeof mod.id !== "string" || mod.id.trim() === "")
     throw new Error("Command script must export a non-empty string `id`");
@@ -5541,10 +5570,12 @@ var extractCommandMeta = (mod) => {
     );
   }
   const params = parseParamsExport(mod.params);
+  const inputs = parseCommandInputs(mod.inputs, params);
   return {
     id: mod.id,
     name: mod.name,
     ...parsed.data,
+    ...inputs ? { inputs } : {},
     ...params.length > 0 ? { params } : {}
   };
 };
@@ -5583,16 +5614,11 @@ var getCommandMetaResult = (script) => {
 };
 var listCommandMeta = (scripts) => scripts.map(getCommandMetaResult);
 var getCommandRun = (script) => compileCommand(script).run;
-var ID_EXPORT_RE = /export\s+const\s+id\s*=\s*["']([^"']+)["']/;
 var commandScriptId = (script) => {
   try {
     return compileCommand(script).meta.id;
   } catch {
-    const named = ID_EXPORT_RE.exec(script);
-    if (named) return named[1];
-    const call = script.search(/defineCommand\s*\(|export\s+default\s*\{/);
-    if (call === -1) return void 0;
-    return /\bid\s*:\s*["']([^"']+)["']/.exec(script.slice(call))?.[1];
+    return scanScriptId(script, /defineCommand\s*\(|export\s+default\s*\{/);
   }
 };
 var mergeCommandModules = (existing, incoming) => mergeScriptModules(existing, incoming, {
@@ -8171,7 +8197,9 @@ var invalidationIds = (op) => {
   switch (op.type) {
     case "add-objects":
     case "update-objects":
-      return op.objects.map((o) => o.id);
+      return op.objects.flatMap(
+        (o) => o.type === "block" ? [o.id, ...inputRefs(o.inputs)] : [o.id]
+      );
     case "remove-objects":
       return op.ids;
     case "set-current-layer":
@@ -9312,7 +9340,12 @@ var LocalDrawing = class {
   /** Delete objects by id (unknown ids are skipped); returns how many went. */
   remove(ids) {
     const entries = [];
-    for (const id of ids) {
+    const all = hostedClosure(
+      ids,
+      this.state.blockDefinitions,
+      documentBlocks(this.state)
+    );
+    for (const id of all) {
       try {
         entries.push({ space: this.findObject(id).space, item: id });
       } catch {
@@ -9614,7 +9647,7 @@ var LocalDrawing = class {
   }
   /** Export the document to a DXF string. */
   async toDxf() {
-    const { buildDxf } = await import("./exportDxf-T2RTSTH5.js");
+    const { buildDxf } = await import("./exportDxf-C4CLQCC3.js");
     return buildDxf(this.state, this.measurer).content;
   }
   /** Export the document to DWG bytes (the DXF content, wasm-transcoded).
@@ -9623,7 +9656,7 @@ var LocalDrawing = class {
    * exploded to plain geometry (DWG_DXF_OPTIONS — the transcoder's DWG
    * output for them is not accepted by AutoCAD). */
   async toDwg(opts) {
-    const { buildDxf, DWG_DXF_OPTIONS } = await import("./exportDxf-T2RTSTH5.js");
+    const { buildDxf, DWG_DXF_OPTIONS } = await import("./exportDxf-C4CLQCC3.js");
     const dxf = buildDxf(this.state, this.measurer, DWG_DXF_OPTIONS).content;
     return dxfToDwg(dxf, opts?.version ?? "AC1027");
   }
@@ -9642,46 +9675,6 @@ var makeContext = (opts, inputs, params) => {
     params
   };
 };
-var paramMismatch = (def, value) => {
-  switch (def.type) {
-    case "number":
-      if (typeof value !== "number" || !Number.isFinite(value))
-        return "expected a number";
-      if (def.integer && !Number.isInteger(value))
-        return "expected a whole number";
-      if (def.min !== void 0 && value < def.min)
-        return `below the minimum ${def.min}`;
-      if (def.max !== void 0 && value > def.max)
-        return `above the maximum ${def.max}`;
-      return null;
-    case "string":
-    case "textStyle":
-    case "dimStyle":
-    case "font":
-    case "lineType":
-    case "hatchPattern":
-      return typeof value === "string" ? null : "expected a string";
-    case "boolean":
-      return typeof value === "boolean" ? null : "expected true or false";
-    case "numberList": {
-      if (!Array.isArray(value) || !value.every((v) => typeof v === "number" && Number.isFinite(v)))
-        return "expected an array of numbers";
-      const low = value.find((v) => def.min !== void 0 && v < def.min);
-      if (low !== void 0) return `${low} is below the minimum ${def.min}`;
-      const high = value.find((v) => def.max !== void 0 && v > def.max);
-      if (high !== void 0) return `${high} is above the maximum ${def.max}`;
-      return null;
-    }
-    case "color":
-      return typeof value === "string" && HEX_COLOR.test(value) ? null : 'expected a "#rrggbb" color';
-    case "stringList":
-      return Array.isArray(value) && value.every((v) => typeof v === "string") ? null : "expected an array of strings";
-    case "enum":
-      return def.options.some((o) => o.value === value) ? null : `expected one of ${def.options.map((o) => JSON.stringify(o.value)).join(", ")}`;
-    default:
-      return "a label carries no value";
-  }
-};
 var resolveCommandParams = (meta, given = {}) => {
   const defs = valueParams(meta.params ?? []);
   const params = /* @__PURE__ */ Object.create(null);
@@ -9699,8 +9692,57 @@ var resolveCommandParams = (meta, given = {}) => {
   }
   return params;
 };
+var surfacePickers = (editor, document) => {
+  let selectionUsed = false;
+  const fromSelection = (def) => {
+    if (selectionUsed) return null;
+    const selected = editor.state().selectedIds.map((id) => document.getObject(id)).filter((o) => o !== void 0);
+    if (!selectionFits(def, selected)) return null;
+    selectionUsed = true;
+    return selected.map((o) => o.id);
+  };
+  return {
+    point: (def, ref) => editor.pickPoint({ label: inputLabel(def), referencePoint: ref }),
+    points: (def, ref) => editor.pickPoints({ ...def, referencePoint: ref }),
+    object: async (def) => fromSelection({ types: def.types, min: 1, max: 1 })?.[0] ?? editor.pickObject({ label: inputLabel(def), types: def.types }),
+    objects: async (def) => fromSelection(def) ?? editor.pickObjects(def)
+  };
+};
+var acquireNamedCommandInputs = async (meta, table, opts) => {
+  const { inputs, missing } = checkNamedInputs(
+    meta.name,
+    table,
+    opts.inputs,
+    (id) => opts.document.getObject(id)
+  );
+  if (!opts.editor) {
+    const required = missing.filter(isRequiredInput);
+    if (required.length > 0)
+      throw new Error(
+        `${meta.name} needs an editor for: ${required.map((d) => d.name).join(", ")} \u2014 supply inputs`
+      );
+    return withEmptyLists(table, inputs);
+  }
+  if (missing.length === 0) return inputs;
+  const picked = await acquireInputTable(
+    missing,
+    surfacePickers(opts.editor, opts.document)
+  );
+  const out = {};
+  for (const def of table) {
+    const v = inputs[def.name] ?? picked[def.name];
+    if (v !== void 0) out[def.name] = v;
+  }
+  return out;
+};
 var acquireCommandInputs = async (meta, opts) => {
+  if (isInputTable(meta.inputs))
+    return acquireNamedCommandInputs(meta, meta.inputs, opts);
   const labels = meta.inputs ?? [];
+  if (opts.inputs !== void 0 && !Array.isArray(opts.inputs))
+    throw new Error(
+      `${meta.name}: inputs are positional (${labels.join(", ") || "none declared"}) \u2014 pass an array`
+    );
   const given = (opts.inputs ?? []).map((p, i) => {
     try {
       return Vec2Schema.parse(p);
@@ -9732,11 +9774,29 @@ var runCommandModule = async (source, opts) => {
   const result = getCommandMetaResult(source);
   if (!result.ok) throw new Error(`Command failed to compile: ${result.error}`);
   const run = getCommandRun(source);
+  if (result.meta.requiresEditor && !opts.editor)
+    throw new Error(
+      `${result.meta.name} needs the editor (it asks during the run) \u2014 run it from Linea`
+    );
   const params = resolveCommandParams(result.meta, opts.params);
   const inputs = await acquireCommandInputs(result.meta, opts);
-  return opts.document.transaction(
-    () => run(makeContext(opts, inputs, params)),
-    result.meta.name
+  try {
+    return await opts.document.transaction(
+      () => run(makeContext(opts, inputs, params)),
+      result.meta.name
+    );
+  } catch (e) {
+    throw opts.editor ? e : namedEditorError(result.meta.name, e);
+  }
+};
+var namedEditorError = (name, e) => {
+  const m = e instanceof TypeError ? /reading '(pickPoint|pickPoints|pickObject|pickObjects|prompt|ask|toast|state|setSelection|setActiveSpace|zoom|listCommands|runCommand)'/.exec(
+    e.message
+  ) : null;
+  if (!m) return e;
+  return new Error(
+    `${name} used editor.${m[1]} but runs without an editor here \u2014 check \`editor\` before using it, or declare \`requiresEditor: true\``,
+    { cause: e }
   );
 };
 var runDocumentCommand = async (id, opts) => {
@@ -9982,7 +10042,8 @@ var Drawing = class extends LocalDrawing {
   }
   // --- scripts ---------------------------------------------------------------
   /** Run a command module source (`defineCommand`) against this drawing as
-   * ONE undo step, headlessly: declared `inputs` must be supplied; declared
+   * ONE undo step, headlessly: declared `inputs` must be supplied (points
+   * in label order, or a record by name for an inputs table); declared
    * `params` take their defaults unless given by name (unknown names and
    * wrong types throw). Resolves with the script's return value. */
   runScript(source, inputs, params) {