@yaoxiu/marketing-dsl 1.2.0 → 1.4.0

package/dist/chunk-FKZKLCVV.js

@@ -0,0 +1,968 @@
+// src/expression.ts
+var KEYWORD_LITERALS = {
+  true: true,
+  false: false,
+  null: null,
+  undefined: void 0
+};
+var PUNCTUATORS = [
+  "===",
+  "!==",
+  "<=",
+  ">=",
+  "==",
+  "!=",
+  "&&",
+  "||",
+  "(",
+  ")",
+  "[",
+  "]",
+  ".",
+  "?",
+  ":",
+  "<",
+  ">",
+  "!",
+  "+",
+  "-",
+  "*",
+  "/",
+  "%"
+];
+function tokenize(input) {
+  const tokens = [];
+  let i = 0;
+  while (i < input.length) {
+    const ch = input[i];
+    if (/\s/.test(ch)) {
+      i++;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      const quote = ch;
+      let value = "";
+      i++;
+      while (i < input.length && input[i] !== quote) {
+        if (input[i] === "\\") {
+          value += input[i + 1] || "";
+          i += 2;
+        } else {
+          value += input[i];
+          i++;
+        }
+      }
+      if (i >= input.length) throw new Error("\u5B57\u7B26\u4E32\u6CA1\u6709\u95ED\u5408");
+      i++;
+      tokens.push({ type: "string", value });
+      continue;
+    }
+    if (/[0-9]/.test(ch) || ch === "." && /[0-9]/.test(input[i + 1] || "")) {
+      let raw = "";
+      while (i < input.length && /[0-9.]/.test(input[i])) {
+        raw += input[i];
+        i++;
+      }
+      tokens.push({ type: "number", value: Number(raw) });
+      continue;
+    }
+    if (/[A-Za-z_$]/.test(ch)) {
+      let name = "";
+      while (i < input.length && /[A-Za-z0-9_$]/.test(input[i])) {
+        name += input[i];
+        i++;
+      }
+      tokens.push({ type: "ident", value: name });
+      continue;
+    }
+    const punctuator = PUNCTUATORS.find((p) => input.startsWith(p, i));
+    if (!punctuator) throw new Error(`\u65E0\u6CD5\u8BC6\u522B\u7684\u5B57\u7B26 "${ch}"`);
+    tokens.push({ type: "punc", value: punctuator });
+    i += punctuator.length;
+  }
+  return tokens;
+}
+function createParser(tokens) {
+  let pos = 0;
+  const peek = () => tokens[pos];
+  const isPunc = (v) => {
+    const token = peek();
+    return !!token && token.type === "punc" && token.value === v;
+  };
+  const eat = (v) => {
+    if (!isPunc(v)) throw new Error(`\u7F3A\u5C11 "${v}"`);
+    pos++;
+  };
+  const binaryLevels = [
+    ["||"],
+    ["&&"],
+    ["===", "!==", "==", "!="],
+    ["<", ">", "<=", ">="],
+    ["+", "-"],
+    ["*", "/", "%"]
+  ];
+  function parseExpression() {
+    return parseTernary();
+  }
+  function parseTernary() {
+    const test = parseBinary(0);
+    if (!isPunc("?")) return test;
+    eat("?");
+    const consequent = parseTernary();
+    eat(":");
+    const alternate = parseTernary();
+    return { kind: "ternary", test, consequent, alternate };
+  }
+  function parseBinary(level) {
+    if (level >= binaryLevels.length) return parseUnary();
+    let left = parseBinary(level + 1);
+    for (; ; ) {
+      const token = peek();
+      if (!token || token.type !== "punc") break;
+      if (binaryLevels[level].indexOf(String(token.value)) === -1) break;
+      const operator = String(token.value);
+      pos++;
+      const right = parseBinary(level + 1);
+      left = { kind: "binary", operator, left, right };
+    }
+    return left;
+  }
+  function parseUnary() {
+    if (isPunc("!") || isPunc("-")) {
+      const operator = String(peek().value);
+      pos++;
+      return { kind: "unary", operator, argument: parseUnary() };
+    }
+    return parseMember();
+  }
+  function parseMember() {
+    let object = parsePrimary();
+    for (; ; ) {
+      if (isPunc(".")) {
+        eat(".");
+        const token = peek();
+        if (!token || token.type !== "ident") throw new Error('"." \u540E\u9762\u9700\u8981\u5C5E\u6027\u540D');
+        pos++;
+        object = {
+          kind: "member",
+          object,
+          property: { kind: "literal", value: token.value }
+        };
+      } else if (isPunc("[")) {
+        eat("[");
+        const property = parseExpression();
+        eat("]");
+        object = { kind: "member", object, property };
+      } else {
+        return object;
+      }
+    }
+  }
+  function parsePrimary() {
+    const token = peek();
+    if (!token) throw new Error("\u8868\u8FBE\u5F0F\u4E0D\u5B8C\u6574");
+    if (isPunc("(")) {
+      eat("(");
+      const node = parseExpression();
+      eat(")");
+      return node;
+    }
+    if (token.type === "number" || token.type === "string") {
+      pos++;
+      return { kind: "literal", value: token.value };
+    }
+    if (token.type === "ident") {
+      pos++;
+      const name = String(token.value);
+      if (Object.prototype.hasOwnProperty.call(KEYWORD_LITERALS, name)) {
+        return { kind: "literal", value: KEYWORD_LITERALS[name] };
+      }
+      return { kind: "identifier", name };
+    }
+    throw new Error(`\u610F\u5916\u7684\u7B26\u53F7 "${token.value}"`);
+  }
+  const ast = parseExpression();
+  if (pos < tokens.length) throw new Error(`\u8868\u8FBE\u5F0F\u7ED3\u5C3E\u6709\u591A\u4F59\u5185\u5BB9 "${tokens[pos].value}"`);
+  return ast;
+}
+var astCache = /* @__PURE__ */ new Map();
+function parse(source) {
+  const cached = astCache.get(source);
+  if (cached) return cached;
+  const ast = createParser(tokenize(source));
+  astCache.set(source, ast);
+  return ast;
+}
+var BLOCKED_KEYS = ["__proto__", "constructor", "prototype"];
+function readProperty(object, key) {
+  if (object === null || object === void 0) return void 0;
+  if (BLOCKED_KEYS.indexOf(String(key)) > -1) return void 0;
+  const value = object[String(key)];
+  return typeof value === "function" ? void 0 : value;
+}
+function evaluateNode(node, context) {
+  switch (node.kind) {
+    case "literal":
+      return node.value;
+    case "identifier":
+      return readProperty(context, node.name);
+    case "member":
+      return readProperty(
+        evaluateNode(node.object, context),
+        evaluateNode(node.property, context)
+      );
+    case "unary": {
+      const value = evaluateNode(node.argument, context);
+      return node.operator === "!" ? !value : -value;
+    }
+    case "ternary":
+      return evaluateNode(node.test, context) ? evaluateNode(node.consequent, context) : evaluateNode(node.alternate, context);
+    case "binary": {
+      if (node.operator === "&&") {
+        return evaluateNode(node.left, context) && evaluateNode(node.right, context);
+      }
+      if (node.operator === "||") {
+        return evaluateNode(node.left, context) || evaluateNode(node.right, context);
+      }
+      const left = evaluateNode(node.left, context);
+      const right = evaluateNode(node.right, context);
+      switch (node.operator) {
+        case "===":
+          return left === right;
+        case "!==":
+          return left !== right;
+        case "==":
+          return left == right;
+        case "!=":
+          return left != right;
+        case "<":
+          return left < right;
+        case ">":
+          return left > right;
+        case "<=":
+          return left <= right;
+        case ">=":
+          return left >= right;
+        case "+":
+          return left + right;
+        case "-":
+          return left - right;
+        case "*":
+          return left * right;
+        case "/":
+          return left / right;
+        case "%":
+          return left % right;
+        default:
+          throw new Error(`\u4E0D\u652F\u6301\u7684\u8FD0\u7B97\u7B26 "${node.operator}"`);
+      }
+    }
+    default:
+      throw new Error("\u4E0D\u652F\u6301\u7684\u8282\u70B9\u7C7B\u578B");
+  }
+}
+function evaluate(source, context) {
+  try {
+    return evaluateNode(parse(source), context);
+  } catch (e) {
+    return void 0;
+  }
+}
+function check(source) {
+  try {
+    parse(source);
+    return "";
+  } catch (error) {
+    return error.message;
+  }
+}
+var INTERPOLATION_RE = /\{\{([\s\S]+?)\}\}/g;
+function interpolate(input, context) {
+  if (typeof input !== "string" || input.indexOf("{{") === -1) return input;
+  const trimmed = input.trim();
+  const tokens = trimmed.match(INTERPOLATION_RE) || [];
+  if (tokens.length === 1 && tokens[0] === trimmed) {
+    return evaluate(trimmed.slice(2, -2).trim(), context);
+  }
+  return input.replace(INTERPOLATION_RE, (_, expr) => {
+    const value = evaluate(expr.trim(), context);
+    return value === void 0 || value === null ? "" : String(value);
+  });
+}
+function interpolateDeep(input, context) {
+  if (typeof input === "string") return interpolate(input, context);
+  if (Array.isArray(input)) {
+    return input.map((item) => interpolateDeep(item, context));
+  }
+  if (input && typeof input === "object") {
+    const result = {};
+    Object.keys(input).forEach((key) => {
+      result[key] = interpolateDeep(input[key], context);
+    });
+    return result;
+  }
+  return input;
+}
+
+// src/countdown.ts
+function pad(value, len = 2) {
+  return String(value).padStart(len, "0");
+}
+function parseEndTime(to) {
+  if (typeof to === "number") return to;
+  if (to === void 0 || to === null || to === "") return 0;
+  const raw = String(to).trim();
+  if (!raw) return 0;
+  if (/^\d+$/.test(raw)) return Number(raw);
+  if (/^\d{4}年/.test(raw)) {
+    const normalizedZh = raw.replace(/年|月/g, "/").replace(/日/g, " ").replace(/时|点|分/g, ":").replace(/秒/g, "").replace(/:+/g, ":").replace(/\s+/g, " ").replace(/[:\s]+$/, "").replace(/(\s\d{1,2})$/, "$1:00").trim();
+    const time2 = new Date(normalizedZh).getTime();
+    return isNaN(time2) ? 0 : time2;
+  }
+  const isIso = /^\d{4}-\d{2}-\d{2}T/.test(raw);
+  const normalized = isIso ? raw : raw.replace(/-/g, "/");
+  const time = new Date(normalized).getTime();
+  return isNaN(time) ? 0 : time;
+}
+function isValidEndTime(to) {
+  if (typeof to === "number") return isFinite(to) && to > 0;
+  if (typeof to !== "string") return false;
+  if (to.indexOf("{{") > -1) return true;
+  return parseEndTime(to) > 0;
+}
+function computeParts(endTime, now = Date.now()) {
+  const raw = endTime - now;
+  const remain = raw > 0 ? raw : 0;
+  const cs = Math.floor(remain / 10);
+  const sec = Math.floor(cs / 100);
+  return {
+    d: String(Math.floor(sec / 86400)),
+    // h 是 0~23；跨天还想连着数小时的用 hAll（如 143:58:07）
+    h: pad(Math.floor(sec % 86400 / 3600)),
+    hAll: pad(Math.floor(sec / 3600)),
+    m: pad(Math.floor(sec % 3600 / 60)),
+    s: pad(sec % 60),
+    cs: pad(cs % 100),
+    ended: !endTime || remain <= 0
+  };
+}
+function formatParts(parts, format) {
+  return (format || "{d}\u5929 {h}:{m}:{s}").replace("{d}", parts.d).replace("{hAll}", parts.hAll).replace("{h}", parts.h).replace("{m}", parts.m).replace("{s}", parts.s).replace("{cs}", parts.cs);
+}
+function createTicker(options) {
+  let timer = null;
+  let raf = 0;
+  let running = false;
+  let precision = "s";
+  let endTimes = [];
+  const hasRaf = typeof requestAnimationFrame === "function";
+  function allEnded() {
+    const now = Date.now();
+    return endTimes.every((end) => !end || end - now <= 0);
+  }
+  function tick() {
+    options.onTick();
+    if (allEnded()) {
+      stop();
+      if (options.onAllEnded) options.onAllEnded();
+    }
+  }
+  function stop() {
+    running = false;
+    if (timer) {
+      clearInterval(timer);
+      timer = null;
+    }
+    if (raf) {
+      cancelAnimationFrame(raf);
+      raf = 0;
+    }
+  }
+  function sync(nextEndTimes, nextPrecision) {
+    const changed = nextPrecision !== precision || nextEndTimes.length !== endTimes.length || nextEndTimes.some((end, i) => end !== endTimes[i]);
+    endTimes = nextEndTimes;
+    precision = nextPrecision;
+    if (!changed && running) return;
+    stop();
+    if (!endTimes.length || allEnded()) return;
+    running = true;
+    if (precision === "cs" && hasRaf) {
+      const loop = () => {
+        tick();
+        if (running) raf = requestAnimationFrame(loop);
+      };
+      raf = requestAnimationFrame(loop);
+    } else {
+      timer = setInterval(tick, 1e3);
+    }
+  }
+  return { sync, stop };
+}
+
+// src/views.ts
+var SINGLE_VIEW_NAME = "main";
+function normalizeViews(dsl) {
+  if (!dsl || typeof dsl !== "object") {
+    return { entry: SINGLE_VIEW_NAME, views: {}, isMulti: false };
+  }
+  if (dsl.views && typeof dsl.views === "object" && !Array.isArray(dsl.views)) {
+    const names = Object.keys(dsl.views);
+    return {
+      entry: dsl.entry && dsl.views[dsl.entry] ? dsl.entry : names[0],
+      views: dsl.views,
+      isMulti: true
+    };
+  }
+  return {
+    entry: SINGLE_VIEW_NAME,
+    views: {
+      [SINGLE_VIEW_NAME]: {
+        type: dsl.type,
+        stage: dsl.stage,
+        nodes: dsl.nodes
+      }
+    },
+    isMulti: false
+  };
+}
+
+// src/style.ts
+function toLength(value) {
+  return typeof value === "number" ? `${value}px` : String(value);
+}
+var px = toLength;
+var LENGTH_RE = /^-?(\d+(\.\d+)?)(px|%|em|rem|vw|vh)$/;
+function isLength(value) {
+  if (typeof value === "number") return isFinite(value);
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (trimmed === "auto" || trimmed === "0") return true;
+  if (/^calc\([^;{}]*\)$/.test(trimmed)) return true;
+  return LENGTH_RE.test(trimmed);
+}
+var STYLE_MAP = {
+  // 文字
+  color: ["color", String],
+  fontSize: ["fontSize", px],
+  fontWeight: ["fontWeight", String],
+  fontFamily: ["fontFamily", String],
+  lineHeight: ["lineHeight", (v) => typeof v === "number" && v > 4 ? px(v) : String(v)],
+  letterSpacing: ["letterSpacing", px],
+  textAlign: ["textAlign", String],
+  textDecoration: ["textDecoration", String],
+  whiteSpace: ["whiteSpace", String],
+  // 倒计时这类逐帧变化的数字必须等宽，否则数字会左右抖动
+  fontVariantNumeric: ["fontVariantNumeric", String],
+  // 背景
+  background: ["background", String],
+  backgroundImage: ["backgroundImage", (v) => `url(${JSON.stringify(String(v))})`],
+  backgroundSize: ["backgroundSize", String],
+  backgroundPosition: ["backgroundPosition", String],
+  backgroundRepeat: ["backgroundRepeat", String],
+  // 边框与圆角
+  border: ["border", String],
+  borderColor: ["borderColor", String],
+  borderWidth: ["borderWidth", px],
+  borderStyle: ["borderStyle", String],
+  radius: ["borderRadius", px],
+  // 盒模型
+  padding: ["padding", px],
+  margin: ["margin", px],
+  marginTop: ["marginTop", px],
+  marginBottom: ["marginBottom", px],
+  marginLeft: ["marginLeft", px],
+  marginRight: ["marginRight", px],
+  overflow: ["overflow", String],
+  opacity: ["opacity", String],
+  shadow: ["boxShadow", String],
+  cursor: ["cursor", String],
+  // flex 容器
+  direction: ["flexDirection", (v) => v === "column" ? "column" : "row"],
+  gap: ["gap", px],
+  wrap: ["flexWrap", (v) => v ? "wrap" : "nowrap"],
+  align: ["alignItems", String],
+  justify: ["justifyContent", String],
+  // flex 子项
+  flex: ["flex", String],
+  // 不写时子项会被拉满父级交叉轴，标签这类「按内容宽度」的元素要显式声明
+  alignSelf: ["alignSelf", String],
+  width: ["width", px],
+  height: ["height", px],
+  minWidth: ["minWidth", px],
+  minHeight: ["minHeight", px],
+  maxWidth: ["maxWidth", px],
+  maxHeight: ["maxHeight", px],
+  // 图片
+  objectFit: ["objectFit", String],
+  // 宽度给百分比、高度按比例算。整图 banner 的热区必须靠它才能用百分比定位：
+  // 容器没有真实高度时，子节点的百分比 rect 算出来全是 0。
+  aspectRatio: ["aspectRatio", String]
+};
+var ALLOWED_STYLE_KEYS = Object.keys(STYLE_MAP);
+function toCssStyle(style) {
+  const css = {};
+  if (!style) return css;
+  Object.keys(style).forEach((key) => {
+    const rule = STYLE_MAP[key];
+    if (!rule) return;
+    const value = style[key];
+    if (value === void 0 || value === null || value === "") return;
+    css[rule[0]] = rule[1](value);
+  });
+  return css;
+}
+function toRectStyle(rect) {
+  if (!Array.isArray(rect)) return {};
+  const [x, y, w, h] = rect;
+  const css = { position: "absolute", left: px(x || 0), top: px(y || 0) };
+  if (w !== void 0 && w !== null && w !== "auto") css.width = px(w);
+  if (h !== void 0 && h !== null && h !== "auto") css.height = px(h);
+  return css;
+}
+function resolveNodeStyle(node, layout) {
+  return Object.assign(
+    {},
+    layout === "absolute" ? toRectStyle(node.rect) : {},
+    toCssStyle(node.style)
+  );
+}
+
+// src/validate.ts
+var LENGTH_STYLE_KEYS = [
+  "width",
+  "height",
+  "minWidth",
+  "minHeight",
+  "maxWidth",
+  "maxHeight",
+  "radius",
+  "padding",
+  "margin",
+  "marginTop",
+  "marginBottom",
+  "marginLeft",
+  "marginRight",
+  "gap",
+  "fontSize",
+  "letterSpacing",
+  "borderWidth"
+];
+var DSL_VERSION = 1;
+var NODE_TYPES = [
+  "box",
+  "flex",
+  "repeat",
+  "image",
+  "text",
+  "button",
+  "tabs",
+  "countdown"
+];
+var ACTION_TYPES = [
+  "navigate",
+  "close",
+  "closeAll",
+  "open",
+  "setState",
+  "track",
+  "call",
+  "sequence"
+];
+var TRACK_EVENT_PATTERN = /^[a-z][a-z0-9_]{2,63}$/;
+var CLOSE_POSITIONS = [
+  "top-right",
+  "top-left",
+  "top-center",
+  "bottom-right",
+  "bottom-left",
+  "bottom-center"
+];
+var CONTAINER_TYPES = ["box", "flex"];
+function validate(dsl) {
+  const errors = [];
+  const warnings = [];
+  const add = (path, message) => errors.push({ path, message });
+  const warn = (path, message) => warnings.push({ path, message });
+  if (!dsl || typeof dsl !== "object" || Array.isArray(dsl)) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: "\u6839\u8282\u70B9\u5FC5\u987B\u662F\u4E00\u4E2A\u5BF9\u8C61" }],
+      warnings
+    };
+  }
+  const doc = dsl;
+  if (doc.version !== DSL_VERSION) {
+    add(
+      "version",
+      `version \u5FC5\u987B\u662F ${DSL_VERSION}\uFF0C\u5F53\u524D\u4E3A ${JSON.stringify(doc.version)}`
+    );
+  }
+  const dataKeys = validateData(doc.data, add);
+  const stateKeys = validateState(doc.state, add);
+  validateDerived(doc.derived, dataKeys, stateKeys, add);
+  const isMulti = doc.views !== void 0;
+  if (isMulti) validateMultiView(doc, add);
+  const { views } = normalizeViews(doc);
+  const viewNames = Object.keys(views);
+  const ctx = { add, warn, viewNames };
+  viewNames.forEach((name) => {
+    validateView(views[name], isMulti ? `views.${name}` : "", ctx);
+  });
+  return { valid: errors.length === 0, errors, warnings };
+}
+function validateMultiView(dsl, add) {
+  if (typeof dsl.views !== "object" || dsl.views === null || Array.isArray(dsl.views)) {
+    add("views", 'views \u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u5F62\u5982 { "main": { type, stage, nodes } }');
+    return;
+  }
+  if (!Object.keys(dsl.views).length) {
+    add("views", "views \u81F3\u5C11\u8981\u6709\u4E00\u4E2A\u89C6\u56FE");
+    return;
+  }
+  if (dsl.entry === void 0) {
+    add("entry", "\u591A\u89C6\u56FE\u5FC5\u987B\u6307\u5B9A entry\uFF08\u9996\u4E2A\u5C55\u793A\u7684\u89C6\u56FE\u540D\uFF09");
+  } else if (!dsl.views[dsl.entry]) {
+    add("entry", `entry "${dsl.entry}" \u5728 views \u91CC\u4E0D\u5B58\u5728`);
+  }
+  ["stage", "nodes"].forEach((key) => {
+    if (dsl[key] !== void 0) {
+      add(key, `\u7528\u4E86 views \u4E4B\u540E\uFF0C${key} \u8981\u5199\u5728\u6BCF\u4E2A\u89C6\u56FE\u91CC\uFF0C\u4E0D\u80FD\u7559\u5728\u9876\u5C42`);
+    }
+  });
+}
+function validateView(view, prefix, ctx) {
+  const { add, warn } = ctx;
+  const at = (key) => prefix ? `${prefix}.${key}` : key;
+  if (!view || typeof view !== "object" || Array.isArray(view)) {
+    add(prefix || "view", "\u89C6\u56FE\u5FC5\u987B\u662F\u5BF9\u8C61\uFF0C\u5305\u542B type / stage / nodes");
+    return;
+  }
+  if (["popup", "banner", "notice"].indexOf(view.type) === -1) {
+    add(at("type"), "type \u5FC5\u987B\u662F popup / banner / notice \u4E4B\u4E00");
+  }
+  validateStage(
+    view.stage,
+    (path, message) => add(prefix ? `${prefix}.${path}` : path, message),
+    warn,
+    ctx,
+    prefix
+  );
+  if (!Array.isArray(view.nodes) || view.nodes.length === 0) {
+    add(at("nodes"), "nodes \u5FC5\u987B\u662F\u975E\u7A7A\u6570\u7EC4");
+    return;
+  }
+  const rootLayout = (view.stage || {}).layout === "flow" ? "flow" : "absolute";
+  view.nodes.forEach((node, index) => {
+    validateNode(node, at(`nodes[${index}]`), rootLayout, ctx);
+  });
+}
+function checkLength(value) {
+  if (typeof value === "string" && value.indexOf("{{") > -1) return true;
+  if (typeof value === "number") return isLength(value);
+  if (typeof value !== "string") return false;
+  if (isLength(value)) return true;
+  return value.trim().split(/\s+/).every(isLength);
+}
+function checkAspectRatio(value) {
+  if (typeof value === "string" && value.indexOf("{{") > -1) return true;
+  if (typeof value === "number") return isFinite(value) && value > 0;
+  if (typeof value !== "string") return false;
+  return /^\s*\d+(\.\d+)?\s*(\/\s*\d+(\.\d+)?\s*)?$/.test(value);
+}
+function validateStage(stage, add, warn, ctx, prefix) {
+  if (stage === void 0) {
+    add("stage", "\u7F3A\u5C11 stage");
+    return;
+  }
+  if (typeof stage !== "object" || stage === null) {
+    add("stage", "stage \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (!checkLength(stage.width)) {
+    add(
+      "stage.width",
+      "stage.width \u5FC5\u987B\u662F\u6570\u5B57(px)\u6216\u957F\u5EA6\u5B57\u7B26\u4E32\uFF0C\u5982 460 / '100%' / 'calc(100% - 32px)'"
+    );
+  }
+  if (!checkLength(stage.height)) {
+    add("stage.height", "stage.height \u5FC5\u987B\u662F\u6570\u5B57(px)\u6216\u957F\u5EA6\u5B57\u7B26\u4E32\uFF0C\u5982 520 / 'auto'");
+  }
+  if (stage.layout !== void 0 && ["absolute", "flow"].indexOf(stage.layout) === -1) {
+    add("stage.layout", "stage.layout \u53EA\u80FD\u662F 'absolute'\uFF08\u9ED8\u8BA4\uFF09\u6216 'flow'");
+  }
+  validateCloseButton(stage.closeButton, add, warn);
+  const at = (key) => prefix ? `${prefix}.stage.${key}` : `stage.${key}`;
+  if (stage.onShow !== void 0) validateAction(stage.onShow, at("onShow"), ctx);
+  if (stage.onClose !== void 0) validateAction(stage.onClose, at("onClose"), ctx);
+  if (stage.height === "auto" && stage.layout !== "flow") {
+    add(
+      "stage.height",
+      "height: 'auto' \u9700\u8981\u540C\u65F6\u8BBE\u7F6E stage.layout: 'flow'\uFF0C\u5426\u5219\u9AD8\u5EA6\u4F1A\u584C\u6210 0"
+    );
+  }
+}
+function validateCloseButton(config, add, warn) {
+  if (config === void 0) return;
+  if (typeof config !== "object" || config === null || Array.isArray(config)) {
+    add("stage.closeButton", "closeButton \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (config.position !== void 0 && CLOSE_POSITIONS.indexOf(config.position) === -1) {
+    add("stage.closeButton.position", `position \u53EA\u80FD\u662F ${CLOSE_POSITIONS.join(" / ")}`);
+  }
+  if (config.offset !== void 0) {
+    if (!Array.isArray(config.offset) || config.offset.length !== 2) {
+      add(
+        "stage.closeButton.offset",
+        "offset \u5FC5\u987B\u662F [x, y] \u4E24\u9879\u6570\u7EC4\uFF0C\u8D1F\u503C\u4F1A\u628A\u6309\u94AE\u79FB\u5230\u5F39\u7A97\u5916\u9762"
+      );
+    } else {
+      config.offset.forEach((value, index) => {
+        if (!checkLength(value)) {
+          add(`stage.closeButton.offset[${index}]`, `"${value}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6`);
+        }
+      });
+    }
+  }
+  if (config.size !== void 0 && !checkLength(config.size)) {
+    add("stage.closeButton.size", `"${config.size}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6`);
+  }
+  if (config.icon !== void 0 && typeof config.icon !== "string") {
+    add("stage.closeButton.icon", "icon \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+  }
+  if (config.image !== void 0 && typeof config.image !== "string") {
+    add("stage.closeButton.image", "image \u5FC5\u987B\u662F\u56FE\u7247\u94FE\u63A5\u5B57\u7B26\u4E32");
+  }
+  if (config.style) {
+    Object.keys(config.style).forEach((key) => {
+      if (ALLOWED_STYLE_KEYS.indexOf(key) === -1) {
+        warn(
+          `stage.closeButton.style.${key}`,
+          `\u6837\u5F0F\u5C5E\u6027 "${key}" \u4E0D\u5728\u767D\u540D\u5355\u5185\uFF0C\u6E32\u67D3\u65F6\u4F1A\u88AB\u5FFD\u7565`
+        );
+      }
+    });
+  }
+}
+function validateData(data, add) {
+  if (data === void 0) return [];
+  if (typeof data !== "object" || data === null || Array.isArray(data)) {
+    add("data", "data \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return [];
+  }
+  Object.keys(data).forEach((key) => {
+    const value = data[key];
+    if (value && typeof value === "object" && !Array.isArray(value) && value.$source) {
+      if (typeof value.$source !== "string") {
+        add(`data.${key}.$source`, "$source \u5FC5\u987B\u662F\u6570\u636E\u6E90\u540D\u79F0\u5B57\u7B26\u4E32");
+      }
+      if (value.params !== void 0 && (typeof value.params !== "object" || value.params === null)) {
+        add(`data.${key}.params`, "params \u5FC5\u987B\u662F\u5BF9\u8C61");
+      }
+    }
+  });
+  return Object.keys(data);
+}
+function validateState(state, add) {
+  if (state === void 0) return [];
+  if (typeof state !== "object" || state === null || Array.isArray(state)) {
+    add("state", "state \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return [];
+  }
+  return Object.keys(state);
+}
+function validateDerived(derived, dataKeys, stateKeys, add) {
+  if (derived === void 0) return;
+  if (typeof derived !== "object" || derived === null || Array.isArray(derived)) {
+    add("derived", "derived \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  Object.keys(derived).forEach((key) => {
+    const item = derived[key] || {};
+    if (typeof item.list !== "string") {
+      add(`derived.${key}.list`, "list \u5FC5\u987B\u662F data \u4E2D\u7684\u6570\u7EC4\u5B57\u6BB5\u540D");
+    } else if (dataKeys.indexOf(item.list) === -1) {
+      add(`derived.${key}.list`, `data \u4E2D\u4E0D\u5B58\u5728 "${item.list}"`);
+    }
+    if (typeof item.indexBy !== "string") {
+      add(`derived.${key}.indexBy`, "indexBy \u5FC5\u987B\u662F state \u4E2D\u7684\u5B57\u6BB5\u540D");
+    } else if (stateKeys.indexOf(item.indexBy) === -1) {
+      add(`derived.${key}.indexBy`, `state \u4E2D\u4E0D\u5B58\u5728 "${item.indexBy}"`);
+    }
+  });
+}
+function validateNode(node, path, layout, ctx) {
+  const { add, warn } = ctx;
+  if (!node || typeof node !== "object" || Array.isArray(node)) {
+    add(path, "\u8282\u70B9\u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (NODE_TYPES.indexOf(node.type) === -1) {
+    add(`${path}.type`, `\u672A\u77E5\u8282\u70B9\u7C7B\u578B "${node.type}"\uFF0C\u53EF\u7528\uFF1A${NODE_TYPES.join(" / ")}`);
+    return;
+  }
+  if (layout === "absolute" && !Array.isArray(node.rect)) {
+    add(`${path}.rect`, "\u5904\u4E8E\u7EDD\u5BF9\u5B9A\u4F4D\u5BB9\u5668\u4E2D\uFF0C\u5FC5\u987B\u63D0\u4F9B rect: [x, y, w, h]");
+  }
+  if (node.rect !== void 0) {
+    if (!Array.isArray(node.rect)) {
+      add(`${path}.rect`, "rect \u5FC5\u987B\u662F [x, y, w, h] \u6570\u7EC4");
+    } else {
+      node.rect.forEach((value, index) => {
+        if (value !== void 0 && value !== null && !checkLength(value)) {
+          add(
+            `${path}.rect[${index}]`,
+            `"${value}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6\uFF0C\u652F\u6301\u6570\u5B57(px) / '100%' / 'auto' \u7B49`
+          );
+        }
+      });
+    }
+  }
+  if (node.style) {
+    Object.keys(node.style).forEach((key) => {
+      if (ALLOWED_STYLE_KEYS.indexOf(key) === -1) {
+        warn(`${path}.style.${key}`, `\u6837\u5F0F\u5C5E\u6027 "${key}" \u4E0D\u5728\u767D\u540D\u5355\u5185\uFF0C\u6E32\u67D3\u65F6\u4F1A\u88AB\u5FFD\u7565`);
+        return;
+      }
+      if (LENGTH_STYLE_KEYS.indexOf(key) > -1 && !checkLength(node.style[key])) {
+        add(
+          `${path}.style.${key}`,
+          `"${node.style[key]}" \u4E0D\u662F\u5408\u6CD5\u957F\u5EA6\uFF0C\u652F\u6301\u6570\u5B57(px) / '100%' / 'auto' \u7B49`
+        );
+      }
+      if (key === "aspectRatio" && !checkAspectRatio(node.style[key])) {
+        add(
+          `${path}.style.aspectRatio`,
+          "aspectRatio \u8981\u5199\u6210 '750 / 200' \u6216 1.5 \u8FD9\u6837\u7684\u5BBD\u9AD8\u6BD4"
+        );
+      }
+    });
+  }
+  if (node.visibleWhen !== void 0) {
+    if (typeof node.visibleWhen !== "string") {
+      add(`${path}.visibleWhen`, "visibleWhen \u5FC5\u987B\u662F\u8868\u8FBE\u5F0F\u5B57\u7B26\u4E32");
+    } else {
+      const error = check(node.visibleWhen);
+      if (error) add(`${path}.visibleWhen`, `\u8868\u8FBE\u5F0F\u6709\u8BEF\uFF1A${error}`);
+    }
+  }
+  if (node.action !== void 0) validateAction(node.action, `${path}.action`, ctx);
+  validateNodeByType(node, path, ctx);
+}
+function validateNodeByType(node, path, ctx) {
+  const { add } = ctx;
+  if (node.type === "image" && !node.src) {
+    add(`${path}.src`, "image \u5FC5\u987B\u63D0\u4F9B src");
+  }
+  if (node.type === "text" && node.content === void 0) {
+    add(`${path}.content`, "text \u5FC5\u987B\u63D0\u4F9B content");
+  }
+  if (node.type === "button" && node.text === void 0) {
+    add(`${path}.text`, "button \u5FC5\u987B\u63D0\u4F9B text");
+  }
+  if (node.type === "tabs") {
+    if (typeof node.bind !== "string") {
+      add(`${path}.bind`, "tabs \u5FC5\u987B\u63D0\u4F9B bind\uFF08data \u4E2D\u7684\u6570\u7EC4\u5B57\u6BB5\u540D\uFF09");
+    }
+    if (typeof node.stateKey !== "string")
+      add(`${path}.stateKey`, "tabs \u5FC5\u987B\u63D0\u4F9B stateKey");
+    if (node.labelField !== void 0 && typeof node.labelField !== "string") {
+      add(`${path}.labelField`, "labelField \u5FC5\u987B\u662F\u5B57\u7B26\u4E32");
+    }
+  }
+  if (node.type === "countdown") {
+    if (!node.to) {
+      add(`${path}.to`, "countdown \u5FC5\u987B\u63D0\u4F9B to\uFF08\u7ED3\u675F\u65F6\u95F4\uFF09");
+    } else if (!isValidEndTime(node.to)) {
+      add(
+        `${path}.to`,
+        `"${node.to}" \u4E0D\u662F\u80FD\u8BC6\u522B\u7684\u65F6\u95F4\u3002\u53EF\u4EE5\u5199 "2026-09-01 18:00:00" / "2026-09-01" / "2026\u5E749\u67081\u65E5 18\u70B9" / ISO \u683C\u5F0F / \u65F6\u95F4\u6233`
+      );
+    }
+    if (node.precision !== void 0 && ["s", "cs"].indexOf(node.precision) === -1) {
+      add(`${path}.precision`, "precision \u53EA\u80FD\u662F 's'\uFF08\u6BCF\u79D2\uFF09\u6216 'cs'\uFF08\u5398\u79D2\uFF0C\u9010\u5E27\u5237\u65B0\uFF09");
+    }
+    if (node.children !== void 0 && !Array.isArray(node.children)) {
+      add(`${path}.children`, "children \u5FC5\u987B\u662F\u6570\u7EC4");
+    } else {
+      (node.children || []).forEach((child, index) => {
+        validateNode(child, `${path}.children[${index}]`, "flow", ctx);
+      });
+    }
+  }
+  if (node.type === "repeat") {
+    if (typeof node.bind !== "string") add(`${path}.bind`, "repeat \u5FC5\u987B\u63D0\u4F9B bind");
+    if (!node.template) {
+      add(`${path}.template`, "repeat \u5FC5\u987B\u63D0\u4F9B template");
+    } else {
+      validateNode(node.template, `${path}.template`, "flow", ctx);
+    }
+  }
+  if (CONTAINER_TYPES.indexOf(node.type) > -1) {
+    const childLayout = node.type === "box" ? "absolute" : "flow";
+    if (node.children !== void 0 && !Array.isArray(node.children)) {
+      add(`${path}.children`, "children \u5FC5\u987B\u662F\u6570\u7EC4");
+    } else {
+      (node.children || []).forEach((child, index) => {
+        validateNode(child, `${path}.children[${index}]`, childLayout, ctx);
+      });
+    }
+  }
+}
+function validateAction(action, path, ctx) {
+  const { add } = ctx;
+  if (!action || typeof action !== "object" || Array.isArray(action)) {
+    add(path, "action \u5FC5\u987B\u662F\u5BF9\u8C61");
+    return;
+  }
+  if (ACTION_TYPES.indexOf(action.type) === -1) {
+    add(`${path}.type`, `\u672A\u77E5\u52A8\u4F5C "${action.type}"\uFF0C\u53EF\u7528\uFF1A${ACTION_TYPES.join(" / ")}`);
+    return;
+  }
+  if (action.type === "navigate" && !action.url) {
+    add(`${path}.url`, "navigate \u5FC5\u987B\u63D0\u4F9B url");
+  }
+  if (action.type === "setState" && typeof action.key !== "string") {
+    add(`${path}.key`, "setState \u5FC5\u987B\u63D0\u4F9B key");
+  }
+  if (action.type === "track") {
+    if (!action.event) {
+      add(`${path}.event`, "track \u5FC5\u987B\u63D0\u4F9B event");
+    } else if (typeof action.event !== "string" || !TRACK_EVENT_PATTERN.test(action.event)) {
+      add(
+        `${path}.event`,
+        `\u57CB\u70B9\u4E8B\u4EF6\u540D "${String(action.event)}" \u4E0D\u5408\u89C4\uFF1A\u53EA\u80FD\u7528\u5C0F\u5199\u82F1\u6587\u5B57\u6BCD\u3001\u6570\u5B57\u548C\u4E0B\u5212\u7EBF\uFF0C\u5FC5\u987B\u4EE5\u5C0F\u5199\u5B57\u6BCD\u5F00\u5934\uFF0C\u603B\u957F\u5EA6 3~64 \u4E2A\u5B57\u7B26\uFF08\u4E0D\u80FD\u7528\u4E2D\u6587\u3001\u5927\u5199\u5B57\u6BCD\u3001\u9A7C\u5CF0\u3001\u4E2D\u5212\u7EBF\u6216\u7A7A\u683C\uFF09\u3002\u6B63\u786E\u793A\u4F8B\uFF1Abanner_renew_click`
+      );
+    }
+  }
+  if (action.type === "call" && !action.name) {
+    add(`${path}.name`, "call \u5FC5\u987B\u63D0\u4F9B name\uFF08\u5BBF\u4E3B\u6CE8\u518C\u7684\u65B9\u6CD5\u540D\uFF09");
+  }
+  if (action.type === "open") {
+    if (!action.view) {
+      add(`${path}.view`, "open \u5FC5\u987B\u63D0\u4F9B view\uFF08\u8981\u6253\u5F00\u7684\u89C6\u56FE\u540D\uFF09");
+    } else if (ctx.viewNames && ctx.viewNames.indexOf(action.view) === -1) {
+      add(`${path}.view`, `views \u91CC\u4E0D\u5B58\u5728\u89C6\u56FE "${action.view}"`);
+    }
+    if (action.mode !== void 0 && ["stack", "replace"].indexOf(action.mode) === -1) {
+      add(
+        `${path}.mode`,
+        "mode \u53EA\u80FD\u662F 'stack'\uFF08\u9ED8\u8BA4\uFF0C\u53E0\u4E00\u5C42\uFF09\u6216 'replace'\uFF08\u6362\u6389\u5F53\u524D\u5C42\uFF09"
+      );
+    }
+  }
+  if (action.type === "sequence") {
+    if (!Array.isArray(action.actions)) {
+      add(`${path}.actions`, "sequence \u5FC5\u987B\u63D0\u4F9B actions \u6570\u7EC4");
+    } else {
+      action.actions.forEach(
+        (item, index) => validateAction(item, `${path}.actions[${index}]`, ctx)
+      );
+    }
+  }
+}
+function formatIssues(issues) {
+  return issues.map((item) => item.path ? `${item.path}: ${item.message}` : item.message).join("\n");
+}
+
+export { ACTION_TYPES, ALLOWED_STYLE_KEYS, CLOSE_POSITIONS, DSL_VERSION, NODE_TYPES, SINGLE_VIEW_NAME, TRACK_EVENT_PATTERN, check, computeParts, createTicker, evaluate, formatIssues, formatParts, interpolate, interpolateDeep, isLength, isValidEndTime, normalizeViews, parseEndTime, resolveNodeStyle, toCssStyle, toLength, validate };