origam 2.2.1 → 2.5.0

package/dist/src/utils/Code/parse-highlight-lines.util.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parse the `highlight-lines` prop of `<OrigamCode>` into a Set of 1-based
+ * line numbers.
+ *
+ * Accepts:
+ *   - an array of numbers, returned as-is (deduplicated, sorted) so the
+ *     consumer can build a Set with a single allocation;
+ *   - a comma- and/or range-separated string ("1", "1,3", "1-3",
+ *     "1,3-5,7"). Whitespace inside the string is ignored. Negative
+ *     values, zeros and NaN are dropped silently — the surface is meant
+ *     for prose-style author input, not validated runtime data.
+ *
+ * Returns `[]` when the input is `null`, `undefined`, an empty string or
+ * an empty array. The caller decides whether to skip the highlight pass
+ * altogether based on `result.length === 0`.
+ *
+ * Examples:
+ *   parseHighlightLines('1,3-5,7') → [1, 3, 4, 5, 7]
+ *   parseHighlightLines([2, 5])    → [2, 5]
+ *   parseHighlightLines('  2 , 5 - 7 ') → [2, 5, 6, 7]
+ *   parseHighlightLines('foo')     → []
+ *   parseHighlightLines(null)      → []
+ */
+export declare function parseHighlightLines(input: number[] | string | null | undefined): number[];

package/dist/src/utils/Code/parse-highlight-lines.util.js

@@ -0,0 +1,28 @@
+export function parseHighlightLines(input) {
+  if (input == null) return [];
+  if (Array.isArray(input)) {
+    const cleaned = input.filter((n) => typeof n === "number" && Number.isFinite(n) && n >= 1).map((n) => Math.floor(n));
+    return Array.from(new Set(cleaned)).sort((a, b) => a - b);
+  }
+  if (typeof input !== "string") return [];
+  const trimmed = input.trim();
+  if (!trimmed) return [];
+  const out = /* @__PURE__ */ new Set();
+  for (const rawSegment of trimmed.split(",")) {
+    const segment = rawSegment.trim();
+    if (!segment) continue;
+    if (segment.includes("-")) {
+      const [rawStart, rawEnd] = segment.split("-").map((s) => s.trim());
+      const start = Number.parseInt(rawStart, 10);
+      const end = Number.parseInt(rawEnd, 10);
+      if (!Number.isFinite(start) || !Number.isFinite(end)) continue;
+      if (start < 1 || end < 1) continue;
+      const [lo, hi] = start <= end ? [start, end] : [end, start];
+      for (let i = lo; i <= hi; i++) out.add(i);
+      continue;
+    }
+    const single = Number.parseInt(segment, 10);
+    if (Number.isFinite(single) && single >= 1) out.add(single);
+  }
+  return Array.from(out).sort((a, b) => a - b);
+}

package/dist/src/utils/CommandPalette/fuzzy-match.util.cjs

@@ -0,0 +1,84 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.fuzzyMatch = fuzzyMatch;
+const SCORE_CONSECUTIVE = 4;
+const SCORE_FIRST_LABEL_POS = 30;
+const SCORE_LABEL_PREFIX = 50;
+const lower = value => value.toLowerCase();
+const isSubsequence = (query, haystack) => {
+  if (query.length === 0) return true;
+  if (haystack.length === 0) return false;
+  let qi = 0;
+  for (let hi = 0; hi < haystack.length; hi++) {
+    if (haystack.charAt(hi) === query.charAt(qi)) {
+      qi += 1;
+      if (qi === query.length) return true;
+    }
+  }
+  return false;
+};
+const scoreOne = (query, label, haystack) => {
+  if (query.length === 0) return 0;
+  let qi = 0;
+  let consecutive = 0;
+  let bestConsecutive = 0;
+  let lastMatchIdx = -1;
+  for (let hi = 0; hi < haystack.length; hi++) {
+    if (haystack.charAt(hi) === query.charAt(qi)) {
+      if (hi === lastMatchIdx + 1) {
+        consecutive += 1;
+      } else {
+        consecutive = 1;
+      }
+      if (consecutive > bestConsecutive) bestConsecutive = consecutive;
+      lastMatchIdx = hi;
+      qi += 1;
+      if (qi === query.length) break;
+    }
+  }
+  let score = bestConsecutive * SCORE_CONSECUTIVE;
+  const firstLabelHit = label.indexOf(query.charAt(0));
+  if (firstLabelHit !== -1) {
+    score += Math.max(0, SCORE_FIRST_LABEL_POS - firstLabelHit);
+    if (label.startsWith(query)) {
+      score += SCORE_LABEL_PREFIX;
+    }
+  }
+  return score;
+};
+function fuzzyMatch(items, query, getHaystack) {
+  const q = lower(query.trim());
+  if (q.length === 0) {
+    return items.map(item => ({
+      item,
+      score: 0
+    }));
+  }
+  const matched = [];
+  for (let i = 0; i < items.length; i++) {
+    const {
+      label,
+      haystack
+    } = getHaystack(items[i]);
+    const lcLabel = lower(label);
+    const lcHaystack = lower(haystack);
+    if (!isSubsequence(q, lcHaystack)) continue;
+    const score = scoreOne(q, lcLabel, lcHaystack);
+    matched.push({
+      item: items[i],
+      score,
+      idx: i
+    });
+  }
+  matched.sort((a, b) => b.score - a.score || a.idx - b.idx);
+  return matched.map(({
+    item,
+    score
+  }) => ({
+    item,
+    score
+  }));
+}

package/dist/src/utils/CommandPalette/fuzzy-match.util.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Subsequence-based fuzzy matcher used by `OrigamCommandPalette`.
+ *
+ * Why not `fuse.js` / `match-sorter`?
+ *
+ * The palette only ranks a small (~hundreds) list of registered commands
+ * whose haystacks are short labels + a handful of keywords. A subsequence
+ * matcher with a tiny scoring heuristic gives us:
+ *
+ *   - zero runtime dependency,
+ *   - deterministic O(haystack-length) ranking,
+ *   - predictable behaviour for unit tests.
+ *
+ * Algorithm — for each command:
+ *
+ *   1. Build the haystack as `label + ' ' + (keywords ?? []).join(' ') +
+ *      ' ' + (description ?? '')`, all lowercased.
+ *   2. Walk the lowercased query character-by-character against the
+ *      haystack. If we cannot find every query character in order, the
+ *      command does not match.
+ *   3. Score = consecutive-run weight + label-position bonus + label-prefix
+ *      bonus. Higher is better. Ties are broken by registration order
+ *      (caller controlled).
+ *
+ * The function is pure — no side effects, no Vue reactivity. Safe to call
+ * inside a `computed`.
+ */
+/**
+ * Output of `fuzzyMatch` — the matched item carries its score so callers
+ * can short-circuit a re-sort on cached input.
+ */
+export interface IFuzzyMatchResult<T> {
+    /** Original item passed in. */
+    item: T;
+    /** Higher = better fit. `0` is the floor for a successful match. */
+    score: number;
+}
+/**
+ * Filter `items` to those whose composite haystack contains the
+ * query as a subsequence, and rank them by score (descending).
+ *
+ * - When `query` is empty, returns every item with `score=0` in the
+ *   input order (stable). The caller is expected to handle grouping
+ *   on top of this.
+ * - The comparator is `(b.score - a.score)`; equal scores fall back
+ *   to the original index so order is deterministic.
+ */
+export declare function fuzzyMatch<T>(items: ReadonlyArray<T>, query: string, getHaystack: (item: T) => {
+    label: string;
+    haystack: string;
+}): Array<IFuzzyMatchResult<T>>;

package/dist/src/utils/CommandPalette/fuzzy-match.util.js

@@ -0,0 +1,62 @@
+const SCORE_CONSECUTIVE = 4;
+const SCORE_FIRST_LABEL_POS = 30;
+const SCORE_LABEL_PREFIX = 50;
+const lower = (value) => value.toLowerCase();
+const isSubsequence = (query, haystack) => {
+  if (query.length === 0) return true;
+  if (haystack.length === 0) return false;
+  let qi = 0;
+  for (let hi = 0; hi < haystack.length; hi++) {
+    if (haystack.charAt(hi) === query.charAt(qi)) {
+      qi += 1;
+      if (qi === query.length) return true;
+    }
+  }
+  return false;
+};
+const scoreOne = (query, label, haystack) => {
+  if (query.length === 0) return 0;
+  let qi = 0;
+  let consecutive = 0;
+  let bestConsecutive = 0;
+  let lastMatchIdx = -1;
+  for (let hi = 0; hi < haystack.length; hi++) {
+    if (haystack.charAt(hi) === query.charAt(qi)) {
+      if (hi === lastMatchIdx + 1) {
+        consecutive += 1;
+      } else {
+        consecutive = 1;
+      }
+      if (consecutive > bestConsecutive) bestConsecutive = consecutive;
+      lastMatchIdx = hi;
+      qi += 1;
+      if (qi === query.length) break;
+    }
+  }
+  let score = bestConsecutive * SCORE_CONSECUTIVE;
+  const firstLabelHit = label.indexOf(query.charAt(0));
+  if (firstLabelHit !== -1) {
+    score += Math.max(0, SCORE_FIRST_LABEL_POS - firstLabelHit);
+    if (label.startsWith(query)) {
+      score += SCORE_LABEL_PREFIX;
+    }
+  }
+  return score;
+};
+export function fuzzyMatch(items, query, getHaystack) {
+  const q = lower(query.trim());
+  if (q.length === 0) {
+    return items.map((item) => ({ item, score: 0 }));
+  }
+  const matched = [];
+  for (let i = 0; i < items.length; i++) {
+    const { label, haystack } = getHaystack(items[i]);
+    const lcLabel = lower(label);
+    const lcHaystack = lower(haystack);
+    if (!isSubsequence(q, lcHaystack)) continue;
+    const score = scoreOne(q, lcLabel, lcHaystack);
+    matched.push({ item: items[i], score, idx: i });
+  }
+  matched.sort((a, b) => b.score - a.score || a.idx - b.idx);
+  return matched.map(({ item, score }) => ({ item, score }));
+}

package/dist/src/utils/Commons/gradient.util.cjs

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gradientFromObject = gradientFromObject;
+exports.isGradient = isGradient;
+exports.resolveGradient = resolveGradient;
+var _colorUtil = require("./color.util.ts");
+const GRADIENT_FN_RE = /^\s*(repeating-)?(linear|radial|conic)-gradient\s*\(/i;
+const PRESET_PREFIX = "gradient-";
+function isGradientString(value) {
+  return GRADIENT_FN_RE.test(value);
+}
+function isPresetString(value) {
+  return value.startsWith(PRESET_PREFIX) && value.length > PRESET_PREFIX.length;
+}
+function isGradientObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const obj = value;
+  const hasShortForm = typeof obj.from === "string" && typeof obj.to === "string";
+  const hasStops = Array.isArray(obj.stops) && obj.stops.length >= 2;
+  return hasShortForm || hasStops;
+}
+function isGradient(value) {
+  if (typeof value === "string") {
+    return isGradientString(value) || isPresetString(value);
+  }
+  return isGradientObject(value);
+}
+function resolveStopColor(color) {
+  if ((0, _colorUtil.isIntent)(color)) {
+    return `var(--origam-color__${(0, _colorUtil.intentTokenBase)(color)}---bg)`;
+  }
+  return color;
+}
+function resolveDirection(type, direction) {
+  if (direction === void 0 || direction === null || direction === "") {
+    if (type === "radial") return "circle at center";
+    if (type === "conic") return "from 0deg at 50% 50%";
+    return "135deg";
+  }
+  if (typeof direction === "number") return `${direction}deg`;
+  return direction;
+}
+function gradientFromObject(g) {
+  const type = g.type ?? "linear";
+  const directionPart = resolveDirection(type, g.direction);
+  let stopsPart = "";
+  if (Array.isArray(g.stops) && g.stops.length >= 2) {
+    stopsPart = g.stops.map(s => `${resolveStopColor(s.color)} ${s.position}%`).join(", ");
+  } else if (g.from && g.to) {
+    const parts = [resolveStopColor(g.from)];
+    if (g.via) parts.push(resolveStopColor(g.via));
+    parts.push(resolveStopColor(g.to));
+    stopsPart = parts.join(", ");
+  } else {
+    stopsPart = "transparent, transparent";
+  }
+  return `${type}-gradient(${directionPart}, ${stopsPart})`;
+}
+function resolveGradient(value) {
+  if (value === null || value === void 0 || value === false) return "";
+  if (typeof value === "string") {
+    if (isGradientString(value)) return value;
+    if (isPresetString(value)) {
+      const slug = value.slice(PRESET_PREFIX.length);
+      return `var(--origam-gradient---${slug})`;
+    }
+    return "";
+  }
+  if (isGradientObject(value)) return gradientFromObject(value);
+  return "";
+}

package/dist/src/utils/Commons/gradient.util.d.ts

@@ -0,0 +1,36 @@
+import type { IGradient } from '../../interfaces/Commons/gradient.interface';
+import type { TColor } from '../../types';
+/**
+ * Type guard: does `value` carry gradient semantics?
+ *
+ *   - Direct CSS function string (`linear-gradient(...)`, …).
+ *   - Preset name (`gradient-sunset`).
+ *   - {@link IGradient} object.
+ *
+ * Returns `false` for intents, hex colors, transparent, null, undefined.
+ */
+export declare function isGradient(value: unknown): boolean;
+/**
+ * Build the CSS gradient function call from a structured {@link IGradient}
+ * descriptor. Pure — no side effects, no warning.
+ *
+ *   { from: 'primary', to: 'success' }
+ *     → 'linear-gradient(135deg, var(--origam-color__action--primary---bg), var(--origam-color__feedback--success---bg))'
+ *
+ *   { type: 'radial', stops: [{ color: '#fff', position: 0 }, { color: '#000', position: 100 }] }
+ *     → 'radial-gradient(circle at center, #fff 0%, #000 100%)'
+ */
+export declare function gradientFromObject(g: IGradient): string;
+/**
+ * Resolve any gradient-flavoured input into a CSS `background-image`
+ * value (the `linear-gradient(…)` / `radial-gradient(…)` / preset
+ * `var(--origam-gradient---*)` string).
+ *
+ * Caller is responsible for wrapping it in the right declaration —
+ * either `background-image: <value>` (default) or the `background-clip:
+ * text` triad when applied to a foreground.
+ *
+ * Returns an empty string for non-gradient inputs (so callers can use
+ * the return value as a truthiness check).
+ */
+export declare function resolveGradient(value: TColor | IGradient): string;

package/dist/src/utils/Commons/gradient.util.js

@@ -0,0 +1,66 @@
+import { intentTokenBase, isIntent } from "./color.util.ts";
+const GRADIENT_FN_RE = /^\s*(repeating-)?(linear|radial|conic)-gradient\s*\(/i;
+const PRESET_PREFIX = "gradient-";
+function isGradientString(value) {
+  return GRADIENT_FN_RE.test(value);
+}
+function isPresetString(value) {
+  return value.startsWith(PRESET_PREFIX) && value.length > PRESET_PREFIX.length;
+}
+function isGradientObject(value) {
+  if (value === null || typeof value !== "object") return false;
+  const obj = value;
+  const hasShortForm = typeof obj.from === "string" && typeof obj.to === "string";
+  const hasStops = Array.isArray(obj.stops) && obj.stops.length >= 2;
+  return hasShortForm || hasStops;
+}
+export function isGradient(value) {
+  if (typeof value === "string") {
+    return isGradientString(value) || isPresetString(value);
+  }
+  return isGradientObject(value);
+}
+function resolveStopColor(color) {
+  if (isIntent(color)) {
+    return `var(--origam-color__${intentTokenBase(color)}---bg)`;
+  }
+  return color;
+}
+function resolveDirection(type, direction) {
+  if (direction === void 0 || direction === null || direction === "") {
+    if (type === "radial") return "circle at center";
+    if (type === "conic") return "from 0deg at 50% 50%";
+    return "135deg";
+  }
+  if (typeof direction === "number") return `${direction}deg`;
+  return direction;
+}
+export function gradientFromObject(g) {
+  const type = g.type ?? "linear";
+  const directionPart = resolveDirection(type, g.direction);
+  let stopsPart = "";
+  if (Array.isArray(g.stops) && g.stops.length >= 2) {
+    stopsPart = g.stops.map((s) => `${resolveStopColor(s.color)} ${s.position}%`).join(", ");
+  } else if (g.from && g.to) {
+    const parts = [resolveStopColor(g.from)];
+    if (g.via) parts.push(resolveStopColor(g.via));
+    parts.push(resolveStopColor(g.to));
+    stopsPart = parts.join(", ");
+  } else {
+    stopsPart = "transparent, transparent";
+  }
+  return `${type}-gradient(${directionPart}, ${stopsPart})`;
+}
+export function resolveGradient(value) {
+  if (value === null || value === void 0 || value === false) return "";
+  if (typeof value === "string") {
+    if (isGradientString(value)) return value;
+    if (isPresetString(value)) {
+      const slug = value.slice(PRESET_PREFIX.length);
+      return `var(--origam-gradient---${slug})`;
+    }
+    return "";
+  }
+  if (isGradientObject(value)) return gradientFromObject(value);
+  return "";
+}

package/dist/src/utils/Mask/apply-mask.util.cjs

@@ -0,0 +1,120 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.applyMask = applyMask;
+exports.parsePattern = parsePattern;
+exports.unmaskValue = unmaskValue;
+const TOKEN_CACHE = /* @__PURE__ */new Map();
+function parsePattern(pattern) {
+  if (TOKEN_CACHE.has(pattern)) {
+    return TOKEN_CACHE.get(pattern);
+  }
+  const tokens = [];
+  for (const char of pattern) {
+    if (char === "#") {
+      tokens.push({
+        kind: "digit",
+        char: "#",
+        consumer: true
+      });
+    } else if (char === "A") {
+      tokens.push({
+        kind: "letter",
+        char: "A",
+        consumer: true
+      });
+    } else if (char === "*") {
+      tokens.push({
+        kind: "any",
+        char: "*",
+        consumer: true
+      });
+    } else {
+      tokens.push({
+        kind: "literal",
+        char,
+        consumer: false
+      });
+    }
+  }
+  TOKEN_CACHE.set(pattern, tokens);
+  return tokens;
+}
+const isDigit = c => c >= "0" && c <= "9";
+const isLetter = c => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+const LITERALS_CACHE = /* @__PURE__ */new Map();
+function literalSetOf(pattern) {
+  if (LITERALS_CACHE.has(pattern)) return LITERALS_CACHE.get(pattern);
+  const set = /* @__PURE__ */new Set();
+  for (const tok of parsePattern(pattern)) {
+    if (!tok.consumer) set.add(tok.char);
+  }
+  LITERALS_CACHE.set(pattern, set);
+  return set;
+}
+function stripLiterals(raw, pattern) {
+  const literals = literalSetOf(pattern);
+  let out = "";
+  for (const c of raw) {
+    if (literals.has(c)) continue;
+    out += c;
+  }
+  return out;
+}
+function applyMask(value, pattern) {
+  if (!pattern) {
+    return {
+      masked: value ?? "",
+      unmasked: value ?? "",
+      complete: false
+    };
+  }
+  const tokens = parsePattern(pattern);
+  const stripped = stripLiterals(value ?? "", pattern);
+  let masked = "";
+  let unmasked = "";
+  let consumed = 0;
+  let filledConsumers = 0;
+  const totalConsumers = tokens.reduce((acc, t) => acc + (t.consumer ? 1 : 0), 0);
+  for (const tok of tokens) {
+    if (!tok.consumer) {
+      if (consumed < stripped.length || unmasked.length > 0) {
+        masked += tok.char;
+      }
+      continue;
+    }
+    let matched = null;
+    while (consumed < stripped.length) {
+      const c = stripped[consumed++];
+      if (tok.kind === "digit" && isDigit(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "letter" && isLetter(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "any") {
+        matched = c;
+        break;
+      }
+    }
+    if (matched === null) {
+      break;
+    }
+    masked += matched;
+    unmasked += matched;
+    filledConsumers++;
+  }
+  const complete = filledConsumers === totalConsumers && totalConsumers > 0;
+  return {
+    masked,
+    unmasked,
+    complete
+  };
+}
+function unmaskValue(value, pattern) {
+  return applyMask(value, pattern).unmasked;
+}

package/dist/src/utils/Mask/apply-mask.util.d.ts

@@ -0,0 +1,13 @@
+import type { IMaskApplyResult, IMaskToken } from '../../interfaces';
+export declare function parsePattern(pattern: string): Array<IMaskToken>;
+/**
+ * Walk the pattern and consume the (pre-stripped) input
+ * char-by-char. Mismatching characters are dropped.
+ */
+export declare function applyMask(value: string, pattern: string): IMaskApplyResult;
+/**
+ * Returns just the unmasked value — handy from outside
+ * code that already knows its mask but only wants the
+ * raw characters.
+ */
+export declare function unmaskValue(value: string, pattern: string): string;

package/dist/src/utils/Mask/apply-mask.util.js

@@ -0,0 +1,91 @@
+const TOKEN_CACHE = /* @__PURE__ */ new Map();
+export function parsePattern(pattern) {
+  if (TOKEN_CACHE.has(pattern)) {
+    return TOKEN_CACHE.get(pattern);
+  }
+  const tokens = [];
+  for (const char of pattern) {
+    if (char === "#") {
+      tokens.push({ kind: "digit", char: "#", consumer: true });
+    } else if (char === "A") {
+      tokens.push({ kind: "letter", char: "A", consumer: true });
+    } else if (char === "*") {
+      tokens.push({ kind: "any", char: "*", consumer: true });
+    } else {
+      tokens.push({ kind: "literal", char, consumer: false });
+    }
+  }
+  TOKEN_CACHE.set(pattern, tokens);
+  return tokens;
+}
+const isDigit = (c) => c >= "0" && c <= "9";
+const isLetter = (c) => c >= "a" && c <= "z" || c >= "A" && c <= "Z";
+const LITERALS_CACHE = /* @__PURE__ */ new Map();
+function literalSetOf(pattern) {
+  if (LITERALS_CACHE.has(pattern)) return LITERALS_CACHE.get(pattern);
+  const set = /* @__PURE__ */ new Set();
+  for (const tok of parsePattern(pattern)) {
+    if (!tok.consumer) set.add(tok.char);
+  }
+  LITERALS_CACHE.set(pattern, set);
+  return set;
+}
+function stripLiterals(raw, pattern) {
+  const literals = literalSetOf(pattern);
+  let out = "";
+  for (const c of raw) {
+    if (literals.has(c)) continue;
+    out += c;
+  }
+  return out;
+}
+export function applyMask(value, pattern) {
+  if (!pattern) {
+    return { masked: value ?? "", unmasked: value ?? "", complete: false };
+  }
+  const tokens = parsePattern(pattern);
+  const stripped = stripLiterals(value ?? "", pattern);
+  let masked = "";
+  let unmasked = "";
+  let consumed = 0;
+  let filledConsumers = 0;
+  const totalConsumers = tokens.reduce(
+    (acc, t) => acc + (t.consumer ? 1 : 0),
+    0
+  );
+  for (const tok of tokens) {
+    if (!tok.consumer) {
+      if (consumed < stripped.length || unmasked.length > 0) {
+        masked += tok.char;
+      }
+      continue;
+    }
+    let matched = null;
+    while (consumed < stripped.length) {
+      const c = stripped[consumed++];
+      if (tok.kind === "digit" && isDigit(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "letter" && isLetter(c)) {
+        matched = c;
+        break;
+      }
+      if (tok.kind === "any") {
+        matched = c;
+        break;
+      }
+    }
+    if (matched === null) {
+      break;
+    }
+    masked += matched;
+    unmasked += matched;
+    filledConsumers++;
+  }
+  const complete = filledConsumers === totalConsumers && totalConsumers > 0;
+  return { masked, unmasked, complete };
+}
+export function unmaskValue(value, pattern) {
+  return applyMask(value, pattern).unmasked;
+}