@diagrammo/dgmo 0.46.0 → 0.48.0

package/dist/chunk-QLCCJEJI.js

@@ -0,0 +1,253 @@
+import {
+  stripQuotes,
+  tokenizeQuoteAware
+} from "./chunk-Y3J7VR52.js";
+import {
+  CATEGORICAL_COLOR_ORDER,
+  RECOGNIZED_COLOR_NAMES,
+  resolveColor
+} from "./chunk-TLVIHFRO.js";
+
+// src/utils/tag-groups.ts
+function tagAttrKey(name) {
+  return name.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function stripDefaultModifier(text) {
+  if (/\bdefault\s*$/.test(text)) {
+    return { text: text.replace(/\s+default\s*$/, "").trim(), isDefault: true };
+  }
+  return { text, isDefault: false };
+}
+var AUTO_TAG_COLOR_SENTINEL = "";
+var autoTagColorCycle = CATEGORICAL_COLOR_ORDER;
+function assignAutoTagColors(group, palette) {
+  const entries = group.entries;
+  const explicitHexes = /* @__PURE__ */ new Set();
+  let hasSentinel = false;
+  for (const e of entries) {
+    if (e.color === AUTO_TAG_COLOR_SENTINEL) hasSentinel = true;
+    else explicitHexes.add(e.color.toLowerCase());
+  }
+  if (!hasSentinel) return;
+  const cycle = autoTagColorCycle.map((name) => ({
+    name,
+    hex: resolveColor(name, palette) ?? name
+  }));
+  const autoHexes = /* @__PURE__ */ new Set();
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    if (e.color !== AUTO_TAG_COLOR_SENTINEL) continue;
+    let chosen = cycle.find(
+      (c) => !explicitHexes.has(c.hex.toLowerCase()) && !autoHexes.has(c.hex.toLowerCase())
+    );
+    if (!chosen) {
+      chosen = cycle[autoHexes.size % cycle.length];
+    }
+    autoHexes.add(chosen.hex.toLowerCase());
+    entries[i] = { ...e, color: chosen.hex };
+  }
+}
+function finalizeAutoTagColors(groups, palette) {
+  for (const g of groups) assignAutoTagColors(g, palette);
+}
+var TAG_BLOCK_NOCOLON_RE = /^tag\s+/i;
+function isAliasToken(token) {
+  return /^[A-Za-z][A-Za-z0-9_]{0,11}$/.test(token);
+}
+function isTagBlockHeading(trimmed) {
+  return TAG_BLOCK_NOCOLON_RE.test(trimmed);
+}
+function parseTagDeclaration(line) {
+  if (!TAG_BLOCK_NOCOLON_RE.test(line)) return null;
+  const afterTag = line.replace(/^tag\s+/i, "");
+  if (!afterTag.trim()) return null;
+  const tokens = tokenizeQuoteAware(afterTag);
+  if (tokens.length === 0) return null;
+  let name;
+  let alias;
+  let inlineValues;
+  let colorHint;
+  let restStartIdx;
+  let valueStart = tokens.length;
+  for (let i = 1; i < tokens.length; i++) {
+    if (tokens[i].includes(",")) {
+      valueStart = i;
+      break;
+    }
+  }
+  let keywordIdx = -1;
+  for (let i = 1; i < valueStart; i++) {
+    if (tokens[i].toLowerCase() === "as") {
+      keywordIdx = i;
+      break;
+    }
+  }
+  if (keywordIdx > 0 && keywordIdx + 1 < tokens.length && isAliasToken(tokens[keywordIdx + 1])) {
+    name = tokens.slice(0, keywordIdx).map((t) => stripQuotes(t)).join(" ");
+    alias = tokens[keywordIdx + 1];
+    restStartIdx = keywordIdx + 2;
+  } else {
+    let prefixEnd = valueStart;
+    if (valueStart < tokens.length) {
+      const isColorWord = (s) => RECOGNIZED_COLOR_NAMES.includes(s);
+      const lastBeforeComma = tokens[valueStart].replace(/,$/, "");
+      prefixEnd = isColorWord(lastBeforeComma) ? valueStart - 1 : valueStart;
+      if (prefixEnd < 1) prefixEnd = 1;
+    }
+    name = tokens.slice(0, prefixEnd).map((t) => stripQuotes(t)).join(" ");
+    restStartIdx = prefixEnd;
+  }
+  if (restStartIdx < tokens.length) {
+    const valueStr = tokens.slice(restStartIdx).join(" ");
+    inlineValues = valueStr.split(",").map((v) => v.trim()).filter(Boolean);
+  }
+  if (!inlineValues || inlineValues.length === 0) {
+    const lastSpaceIdx = name.lastIndexOf(" ");
+    if (lastSpaceIdx > 0) {
+      const trailing = name.substring(lastSpaceIdx + 1);
+      if (RECOGNIZED_COLOR_NAMES.includes(trailing)) {
+        colorHint = trailing;
+        name = name.substring(0, lastSpaceIdx).trimEnd();
+      }
+    }
+  }
+  return {
+    name,
+    alias,
+    colorHint,
+    inlineValues: inlineValues && inlineValues.length > 0 ? inlineValues : void 0
+  };
+}
+function resolveTagColor(metadata, tagGroups, activeGroupName, isContainer) {
+  if (!activeGroupName) return void 0;
+  const group = tagGroups.find(
+    (g) => tagAttrKey(g.name) === tagAttrKey(activeGroupName)
+  );
+  if (!group) return void 0;
+  const metaValue = metadata[tagAttrKey(group.name)] ?? (isContainer ? void 0 : group.defaultValue);
+  if (!metaValue) return "#999999";
+  return group.entries.find((e) => e.value.toLowerCase() === metaValue.toLowerCase())?.color ?? "#999999";
+}
+function validateTagValues(entities, tagGroups, pushWarning, suggestFn) {
+  if (tagGroups.length === 0) return;
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const g of tagGroups) groupMap.set(tagAttrKey(g.name), g);
+  for (const entity of entities) {
+    for (const [key, value] of Object.entries(entity.metadata)) {
+      const group = groupMap.get(key);
+      if (!group) continue;
+      const match = group.entries.some(
+        (e) => e.value.toLowerCase() === value.toLowerCase()
+      );
+      if (!match) {
+        const valueLower = value.toLowerCase();
+        const isPrefix = group.entries.some(
+          (e) => e.value.toLowerCase().startsWith(valueLower)
+        );
+        if (!isPrefix) {
+          const defined = group.entries.map((e) => e.value);
+          let msg = `Unknown value '${value}' for tag group '${group.name}' \u2014 use one of: ${defined.join(", ")}`;
+          const hint = suggestFn?.(value, defined);
+          if (hint) {
+            msg += `. ${hint}`;
+          }
+          pushWarning(entity.lineNumber, msg);
+        }
+      }
+    }
+  }
+}
+var VALID_TAG_IDENT_RE = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+function validateTagGroupNames(tagGroups, pushWarning, pushError) {
+  const report = pushError ?? pushWarning;
+  for (const group of tagGroups) {
+    if (group.name.toLowerCase() === "none") {
+      pushWarning(
+        group.lineNumber,
+        `'none' is a reserved keyword and cannot be used as a tag group name`
+      );
+    }
+    if (!VALID_TAG_IDENT_RE.test(tagAttrKey(group.name))) {
+      report(
+        group.lineNumber,
+        `Tag group name "${group.name}" can't form a valid key \u2014 use letters, digits, underscore, or hyphen, and quote a multi-word name (e.g. tag "Trust Zone" as tz)`
+      );
+    }
+    if (group.alias != null && !VALID_TAG_IDENT_RE.test(group.alias)) {
+      report(
+        group.lineNumber,
+        `Tag group alias "${group.alias}" contains invalid characters \u2014 use a single identifier (letters, digits, underscore, hyphen)`
+      );
+    }
+  }
+}
+function cascadeTagMetadata(roots, tagGroups) {
+  const keys = tagGroups.map((g) => tagAttrKey(g.name));
+  if (keys.length === 0) return;
+  const walk = (node, inherited) => {
+    const childInherited = { ...inherited };
+    for (const key of keys) {
+      const own = node.metadata[key];
+      if (own) {
+        childInherited[key] = own;
+      } else if (inherited[key]) {
+        node.metadata[key] = inherited[key];
+      }
+    }
+    for (const child of node.children) walk(child, childInherited);
+  };
+  for (const root of roots) walk(root, {});
+}
+function injectDefaultTagMetadata(entities, tagGroups, skip) {
+  const defaults = [];
+  for (const group of tagGroups) {
+    if (group.defaultValue) {
+      defaults.push({
+        key: tagAttrKey(group.name),
+        value: group.defaultValue
+      });
+    }
+  }
+  if (defaults.length === 0) return;
+  for (const entity of entities) {
+    if (skip?.(entity)) continue;
+    for (const { key, value } of defaults) {
+      if (!(key in entity.metadata)) {
+        entity.metadata[key] = value;
+      }
+    }
+  }
+}
+function resolveActiveTagGroup(tagGroups, explicitActiveTag, programmaticOverride) {
+  if (programmaticOverride !== void 0) {
+    if (!programmaticOverride) return null;
+    if (programmaticOverride.toLowerCase() === "none") return null;
+    return programmaticOverride;
+  }
+  if (explicitActiveTag) {
+    if (explicitActiveTag.toLowerCase() === "none") return null;
+    return explicitActiveTag;
+  }
+  if (tagGroups.length > 0) return tagGroups[0].name;
+  return null;
+}
+function matchTagBlockHeading(trimmed) {
+  return parseTagDeclaration(trimmed);
+}
+
+export {
+  tagAttrKey,
+  stripDefaultModifier,
+  AUTO_TAG_COLOR_SENTINEL,
+  autoTagColorCycle,
+  finalizeAutoTagColors,
+  isTagBlockHeading,
+  resolveTagColor,
+  validateTagValues,
+  validateTagGroupNames,
+  cascadeTagMetadata,
+  injectDefaultTagMetadata,
+  resolveActiveTagGroup,
+  matchTagBlockHeading
+};
+//# sourceMappingURL=chunk-QLCCJEJI.js.map

package/dist/chunk-QOOUC2J5.js

@@ -0,0 +1,52 @@
+import {
+  measureText,
+  truncateText
+} from "./chunk-WCT3NYCV.js";
+
+// src/utils/legend-constants.ts
+var LEGEND_HEIGHT = 28;
+var LEGEND_PILL_PAD = 16;
+var LEGEND_PILL_FONT_SIZE = 11;
+var LEGEND_CAPSULE_PAD = 4;
+var LEGEND_DOT_R = 4;
+var LEGEND_ENTRY_FONT_SIZE = 10;
+var LEGEND_ENTRY_DOT_GAP = 4;
+var LEGEND_ENTRY_TRAIL = 8;
+var LEGEND_GROUP_GAP = 12;
+var LEGEND_EYE_SIZE = 14;
+var LEGEND_EYE_GAP = 6;
+var LEGEND_ICON_W = 20;
+var LEGEND_MAX_ENTRY_ROWS = 3;
+var measureLegendText = measureText;
+var truncateLegendText = truncateText;
+var EYE_OPEN_PATH = "M1 7s2.5-5 6-5 6 5 6 5-2.5 5-6 5-6-5-6-5z M7 9.5a2.5 2.5 0 1 0 0-5 2.5 2.5 0 0 0 0 5z";
+var EYE_CLOSED_PATH = "M2.5 2.5l9 9 M1.5 7s2.2-4 5.5-4c1.2 0 2.2.5 3 1.1 M12.5 7s-2.2 4-5.5 4c-1.2 0-2.2-.5-3-1.1";
+var CONTROLS_ICON_PATH = "M5.6 1.7L8.4 1.7L7.9 3.6L9.5 4.5L10.9 3.1L12.3 5.6L10.4 6.1L10.4 7.9L12.3 8.4L10.9 10.9L9.5 9.5L7.9 10.4L8.4 12.3L5.6 12.3L6.1 10.4L4.5 9.5L3.1 10.9L1.7 8.4L3.6 7.9L3.6 6.1L1.7 5.6L3.1 3.1L4.5 4.5L6.1 3.6ZM5 7a2 2 0 1 0 4 0a2 2 0 1 0-4 0Z";
+var LEGEND_TOGGLE_DOT_R = LEGEND_DOT_R;
+var LEGEND_TOGGLE_OFF_OPACITY = 0.4;
+var LEGEND_GEAR_PILL_W = 14 + LEGEND_PILL_PAD;
+
+export {
+  LEGEND_HEIGHT,
+  LEGEND_PILL_PAD,
+  LEGEND_PILL_FONT_SIZE,
+  LEGEND_CAPSULE_PAD,
+  LEGEND_DOT_R,
+  LEGEND_ENTRY_FONT_SIZE,
+  LEGEND_ENTRY_DOT_GAP,
+  LEGEND_ENTRY_TRAIL,
+  LEGEND_GROUP_GAP,
+  LEGEND_EYE_SIZE,
+  LEGEND_EYE_GAP,
+  LEGEND_ICON_W,
+  LEGEND_MAX_ENTRY_ROWS,
+  measureLegendText,
+  truncateLegendText,
+  EYE_OPEN_PATH,
+  EYE_CLOSED_PATH,
+  CONTROLS_ICON_PATH,
+  LEGEND_TOGGLE_DOT_R,
+  LEGEND_TOGGLE_OFF_OPACITY,
+  LEGEND_GEAR_PILL_W
+};
+//# sourceMappingURL=chunk-QOOUC2J5.js.map