@pixerate/editor 0.271.0 → 0.272.1

package/dist/{chunk-2WOGXEDX.cjs → chunk-M3RZOF3G.cjs}

@@ -74,7 +74,7 @@ function profileAlongPolyline(points, values, count = 32) {
 var round3 = (v) => Math.round(v * 1e3) / 1e3;
 var loading = null;
 function loadCanvasBrushstrokeRenderer() {
-  loading ??= Promise.resolve().then(() => _interopRequireWildcard(require("./brushstrokeRender-WR2N5HHY.cjs"))).catch((error) => {
+  loading ??= Promise.resolve().then(() => _interopRequireWildcard(require("./brushstrokeRender-5YBCLFDQ.cjs"))).catch((error) => {
     loading = null;
     throw error;
   });

package/dist/chunk-MFBUQC67.cjs

@@ -0,0 +1,328 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunk7TD63DZPcjs = require('./chunk-7TD63DZP.cjs');
+
+
+var _chunkWOFXZ3XUcjs = require('./chunk-WOFXZ3XU.cjs');
+
+
+
+var _chunk2BSBFBOAcjs = require('./chunk-2BSBFBOA.cjs');
+
+// src/tools/style.ts
+var STYLE_SKILL_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseStyleDomains(markdown) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---/.exec(markdown);
+  const line = _optionalChain([match, 'optionalAccess', _ => _[1], 'access', _2 => _2.split, 'call', _3 => _3(/\r?\n/), 'access', _4 => _4.find, 'call', _5 => _5((l) => /^domains:/.test(l))]);
+  if (!line) return void 0;
+  const raw = line.slice("domains:".length).trim().replace(/^\[|\]$/g, "");
+  return raw.split(",").map((d) => d.trim().replace(/^(['"])(.*)\1$/, "$2")).filter(Boolean);
+}
+function memoryStyleStore(initial = {}, state = {}) {
+  const files = /* @__PURE__ */ new Map();
+  const states = new Map(Object.entries(state));
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => listeners.forEach((l) => l());
+  for (const [path, text] of Object.entries(initial)) {
+    const [dir, ...rest] = path.replace(/\\/g, "/").replace(/^\.?\//, "").split("/");
+    if (!dir || !rest.length) continue;
+    if (!files.has(dir)) files.set(dir, /* @__PURE__ */ new Map());
+    files.get(dir).set(rest.join("/"), text);
+  }
+  return {
+    list: () => [.../* @__PURE__ */ new Set([...files.keys(), ...states.keys()])].sort().map((name) => ({ name, ...states.get(name) })),
+    read: (name, file) => _optionalChain([files, 'access', _6 => _6.get, 'call', _7 => _7(name), 'optionalAccess', _8 => _8.get, 'call', _9 => _9(file)]),
+    files: (name) => [..._nullishCoalesce(_optionalChain([files, 'access', _10 => _10.get, 'call', _11 => _11(name), 'optionalAccess', _12 => _12.keys, 'call', _13 => _13()]), () => ( []))].sort(),
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    set(name, skillFiles) {
+      files.set(name, new Map(Object.entries(skillFiles)));
+      notify();
+    },
+    remove(name) {
+      files.delete(name);
+      states.delete(name);
+      notify();
+    },
+    setState(name, next) {
+      if (next) states.set(name, next);
+      else states.delete(name);
+      notify();
+    }
+  };
+}
+function resolveTokens(value, tokens, path, errors) {
+  if (Array.isArray(value)) return value.map((v, i) => resolveTokens(v, tokens, `${path}[${i}]`, errors));
+  if (!isPlainObject(value)) return value;
+  if ("$token" in value) {
+    const token = value.$token;
+    const mode = value.mode;
+    if (typeof token !== "string" || !token || mode !== void 0 && typeof mode !== "string" || Object.keys(value).some((k) => k !== "$token" && k !== "mode")) {
+      errors.push(`${path || "profile"}: a token reference is { "$token": "<variable name or id>", "mode"?: "<mode>" }.`);
+      return void 0;
+    }
+    if (!tokens) {
+      errors.push(`${path}: "${token}" is a token reference, but this host has no design tokens to resolve it.`);
+      return void 0;
+    }
+    const resolved = tokens.resolve({ token, ...mode ? { mode } : {} });
+    if (!resolved.ok) errors.push(`${path}: ${resolved.message}`);
+    return resolved.ok ? resolved.value : void 0;
+  }
+  const out = {};
+  for (const [k, v] of Object.entries(value)) out[k] = resolveTokens(v, tokens, path ? `${path}.${k}` : k, errors);
+  return out;
+}
+function checkListErrors(list, domain) {
+  if (list === void 0) return [];
+  if (!Array.isArray(list)) return ['checks: expected a list of check ids or { "id": ..., options } objects.'];
+  const errors = [];
+  list.forEach((entry, i) => {
+    const id = typeof entry === "string" ? entry : isPlainObject(entry) ? entry.id : void 0;
+    if (typeof id !== "string" || !id) {
+      errors.push(`checks[${i}]: expected a check id or { "id": ..., options }.`);
+      return;
+    }
+    const check = domain.checks.find((c) => c.id === id);
+    if (!check || typeof entry === "string") return;
+    const { id: _id, ...options } = entry;
+    const schema = _nullishCoalesce(check.optionsSchema, () => ( { type: "object", properties: {}, additionalProperties: false }));
+    for (const e of _chunkWOFXZ3XUcjs.validateJsonSchema.call(void 0, options, schema)) errors.push(`checks[${i}] (${id})${e.path}: ${e.message}`);
+  });
+  return errors;
+}
+function mergeProfile(target, value, layer, skill, sources, locked, issues, prefix = "") {
+  for (const [key, next] of Object.entries(value)) {
+    if (_chunk2BSBFBOAcjs.isUnsafeJsonKey.call(void 0, key) || next === void 0) continue;
+    const path = prefix ? `${prefix}.${key}` : key;
+    const lockedBy = [...locked.entries()].find(([p]) => p === path || path.startsWith(`${p}.`) || p.startsWith(`${path}.`));
+    if (isPlainObject(next)) {
+      if (!isPlainObject(target[key])) {
+        if (lockedBy && lockedBy[1] !== layer.id && target[key] !== void 0) {
+          issues.push({ skill, layer: layer.id, message: `"${path}" is locked by the ${lockedBy[1]} layer, so this skill's value is ignored.` });
+          continue;
+        }
+        target[key] = {};
+        delete sources[path];
+      }
+      mergeProfile(target[key], next, layer, skill, sources, locked, issues, path);
+      continue;
+    }
+    if (lockedBy && lockedBy[1] !== layer.id) {
+      issues.push({ skill, layer: layer.id, message: `"${path}" is locked by the ${lockedBy[1]} layer, so this skill's value is ignored.` });
+      continue;
+    }
+    target[key] = Array.isArray(next) ? structuredClone(next) : next;
+    for (const p of Object.keys(sources)) if (p.startsWith(`${path}.`)) delete sources[p];
+    sources[path] = layer.id;
+    if (layer.locked) locked.set(path, layer.id);
+  }
+}
+function createStyleResolver(options) {
+  const layers = [...options.layers];
+  const domains = [...options.domains];
+  const ids = /* @__PURE__ */ new Set();
+  for (const layer of layers) {
+    if (ids.has(layer.id)) throw new Error(`Two style layers are called "${layer.id}"; give each layer its own id.`);
+    ids.add(layer.id);
+  }
+  const domainIds = domains.map((d) => d.id);
+  const requireDomain = (id) => {
+    const domain = domains.find((d) => d.id === id);
+    if (!domain) throw new Error(`There is no house-style domain "${id}"; expected one of ${domainIds.map((d) => `"${d}"`).join(", ") || "(none registered)"}.`);
+    return domain;
+  };
+  async function load() {
+    const issues = [];
+    const entries = await Promise.all(layers.map(async (layer) => [...await layer.store.list()]));
+    const names = [...new Set(entries.flat().map((e) => e.name))];
+    const skills = [];
+    for (const name of names) {
+      if (!STYLE_SKILL_NAME.test(name)) {
+        issues.push({ skill: name, message: `"${name}" is not a valid skill name (lowercase letters, digits and hyphens, at most 64).` });
+        continue;
+      }
+      const copies = [];
+      for (let i = 0; i < layers.length; i++) {
+        const text = await layers[i].store.read(name, "SKILL.md");
+        if (text !== void 0) copies.push({ index: i, text });
+      }
+      if (!copies.length) continue;
+      const lockedCopy = copies.find((c) => layers[c.index].locked);
+      const winner = _nullishCoalesce(lockedCopy, () => ( copies[copies.length - 1]));
+      const layer = layers[winner.index];
+      const skillIssues = [];
+      for (const c of copies) {
+        if (c.index > winner.index) skillIssues.push(`The ${layers[c.index].id} layer's copy is ignored: the ${layer.id} layer is locked.`);
+      }
+      let enabled = true;
+      let order = 0;
+      for (let i = 0; i < layers.length; i++) {
+        const entry = entries[i].find((e) => e.name === name);
+        if (!entry) continue;
+        if (i === winner.index && entry.order !== void 0) order = entry.order;
+        if (entry.enabled === void 0) continue;
+        if (layer.required && i !== winner.index) {
+          if (entry.enabled === false) skillIssues.push(`The ${layers[i].id} layer cannot switch it off: the ${layer.id} layer requires it.`);
+          continue;
+        }
+        enabled = entry.enabled;
+      }
+      const { description = "", body } = _chunk7TD63DZPcjs.parseSkillFrontmatter.call(void 0, winner.text);
+      const named = parseStyleDomains(winner.text);
+      const applies = /* @__PURE__ */ new Set();
+      for (const d of _nullishCoalesce(named, () => ( domainIds))) {
+        if (domainIds.includes(d)) applies.add(d);
+        else skillIssues.push(`It names an unknown domain "${d}"; the domains here are ${domainIds.join(", ")}.`);
+      }
+      const profiles = /* @__PURE__ */ new Map();
+      for (const domain of domains) {
+        const raw = await layer.store.read(name, `${domain.id}.json`);
+        if (raw === void 0) continue;
+        const file = `${domain.id}.json`;
+        if (!applies.has(domain.id)) {
+          skillIssues.push(`${file} is left out: the skill's domains do not include ${domain.id}.`);
+          continue;
+        }
+        let parsed;
+        try {
+          parsed = _chunk2BSBFBOAcjs.stripPrototypeKeys.call(void 0, JSON.parse(raw));
+        } catch (error) {
+          skillIssues.push(`${file} is not valid JSON: ${error.message}`);
+          continue;
+        }
+        if (!isPlainObject(parsed)) {
+          skillIssues.push(`${file} must hold a JSON object.`);
+          continue;
+        }
+        const errors = [];
+        const resolved = resolveTokens(parsed, options.tokens, "", errors);
+        const { checks, ...rest } = resolved;
+        errors.push(..._chunkWOFXZ3XUcjs.validateJsonSchema.call(void 0, rest, domain.profileSchema).map((e) => `${e.path || "(profile)"}: ${e.message}`));
+        errors.push(...checkListErrors(checks, domain));
+        if (errors.length) {
+          skillIssues.push(`${file} is left out: ${errors.join(" ")}`);
+          continue;
+        }
+        profiles.set(domain.id, resolved);
+      }
+      skills.push({
+        info: {
+          name,
+          description,
+          layer: layer.id,
+          domains: [...applies],
+          profiles: [...profiles.keys()],
+          enabled,
+          order,
+          issues: skillIssues
+        },
+        layerIndex: winner.index,
+        body: body.trim(),
+        profiles,
+        applies
+      });
+    }
+    skills.sort((a, b) => a.layerIndex - b.layerIndex || a.info.order - b.info.order || a.info.name.localeCompare(b.info.name));
+    return { skills, issues };
+  }
+  async function resolve(domainId) {
+    requireDomain(domainId);
+    const { skills, issues: loadIssues } = await load();
+    const issues = [...loadIssues];
+    const profile = {};
+    const sources = {};
+    const locked = /* @__PURE__ */ new Map();
+    const applied = [];
+    for (const skill of skills) {
+      if (!skill.applies.has(domainId)) continue;
+      for (const message of skill.info.issues) issues.push({ skill: skill.info.name, layer: skill.info.layer, message });
+      if (!skill.info.enabled) continue;
+      applied.push({ name: skill.info.name, description: skill.info.description, layer: skill.info.layer, body: skill.body });
+      const own = skill.profiles.get(domainId);
+      if (own) mergeProfile(profile, own, layers[skill.layerIndex], skill.info.name, sources, locked, issues);
+    }
+    return { domain: domainId, skills: applied, profile, sources, issues };
+  }
+  async function winnerLayer(name) {
+    const copies = [];
+    for (let i = 0; i < layers.length; i++) if (await layers[i].store.read(name, "SKILL.md") !== void 0) copies.push(i);
+    if (!copies.length) return void 0;
+    return layers[_nullishCoalesce(copies.find((i) => layers[i].locked), () => ( copies[copies.length - 1]))];
+  }
+  return {
+    layers,
+    domains,
+    async list(opts = {}) {
+      if (opts.domain !== void 0) requireDomain(opts.domain);
+      const { skills } = await load();
+      return skills.filter((s) => opts.domain === void 0 || s.applies.has(opts.domain)).map((s) => s.info);
+    },
+    resolve,
+    async readFile(name, file) {
+      const layer = await winnerLayer(name);
+      return layer ? layer.store.read(name, file) : void 0;
+    },
+    async files(name) {
+      const layer = await winnerLayer(name);
+      return layer ? [...await layer.store.files(name)] : void 0;
+    },
+    async check(domainId, state) {
+      const domain = requireDomain(domainId);
+      const style = await resolve(domainId);
+      return { ...runStyleChecks(domain, state, style), style };
+    },
+    subscribe(listener) {
+      const offs = [...layers.map((l) => _optionalChain([l, 'access', _14 => _14.store, 'access', _15 => _15.subscribe, 'optionalCall', _16 => _16(listener)])), _optionalChain([options, 'access', _17 => _17.tokens, 'optionalAccess', _18 => _18.subscribe, 'optionalCall', _19 => _19(listener)])];
+      return () => offs.forEach((off) => _optionalChain([off, 'optionalCall', _20 => _20()]));
+    }
+  };
+}
+function runStyleChecks(domain, state, style) {
+  const report = { findings: [], ran: [], skipped: [] };
+  const list = Array.isArray(style.profile.checks) ? style.profile.checks : [];
+  const layer = style.sources.checks;
+  for (const entry of list) {
+    const id = typeof entry === "string" ? entry : isPlainObject(entry) && typeof entry.id === "string" ? entry.id : void 0;
+    if (!id) continue;
+    const check = domain.checks.find((c) => c.id === id);
+    if (!check) {
+      report.skipped.push({ check: id, reason: `There is no "${id}" check for ${domain.id}; it has ${domain.checks.map((c) => `"${c.id}"`).join(", ")}.` });
+      continue;
+    }
+    const { id: _id, ...options } = isPlainObject(entry) ? entry : { id };
+    try {
+      for (const f of check.run(state, style.profile, options)) report.findings.push({ ...f, check: id, ...layer ? { layer } : {} });
+      report.ran.push(id);
+    } catch (error) {
+      report.skipped.push({ check: id, reason: `The check could not run: ${error.message}` });
+    }
+  }
+  return report;
+}
+var escapeAttribute = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+function renderStyle(style) {
+  if (!style.skills.length) return `No house style applies to ${style.domain}.`;
+  const blocks = style.skills.map((s) => {
+    const body = s.body.replace(/<(\/?)style_skill/gi, "&lt;$1style_skill");
+    return `<style_skill name="${escapeAttribute(s.name)}" layer="${escapeAttribute(s.layer)}">
+${body}
+</style_skill>`;
+  });
+  const profile = Object.keys(style.profile).length ? `
+
+Merged ${style.domain} profile:
+${JSON.stringify(style.profile, null, 2)}` : "";
+  return `${blocks.join("\n\n")}${profile}`;
+}
+
+
+
+
+
+
+
+exports.parseStyleDomains = parseStyleDomains; exports.memoryStyleStore = memoryStyleStore; exports.createStyleResolver = createStyleResolver; exports.runStyleChecks = runStyleChecks; exports.renderStyle = renderStyle;