origam 2.2.1 → 2.3.0

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

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseHighlightLines = parseHighlightLines;
+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/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/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;
+}

package/dist/src/utils/Mask/index.cjs

@@ -0,0 +1,38 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _applyMask = require("./apply-mask.util.cjs");
+Object.keys(_applyMask).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _applyMask[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _applyMask[key];
+    }
+  });
+});
+var _resolveMaskConfig = require("./resolve-mask-config.util.cjs");
+Object.keys(_resolveMaskConfig).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _resolveMaskConfig[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _resolveMaskConfig[key];
+    }
+  });
+});
+var _validatePattern = require("./validate-pattern.util.cjs");
+Object.keys(_validatePattern).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _validatePattern[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _validatePattern[key];
+    }
+  });
+});

package/dist/src/utils/Mask/index.d.ts

@@ -0,0 +1,3 @@
+export * from './apply-mask.util';
+export * from './resolve-mask-config.util';
+export * from './validate-pattern.util';

package/dist/src/utils/Mask/index.js

@@ -0,0 +1,3 @@
+export * from "./apply-mask.util.js";
+export * from "./resolve-mask-config.util.js";
+export * from "./validate-pattern.util.js";

package/dist/src/utils/Mask/resolve-mask-config.util.cjs

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.resolveMaskConfig = resolveMaskConfig;
+var _consts = require("../../consts/index.cjs");
+function resolveMaskConfig(mask) {
+  if (mask == null || mask === "") return null;
+  if (typeof mask === "string") {
+    if (_consts.BUILT_IN_PATTERN_KEYS.has(mask)) {
+      const preset = _consts.BUILT_IN_PATTERNS[mask];
+      return {
+        pattern: preset.pattern,
+        validator: preset.validator ?? null,
+        required: preset.required ?? false
+      };
+    }
+    return {
+      pattern: mask,
+      validator: null,
+      required: false
+    };
+  }
+  const opts = mask;
+  return {
+    pattern: opts.pattern,
+    validator: opts.validator ?? null,
+    required: opts.required ?? false
+  };
+}

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

@@ -0,0 +1,15 @@
+import type { IResolvedMaskConfig } from '../../interfaces';
+import type { TMask } from '../../types';
+/**
+ * Normalise the polymorphic `mask` prop / arg into a fully
+ * resolved `{ pattern, validator, required }` object.
+ *
+ * - `null | undefined | ''` → returns `null`. Callers treat
+ *   this as "no masking".
+ * - `string`                → either a registered built-in
+ *                             key (looked up) or a raw
+ *                             pattern (used verbatim).
+ * - `IMaskOptions`          → consumed as-is, with `required`
+ *                             defaulting to `false`.
+ */
+export declare function resolveMaskConfig(mask: TMask | undefined): IResolvedMaskConfig | null;

package/dist/src/utils/Mask/resolve-mask-config.util.js

@@ -0,0 +1,21 @@
+import { BUILT_IN_PATTERN_KEYS, BUILT_IN_PATTERNS } from "../../consts/index.js";
+export function resolveMaskConfig(mask) {
+  if (mask == null || mask === "") return null;
+  if (typeof mask === "string") {
+    if (BUILT_IN_PATTERN_KEYS.has(mask)) {
+      const preset = BUILT_IN_PATTERNS[mask];
+      return {
+        pattern: preset.pattern,
+        validator: preset.validator ?? null,
+        required: preset.required ?? false
+      };
+    }
+    return { pattern: mask, validator: null, required: false };
+  }
+  const opts = mask;
+  return {
+    pattern: opts.pattern,
+    validator: opts.validator ?? null,
+    required: opts.required ?? false
+  };
+}