@pixerate/editor 0.271.0 → 0.272.1

package/dist/chunk-5UGRMVNE.js

@@ -0,0 +1,328 @@
+import {
+  parseSkillFrontmatter
+} from "./chunk-K4BGRCSH.js";
+import {
+  validateJsonSchema
+} from "./chunk-V2ZCJRDM.js";
+import {
+  isUnsafeJsonKey,
+  stripPrototypeKeys
+} from "./chunk-HF5QZS7Z.js";
+
+// 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 = match?.[1].split(/\r?\n/).find((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) => files.get(name)?.get(file),
+    files: (name) => [...files.get(name)?.keys() ?? []].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 = check.optionsSchema ?? { type: "object", properties: {}, additionalProperties: false };
+    for (const e of validateJsonSchema(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 (isUnsafeJsonKey(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 = 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 } = parseSkillFrontmatter(winner.text);
+      const named = parseStyleDomains(winner.text);
+      const applies = /* @__PURE__ */ new Set();
+      for (const d of 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 = stripPrototypeKeys(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(...validateJsonSchema(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[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) => l.store.subscribe?.(listener)), options.tokens?.subscribe?.(listener)];
+      return () => offs.forEach((off) => off?.());
+    }
+  };
+}
+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}`;
+}
+
+export {
+  parseStyleDomains,
+  memoryStyleStore,
+  createStyleResolver,
+  runStyleChecks,
+  renderStyle
+};

package/dist/{chunk-X4FTNFIA.js → chunk-7MGPW2OV.js}

@@ -5,7 +5,7 @@ import {
   chartToMermaid,
   describeChart,
   layoutSparkline
-} from "./chunk-NMZQMPFZ.js";
+} from "./chunk-4LZQO5Y7.js";
 import {
   layoutChart
 } from "./chunk-C2WEIEUB.js";

package/dist/{chunk-BPJSI4NT.cjs → chunk-7W2EQQBP.cjs}

@@ -1,6 +1,6 @@
 "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 _chunkEU2ZZA6Lcjs = require('./chunk-EU2ZZA6L.cjs');
+var _chunkGHGBIAWQcjs = require('./chunk-GHGBIAWQ.cjs');
 
 
 var _chunkJBZRVLXVcjs = require('./chunk-JBZRVLXV.cjs');
@@ -44,7 +44,7 @@ function brushPreviewStrength(brush) {
 }
 var over = (fg, bg, alpha) => ({ r: fg.r * alpha + bg.r * (1 - alpha), g: fg.g * alpha + bg.g * (1 - alpha), b: fg.b * alpha + bg.b * (1 - alpha), a: 1 });
 function brushPreviewColours(brush, options = {}) {
-  const profile = _nullishCoalesce(options.profile, () => ( _chunkEU2ZZA6Lcjs.PAINT_PROFILE));
+  const profile = _nullishCoalesce(options.profile, () => ( _chunkGHGBIAWQcjs.PAINT_PROFILE));
   let background = profile.light === "full" && brushPreviewsOnDark(brush) ? BRUSH_PREVIEW_DARK_PAPER : hexOf(_nullishCoalesce(options.paper, () => ( "#ffffff")));
   if (!options.keepPaper && brush.tip.blend === "multiply" && _chunk5UEFBM2Mcjs.relativeLuminance.call(void 0, _chunk5UEFBM2Mcjs.parseColor.call(void 0, background)) < 0.18) background = "#ffffff";
   const bg = _chunk5UEFBM2Mcjs.parseColor.call(void 0, background);

package/dist/{chunk-DGITFN73.cjs → chunk-BWJBZAUE.cjs}

@@ -5,7 +5,7 @@
 
 
 
-var _chunkGSLOH2INcjs = require('./chunk-GSLOH2IN.cjs');
+var _chunkVF6ODSYXcjs = require('./chunk-VF6ODSYX.cjs');
 
 
 var _chunkMDLEGVENcjs = require('./chunk-MDLEGVEN.cjs');
@@ -1457,7 +1457,7 @@ var ChartNodeView = (_class = class {
     this.dom.contentEditable = "false";
     this.syncAttributes();
     this.key = specKey(this.node.attrs.spec);
-    this.controller = new (0, _chunkGSLOH2INcjs.ChartController)({ spec: this.node.attrs.spec });
+    this.controller = new (0, _chunkVF6ODSYXcjs.ChartController)({ spec: this.node.attrs.spec });
     this.unsubscribe = this.controller.subscribe((state) => {
       if (!state.gesture) this.writeBack();
     });
@@ -1717,9 +1717,9 @@ function staticChartSvg(node, options) {
   const width = _nullishCoalesce(node.attrs.width, () => ( options.defaultWidth));
   const height = _nullishCoalesce(node.attrs.height, () => ( options.defaultHeight));
   const scene = _chunkMDLEGVENcjs.layoutChart.call(void 0, spec, { width, height, theme: options.theme, selection: null });
-  return _chunkGSLOH2INcjs.chartSceneToDomSpec.call(void 0, scene, {
+  return _chunkVF6ODSYXcjs.chartSceneToDomSpec.call(void 0, scene, {
     ariaLabel: spec.title || "Chart",
-    description: _chunkGSLOH2INcjs.describeChart.call(void 0, spec),
+    description: _chunkVF6ODSYXcjs.describeChart.call(void 0, spec),
     attrs: { style: "max-width: 100%; height: auto; display: block" }
   });
 }
@@ -1787,7 +1787,7 @@ var Chart = _core.Node.create({
           const code = element.querySelector("code");
           const language = _nullishCoalesce(_nullishCoalesce(_optionalChain([code, 'optionalAccess', _47 => _47.getAttribute, 'call', _48 => _48("class")]), () => ( element.getAttribute("data-language"))), () => ( ""));
           if (!/(?:^|\s)language-mermaid(?:\s|$)/.test(language) && language !== "mermaid") return false;
-          const result = _chunkGSLOH2INcjs.chartFromMermaid.call(void 0, _nullishCoalesce((_nullishCoalesce(code, () => ( element))).textContent, () => ( "")));
+          const result = _chunkVF6ODSYXcjs.chartFromMermaid.call(void 0, _nullishCoalesce((_nullishCoalesce(code, () => ( element))).textContent, () => ( "")));
           return result.family ? { spec: result.spec } : false;
         }
       }
@@ -1811,7 +1811,7 @@ var Chart = _core.Node.create({
     return {
       markdown: {
         serialize(state, node) {
-          const text = _chunkGSLOH2INcjs.chartToMermaid.call(void 0, node.attrs.spec);
+          const text = _chunkVF6ODSYXcjs.chartToMermaid.call(void 0, node.attrs.spec);
           const fence = "`".repeat(Math.max(3, longestBacktickRun(text) + 1));
           state.write(`${fence}mermaid
 `);
@@ -1951,14 +1951,14 @@ var Sparkline = _core.Node.create({
     return [{ tag: 'span[data-type="sparkline"]', priority: 60 }];
   },
   renderHTML({ node, HTMLAttributes }) {
-    const scene = _chunkGSLOH2INcjs.layoutSparkline.call(void 0, node.attrs.values, {
+    const scene = _chunkVF6ODSYXcjs.layoutSparkline.call(void 0, node.attrs.values, {
       kind: node.attrs.kind,
       width: node.attrs.width,
       height: node.attrs.height,
       color: _nullishCoalesce(node.attrs.color, () => ( this.options.color)),
       negativeColor: this.options.negativeColor
     });
-    const svg = _chunkGSLOH2INcjs.chartSceneToDomSpec.call(void 0, scene, {
+    const svg = _chunkVF6ODSYXcjs.chartSceneToDomSpec.call(void 0, scene, {
       ariaLabel: sparklineLabel(node),
       attrs: { style: "display: inline-block; vertical-align: middle" }
     });