@hankchen/canvas-editor 0.3.0 → 0.4.0

package/dist/index.js

@@ -501,6 +501,7 @@ function normalizeSchemaType(value) {
   const primary = value.find((entry) => entry !== "null" && entry !== "");
   return primary;
 }
+var FORMAT_ANNOTATIONS = /* @__PURE__ */ new Set(["date", "date-time"]);
 function annotationsOf(raw) {
   const node = {};
   const rawType = raw["type"];
@@ -515,6 +516,10 @@ function annotationsOf(raw) {
   if (typeof rawDescription === "string") node.description = rawDescription;
   const rawTitle = raw["title"];
   if (typeof rawTitle === "string") node.title = rawTitle;
+  const rawFormat = raw["format"];
+  if (node.type === "string" && typeof rawFormat === "string" && FORMAT_ANNOTATIONS.has(rawFormat)) {
+    node.format = rawFormat;
+  }
   return node;
 }
 function pointerEscape(key) {
@@ -692,15 +697,170 @@ function parseExpressionPath(expr) {
   return { ok: true, head: { kind: "bare", name: head }, rest };
 }
 
+// src/shared/expressionCall.ts
+var TRIM_CHARS = " 	\n\r\0\v";
+var WS_CHARS = " 	\n\r";
+var HEAD_STOP_CHARS = `()',.${TRIM_CHARS}`;
+function phpTrim(value) {
+  let start = 0;
+  let end = value.length;
+  while (start < end && TRIM_CHARS.includes(value[start])) start += 1;
+  while (end > start && TRIM_CHARS.includes(value[end - 1])) end -= 1;
+  return value.slice(start, end);
+}
+function skipWs(expr, pos) {
+  while (pos < expr.length && WS_CHARS.includes(expr[pos])) pos += 1;
+  return pos;
+}
+function isCallFragment(expr) {
+  let head = 0;
+  while (head < expr.length && !HEAD_STOP_CHARS.includes(expr[head])) head += 1;
+  if (head === 0) return false;
+  let pos = head;
+  while (pos < expr.length && TRIM_CHARS.includes(expr[pos])) pos += 1;
+  return expr[pos] === "(";
+}
+function parseExpressionCall(expr) {
+  let head = 0;
+  while (head < expr.length && !HEAD_STOP_CHARS.includes(expr[head])) head += 1;
+  if (head === 0) return { ok: false, error: "expression_syntax_error" };
+  const name = expr.slice(0, head);
+  let pos = skipWs(expr, head);
+  if (pos >= expr.length || expr[pos] !== "(") return { ok: false, error: "expression_syntax_error" };
+  pos = skipWs(expr, pos + 1);
+  const args = [];
+  if (pos < expr.length && expr[pos] === ")") {
+    pos += 1;
+  } else {
+    for (; ; ) {
+      if (pos >= expr.length) return { ok: false, error: "expression_syntax_error" };
+      const arg = parseCallArg(expr, pos);
+      if (!arg.ok) return arg;
+      args.push(arg.value);
+      pos = skipWs(expr, arg.end);
+      if (pos >= expr.length) return { ok: false, error: "expression_syntax_error" };
+      if (expr[pos] === ",") {
+        pos = skipWs(expr, pos + 1);
+        if (pos < expr.length && expr[pos] === ")") {
+          return { ok: false, error: "expression_syntax_error" };
+        }
+        continue;
+      }
+      if (expr[pos] === ")") {
+        pos += 1;
+        break;
+      }
+      return { ok: false, error: "expression_syntax_error" };
+    }
+  }
+  if (skipWs(expr, pos) !== expr.length) return { ok: false, error: "expression_syntax_error" };
+  if (args[0] !== void 0 && args[0].type !== "path") return { ok: false, error: "expression_syntax_error" };
+  for (const arg of args) {
+    if (arg.type === "path" && !parseExpressionPath(arg.value).ok) {
+      return { ok: false, error: "expression_syntax_error" };
+    }
+  }
+  return { ok: true, name, args };
+}
+function parseCallArg(expr, pos) {
+  const len = expr.length;
+  const ch = expr[pos];
+  if (ch === "'") {
+    let cursor = pos + 1;
+    let buf = "";
+    for (; ; ) {
+      if (cursor >= len) return { ok: false, error: "expression_syntax_error" };
+      if (expr[cursor] === "'") {
+        if (cursor + 1 < len && expr[cursor + 1] === "'") {
+          buf += "'";
+          cursor += 2;
+          continue;
+        }
+        cursor += 1;
+        break;
+      }
+      buf += expr[cursor];
+      cursor += 1;
+    }
+    return { ok: true, value: { type: "string", value: buf }, end: cursor };
+  }
+  if (ch >= "0" && ch <= "9") {
+    const start2 = pos;
+    const isDigitAt = (index) => {
+      const c = expr[index];
+      return c !== void 0 && c >= "0" && c <= "9";
+    };
+    while (isDigitAt(pos)) pos += 1;
+    if (pos < len && expr[pos] === "." && isDigitAt(pos + 1)) {
+      pos += 1;
+      while (isDigitAt(pos)) pos += 1;
+    }
+    return { ok: true, value: { type: "number", value: expr.slice(start2, pos) }, end: pos };
+  }
+  const start = pos;
+  while (pos < len && expr[pos] !== "," && expr[pos] !== ")") pos += 1;
+  const raw = phpTrim(expr.slice(start, pos));
+  if (raw === "") return { ok: false, error: "expression_syntax_error" };
+  return { ok: true, value: { type: "path", value: raw }, end: pos };
+}
+function expressionCallSlotAtEnd(expr) {
+  let head = 0;
+  while (head < expr.length && !HEAD_STOP_CHARS.includes(expr[head])) head += 1;
+  if (head === 0) return null;
+  let pos = skipWs(expr, head);
+  if (pos >= expr.length || expr[pos] !== "(") return null;
+  pos = skipWs(expr, pos + 1);
+  let index = 0;
+  for (; ; ) {
+    if (pos >= expr.length) return { name: expr.slice(0, head), index, text: "", stringSlot: false };
+    const ch = expr[pos];
+    if (ch === "'") {
+      let cursor = pos + 1;
+      for (; ; ) {
+        if (cursor >= expr.length) {
+          return { name: expr.slice(0, head), index, text: expr.slice(pos + 1), stringSlot: true };
+        }
+        if (expr[cursor] === "'") {
+          if (cursor + 1 < expr.length && expr[cursor + 1] === "'") {
+            cursor += 2;
+            continue;
+          }
+          cursor += 1;
+          break;
+        }
+        cursor += 1;
+      }
+      pos = cursor;
+    } else if (ch !== "," && ch !== ")") {
+      const argStart = pos;
+      while (pos < expr.length && expr[pos] !== "," && expr[pos] !== ")") pos += 1;
+      if (pos >= expr.length) {
+        return { name: expr.slice(0, head), index, text: phpTrim(expr.slice(argStart)), stringSlot: false };
+      }
+    }
+    if (pos >= expr.length) return { name: expr.slice(0, head), index: index + 1, text: "", stringSlot: false };
+    if (expr[pos] === ")") return null;
+    index += 1;
+    pos = skipWs(expr, pos + 1);
+  }
+}
+
 // src/shared/expressionScan.ts
 var PHP_TRIM_CHARS = " 	\n\r\0\v";
-function phpTrim(value) {
+function phpTrim2(value) {
   let start = 0;
   let end = value.length;
   while (start < end && PHP_TRIM_CHARS.includes(value[start])) start += 1;
   while (end > start && PHP_TRIM_CHARS.includes(value[end - 1])) end -= 1;
   return value.slice(start, end);
 }
+function fragmentSyntaxError(expr) {
+  if (expr === "") return "expression_syntax_error";
+  if (isCallFragment(expr)) {
+    return parseExpressionCall(expr).ok ? null : "expression_syntax_error";
+  }
+  return parseExpressionPath(expr).ok ? null : "expression_syntax_error";
+}
 function scanExpressionFragments(template) {
   const parts = [];
   let pos = 0;
@@ -712,15 +872,15 @@ function scanExpressionFragments(template) {
         parts.push({ kind: "literal", start: pos, end: open, text: template.slice(pos, open) });
       }
       const text = template.slice(open);
-      parts.push({ kind: "open", start: open, end: template.length, text, expr: phpTrim(text.slice(2)) });
+      parts.push({ kind: "open", start: open, end: template.length, text, expr: phpTrim2(text.slice(2)) });
       return { template, parts };
     }
     if (open > pos) {
       parts.push({ kind: "literal", start: pos, end: open, text: template.slice(pos, open) });
     }
     const raw = template.slice(open + 2, close);
-    const expr = phpTrim(raw);
-    const error = parseExpressionPath(expr).ok ? null : "expression_syntax_error";
+    const expr = phpTrim2(raw);
+    const error = fragmentSyntaxError(expr);
     parts.push({ kind: "fragment", start: open, end: close + 2, raw, expr, error });
     pos = close + 2;
     open = template.indexOf("{{", pos);
@@ -4081,6 +4241,22 @@ function classifyWheel(input) {
   return "pan";
 }
 
+// src/shared/expressionFunctions.ts
+var EXPRESSION_FUNCTIONS = [
+  { name: "date", signature: "date(path[, format])", summary: "\u65E5\u671F\u683C\u5F0F\u5316\uFF08moment \u98CE\u683C token\uFF0C\u9884\u8BBE date/datetime\uFF09" },
+  { name: "number", signature: "number(path[, n])", summary: "\u5343\u5206\u4F4D\u5206\u7EC4" },
+  { name: "fixed", signature: "fixed(path[, n])", summary: "\u5B9A\u70B9\u8865\u96F6\uFF08\u7F3A\u7701 2 \u4F4D\uFF09" },
+  { name: "percent", signature: "percent(path[, n])", summary: "\u767E\u5206\u6BD4\uFF08\u4E58 100\uFF09" }
+];
+var NUMBER_FUNCTION_SUGGESTIONS = EXPRESSION_FUNCTIONS.filter(
+  (fn) => fn.name !== "date"
+);
+var DATE_FORMAT_SUGGESTIONS = [
+  { segment: "date", description: "\u9884\u8BBE \u2192 YYYY-MM-DD" },
+  { segment: "datetime", description: "\u9884\u8BBE \u2192 YYYY-MM-DD HH:mm:ss" },
+  { segment: "YYYY\u5E74MM\u6708DD\u65E5", description: "\u4E2D\u6587\u6A21\u677F\uFF08\u5199\u5373\u6240\u5F97\uFF09" }
+];
+
 // src/shared/expressionCandidates.ts
 function headName(head) {
   if (head.kind === "row") return "row";
@@ -4098,9 +4274,57 @@ function childCandidate(entry, prefix) {
   const path = prefix === "" ? entry.key : `${prefix}.${entry.key}`;
   return { path, segment: entry.key, ...candidateMeta(entry.node) };
 }
-function headCandidates(schema, context, rowSchema) {
+function callCandidatesFor(entry, path, exprLen) {
+  const extras = [];
+  if (entry.node.format === "date" || entry.node.format === "date-time") {
+    extras.push({
+      path: `date(${path}, '')`,
+      segment: `date(${path}, '')`,
+      cursorBack: 2,
+      replaceLen: exprLen,
+      filterKey: entry.key,
+      description: "\u65E5\u671F\u683C\u5F0F\u5316",
+      type: "\u51FD\u6570"
+    });
+  } else if (entry.node.type === "number") {
+    for (const fn of NUMBER_FUNCTION_SUGGESTIONS) {
+      extras.push({
+        path: `${fn.name}(${path})`,
+        segment: `${fn.name}(${path})`,
+        replaceLen: exprLen,
+        filterKey: entry.key,
+        description: fn.summary,
+        type: "\u51FD\u6570"
+      });
+    }
+  }
+  return extras;
+}
+function childCandidates(entry, prefix, exprLen, withBuckets) {
+  const base = childCandidate(entry, prefix);
+  if (!withBuckets) return [base];
+  return [base, ...callCandidatesFor(entry, base.path, exprLen)];
+}
+function functionCandidates() {
+  return EXPRESSION_FUNCTIONS.map((fn) => ({
+    path: fn.signature,
+    segment: `${fn.name}()`,
+    cursorBack: 1,
+    description: fn.summary,
+    type: "\u51FD\u6570"
+  }));
+}
+function dateFormatCandidates() {
+  return DATE_FORMAT_SUGGESTIONS.map((suggestion) => ({
+    path: suggestion.segment,
+    segment: suggestion.segment,
+    description: suggestion.description,
+    type: "\u683C\u5F0F"
+  }));
+}
+function headCandidates(schema, context, rowSchema, exprLen, withBuckets) {
   const view = schemaChildEntries(schema);
-  const candidates = view.entries.map((entry) => childCandidate(entry, ""));
+  const candidates = view.entries.flatMap((entry) => childCandidates(entry, "", exprLen, withBuckets));
   candidates.push({ path: "$root", segment: "$root" });
   if (context === "row") {
     candidates.push(rowSchema ? { path: "row", segment: "row", ...candidateMeta(rowSchema) } : { path: "row", segment: "row" });
@@ -4108,15 +4332,35 @@ function headCandidates(schema, context, rowSchema) {
   }
   return view.open === true ? { candidates, open: true } : { candidates };
 }
-function enumerateExpressionCandidates(schema, query) {
+function callSlotResult(schema, query) {
+  const slot = expressionCallSlotAtEnd(query.expr);
+  if (slot === null) {
+    return { ok: true, prefix: "", partial: "", candidates: [] };
+  }
+  if (slot.stringSlot && slot.index >= 1 && slot.name === "date") {
+    return { ok: true, prefix: "", partial: slot.text, candidates: dateFormatCandidates() };
+  }
+  if (slot.index === 0 && !isCallFragment(slot.text)) {
+    const sub = enumeratePathCandidates(schema, query, slot.text, false);
+    if (!sub.ok) return { ok: true, prefix: "", partial: "", candidates: [] };
+    return sub;
+  }
+  return { ok: true, prefix: "", partial: "", candidates: [] };
+}
+function enumeratePathCandidates(schema, query, expr, allowCallSuggestions) {
   if (schema === null) {
     return { ok: true, prefix: "", partial: "", candidates: [] };
   }
-  const hadTrailingDot = query.expr.endsWith(".");
-  const stripped = hadTrailingDot ? query.expr.slice(0, -1) : query.expr;
+  const hadTrailingDot = expr.endsWith(".");
+  const stripped = hadTrailingDot ? expr.slice(0, -1) : expr;
   if (stripped === "") {
-    if (query.expr === "") {
-      return { ok: true, prefix: "", partial: "", ...headCandidates(schema, query.context, query.rowSchema) };
+    if (expr === "") {
+      return {
+        ok: true,
+        prefix: "",
+        partial: "",
+        ...headCandidates(schema, query.context, query.rowSchema, expr.length, false)
+      };
     }
     return { ok: false, reason: "expression_syntax_error" };
   }
@@ -4137,8 +4381,17 @@ function enumerateExpressionCandidates(schema, query) {
     prefixPath = [];
     partial = headName(head);
   }
+  const withBuckets = allowCallSuggestions && partial !== "";
   if (prefixPath.length === 0) {
-    return { ok: true, prefix: "", partial, ...headCandidates(schema, query.context, query.rowSchema) };
+    const view2 = headCandidates(schema, query.context, query.rowSchema, expr.length, withBuckets);
+    const fns = allowCallSuggestions && expr !== "" ? functionCandidates() : [];
+    return {
+      ok: true,
+      prefix: "",
+      partial,
+      candidates: [...view2.candidates, ...fns],
+      ...view2.open === true ? { open: true } : {}
+    };
   }
   let base;
   let segments;
@@ -4167,10 +4420,19 @@ function enumerateExpressionCandidates(schema, query) {
     ok: true,
     prefix,
     partial,
-    candidates: view.entries.map((entry) => childCandidate(entry, prefix)),
+    candidates: view.entries.flatMap((entry) => childCandidates(entry, prefix, expr.length, withBuckets)),
     ...view.open === true ? { open: true } : {}
   };
 }
+function enumerateExpressionCandidates(schema, query) {
+  if (schema === null) {
+    return { ok: true, prefix: "", partial: "", candidates: [] };
+  }
+  if (isCallFragment(query.expr)) {
+    return callSlotResult(schema, query);
+  }
+  return enumeratePathCandidates(schema, query, query.expr, true);
+}
 
 // src/shared/rowsPathCandidates.ts
 function isArrayNode(node) {
@@ -4320,15 +4582,18 @@ export {
   ANCHORS,
   ARM_CREATE_LAYER_TYPES,
   CREATE_DEAD_ZONE_SCREEN_PX,
+  DATE_FORMAT_SUGGESTIONS,
   DEFAULT_EDITOR_SHORTCUTS,
   DEFAULT_ZOOM_BOUNDS,
   EDITOR_STATE_SCHEMA_VERSION,
+  EXPRESSION_FUNCTIONS,
   EditorSession,
   EditorStore,
   FontCatalog,
   HORIZONTAL_ALIGNS,
   LAYER_TYPES,
   MAX_HISTORY_STEPS,
+  NUMBER_FUNCTION_SUGGESTIONS,
   PACKAGE_NAME,
   PAN_TO_BOX_MARGIN_PX,
   PASTE_OFFSET_PX,
@@ -4366,6 +4631,7 @@ export {
   deleteLayerInDraft,
   enumerateExpressionCandidates,
   enumerateRowsPathCandidates,
+  expressionCallSlotAtEnd,
   expressionFragmentAtCursor,
   fitRect,
   fitViewport,
@@ -4375,6 +4641,7 @@ export {
   hitTest,
   insertRootLayerAdjacentInDraft,
   insertRootLayerInDraft,
+  isCallFragment,
   isImageContentUndrawn,
   isLayerPath,
   isLockedPath,
@@ -4393,11 +4660,13 @@ export {
   normalizeExpressionSchemaSource,
   panBy,
   panToBox,
+  parseExpressionCall,
   parseExpressionPath,
   parseExpressionSchema,
   pastePosition,
   pathStartsWith,
   pathsEqual,
+  phpTrim2 as phpTrim,
   pickNextTextStylePatch,
   prepareRootPaste,
   readSpecField,