@graphrefly/ts 0.0.0 → 0.0.1

package/dist/solutions/reactive-layout/browser/index.cjs

@@ -0,0 +1,449 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solutions/reactive-layout/browser/index.ts
+var browser_exports = {};
+__export(browser_exports, {
+  CanvasMeasureAdapter: () => CanvasMeasureAdapter,
+  canvasTextMeasurements: () => canvasTextMeasurements
+});
+module.exports = __toCommonJS(browser_exports);
+
+// src/ctx/types.ts
+var CTX_DEP_CACHE = /* @__PURE__ */ Symbol("graphrefly.ctx.depCache");
+function depLatest(ctx, depIndex) {
+  return ctx[CTX_DEP_CACHE]?.latest[depIndex];
+}
+
+// src/solutions/reactive-layout/index.ts
+var TEXT_SEGMENTS_MEASUREMENT_KIND = "text-segments";
+var kinsokuStart = /* @__PURE__ */ new Set([
+  "\u3001",
+  "\u3002",
+  "\u30FB",
+  "\uFF09",
+  "\u3015",
+  "\u3009",
+  "\u300B",
+  "\u300D",
+  "\u300F",
+  "\u3011"
+]);
+var leftStickyPunctuation = /* @__PURE__ */ new Set([
+  ".",
+  ",",
+  "!",
+  "?",
+  ":",
+  ";",
+  ")",
+  "]",
+  "}",
+  "%",
+  '"',
+  "\u201D",
+  "\u2019",
+  "\xBB",
+  "\u203A",
+  "\u2026"
+]);
+function isCJK(text) {
+  for (const ch of text) {
+    const c = ch.codePointAt(0);
+    if (c !== void 0 && c >= 19968 && c <= 40959 || c !== void 0 && c >= 13312 && c <= 19903 || c !== void 0 && c >= 12288 && c <= 12351 || c !== void 0 && c >= 12352 && c <= 12447 || c !== void 0 && c >= 44032 && c <= 55215 || c !== void 0 && c >= 65280 && c <= 65519) {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeWhitespace(text) {
+  return text.replace(/[\t\f ]+/g, " ").replace(/^ | $/g, "");
+}
+function segmentText(text, segmentAdapter) {
+  const pieces = [];
+  for (const s of segmentAdapter.segmentWords(text)) {
+    const wordSegment = s.segment;
+    const rawWordLike = s.isWordLike ?? false;
+    const pieceTexts = [];
+    const pieceWordLikes = [];
+    const pieceKinds = [];
+    let currentText = "";
+    let currentKind = null;
+    for (const ch of wordSegment) {
+      let kind;
+      if (ch === " ") {
+        kind = "space";
+      } else if (ch === "\u200B") {
+        kind = "zero-width-break";
+      } else if (ch === "\xAD") {
+        kind = "soft-hyphen";
+      } else if (ch === "\n") {
+        kind = "hard-break";
+      } else {
+        kind = "text";
+      }
+      if (currentKind !== null && kind === currentKind) {
+        currentText += ch;
+      } else {
+        if (currentKind !== null) {
+          pieceTexts.push(currentText);
+          pieceWordLikes.push(currentKind === "text" && rawWordLike);
+          pieceKinds.push(currentKind);
+        }
+        currentText = ch;
+        currentKind = kind;
+      }
+    }
+    if (currentKind !== null) {
+      pieceTexts.push(currentText);
+      pieceWordLikes.push(currentKind === "text" && rawWordLike);
+      pieceKinds.push(currentKind);
+    }
+    pieces.push({ texts: pieceTexts, isWordLike: pieceWordLikes, kinds: pieceKinds });
+  }
+  return pieces;
+}
+function* fallbackSegmentWords(text) {
+  let index = 0;
+  let current = "";
+  let currentIndex = 0;
+  let currentWordLike = null;
+  const flush = () => {
+    if (current.length === 0 || currentWordLike === null) return void 0;
+    const out2 = { segment: current, index: currentIndex, isWordLike: currentWordLike };
+    current = "";
+    currentWordLike = null;
+    return out2;
+  };
+  for (const ch of text) {
+    const isWordLike = !/[\s\u200B\u00AD]/u.test(ch);
+    if (currentWordLike !== null && currentWordLike !== isWordLike) {
+      const out2 = flush();
+      if (out2) yield out2;
+    }
+    if (currentWordLike === null) {
+      currentWordLike = isWordLike;
+      currentIndex = index;
+    }
+    current += ch;
+    index += ch.length;
+  }
+  const out = flush();
+  if (out) yield out;
+}
+function* fallbackSegmentGraphemes(text) {
+  let index = 0;
+  for (const ch of text) {
+    yield { segment: ch, index };
+    index += ch.length;
+  }
+}
+function createDefaultSegmentAdapter() {
+  return {
+    segmentWords(text) {
+      return fallbackSegmentWords(text);
+    },
+    segmentGraphemes(text) {
+      return fallbackSegmentGraphemes(text);
+    }
+  };
+}
+var defaultSegmentAdapter = null;
+function getDefaultSegmentAdapter() {
+  if (defaultSegmentAdapter === null) {
+    defaultSegmentAdapter = createDefaultSegmentAdapter();
+  }
+  return defaultSegmentAdapter;
+}
+function measurementIssue(code, message, targetId, measurementKind, opts = {}) {
+  return {
+    kind: "issue",
+    code,
+    message,
+    severity: opts.severity ?? "warning",
+    source: opts.source,
+    subjectId: targetId,
+    measurementKind,
+    details: opts.details,
+    metadata: opts.metadata
+  };
+}
+function measurementOk(targetId, measurementKind, value, opts = {}) {
+  return {
+    kind: "ok",
+    targetId,
+    measurementKind,
+    value,
+    source: opts.source,
+    metadata: opts.metadata
+  };
+}
+function tryMeasureHyphenWidth(adapter, font) {
+  try {
+    return nonNegativeFinite(adapter.measureSegment("-", font).width, 0);
+  } catch {
+    return void 0;
+  }
+}
+function textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source) {
+  try {
+    const segments = analyzeAndMeasure(text, font, adapter, cache, void 0, segmentAdapter);
+    const hyphenWidth = tryMeasureHyphenWidth(adapter, font);
+    const facts = [
+      measurementOk(
+        targetId,
+        TEXT_SEGMENTS_MEASUREMENT_KIND,
+        hyphenWidth === void 0 ? { segments } : { segments, hyphenWidth },
+        { source }
+      )
+    ];
+    if (hyphenWidth === void 0) {
+      facts.push(
+        measurementIssue(
+          "measurement.hyphen.failed",
+          `Hyphen measurement failed for '${targetId}'`,
+          targetId,
+          TEXT_SEGMENTS_MEASUREMENT_KIND,
+          { source, severity: "warning" }
+        )
+      );
+    }
+    return facts;
+  } catch (error) {
+    return [
+      measurementIssue(
+        "measurement.failed",
+        `Text measurement failed for '${targetId}'`,
+        targetId,
+        TEXT_SEGMENTS_MEASUREMENT_KIND,
+        { source, details: error, severity: "error" }
+      )
+    ];
+  }
+}
+function textMeasurementProvider(opts) {
+  const targetId = opts.targetId ?? "text";
+  const name = opts.name ?? `${targetId}-measurements`;
+  const source = opts.source ?? name;
+  const cache = /* @__PURE__ */ new Map();
+  let activeAdapter = null;
+  return opts.graph.node(
+    opts.segmentAdapter ? [opts.text, opts.font, opts.adapter, opts.segmentAdapter] : [opts.text, opts.font, opts.adapter],
+    (ctx) => {
+      const flush = () => {
+        cache.clear();
+        depLatest(ctx, 2).clearCache?.();
+      };
+      ctx.onDeactivation(flush);
+      ctx.onInvalidate(flush);
+      const text = depLatest(ctx, 0);
+      const font = depLatest(ctx, 1);
+      const adapter = depLatest(ctx, 2);
+      if (adapter !== activeAdapter) {
+        cache.clear();
+        activeAdapter = adapter;
+      }
+      const segmentAdapter = opts.segmentAdapter === void 0 ? getDefaultSegmentAdapter() : depLatest(ctx, 3);
+      ctx.down([
+        [
+          "DATA",
+          textMeasurementFacts(text, font, adapter, cache, segmentAdapter, targetId, source)
+        ]
+      ]);
+    },
+    { name }
+  );
+}
+function analyzeAndMeasure(text, font, adapter, cache, stats, segmentAdapter) {
+  const normalized = normalizeWhitespace(text);
+  if (normalized.length === 0) {
+    return [];
+  }
+  const segAdapter = segmentAdapter ?? getDefaultSegmentAdapter();
+  const pieces = segmentText(normalized, segAdapter);
+  const rawTexts = [];
+  const rawKinds = [];
+  const rawWordLike = [];
+  for (const piece of pieces) {
+    for (let i = 0; i < piece.texts.length; i += 1) {
+      rawTexts.push(piece.texts[i]);
+      rawKinds.push(piece.kinds[i]);
+      rawWordLike.push(piece.isWordLike[i]);
+    }
+  }
+  const mergedTexts = [];
+  const mergedKinds = [];
+  const mergedWordLike = [];
+  for (let i = 0; i < rawTexts.length; i += 1) {
+    const t = rawTexts[i];
+    const k = rawKinds[i];
+    const wl = rawWordLike[i];
+    if (k === "text" && !wl && mergedTexts.length > 0 && mergedKinds[mergedTexts.length - 1] === "text") {
+      const isSticky = t.length === 1 && (leftStickyPunctuation.has(t) || kinsokuStart.has(t));
+      if (isSticky) {
+        mergedTexts[mergedTexts.length - 1] += t;
+        continue;
+      }
+    }
+    if (t === "-" && mergedTexts.length > 0 && mergedKinds[mergedKinds.length - 1] === "text" && mergedWordLike[mergedWordLike.length - 1]) {
+      mergedTexts[mergedTexts.length - 1] += t;
+      continue;
+    }
+    mergedTexts.push(t);
+    mergedKinds.push(k);
+    mergedWordLike.push(wl);
+  }
+  const fontCache = cache.get(font) ?? /* @__PURE__ */ new Map();
+  if (!cache.has(font)) cache.set(font, fontCache);
+  function measureCached(segment) {
+    const cached = fontCache.get(segment);
+    if (cached === void 0) {
+      if (stats) stats.misses += 1;
+      const measured = adapter.measureSegment(segment, font).width;
+      const width = Number.isFinite(measured) && measured >= 0 ? measured : 0;
+      fontCache.set(segment, width);
+      return width;
+    }
+    if (stats) stats.hits += 1;
+    return cached;
+  }
+  const out = [];
+  for (let i = 0; i < mergedTexts.length; i += 1) {
+    const t = mergedTexts[i];
+    const kind = mergedKinds[i];
+    if (kind !== "text") {
+      out.push({
+        text: t,
+        width: kind === "space" ? measureCached(" ") * t.length : 0,
+        kind,
+        graphemeWidths: null
+      });
+      continue;
+    }
+    if (isCJK(t)) {
+      let unitText = "";
+      for (const graphemeSegment of segAdapter.segmentGraphemes(t)) {
+        const grapheme = graphemeSegment.segment;
+        if (unitText.length > 0 && kinsokuStart.has(grapheme)) {
+          unitText += grapheme;
+          continue;
+        }
+        if (unitText.length > 0) {
+          out.push({
+            text: unitText,
+            width: measureCached(unitText),
+            kind: "text",
+            graphemeWidths: null
+          });
+        }
+        unitText = grapheme;
+      }
+      if (unitText.length > 0) {
+        out.push({
+          text: unitText,
+          width: measureCached(unitText),
+          kind: "text",
+          graphemeWidths: null
+        });
+      }
+      continue;
+    }
+    const textWidth = measureCached(t);
+    let graphemeWidths = null;
+    if (mergedWordLike[i] && t.length > 1) {
+      const widths = [];
+      for (const grapheme of segAdapter.segmentGraphemes(t)) {
+        widths.push(measureCached(grapheme.segment));
+      }
+      if (widths.length > 1) graphemeWidths = widths;
+    }
+    out.push({
+      text: t,
+      width: textWidth,
+      kind: "text",
+      graphemeWidths
+    });
+  }
+  return out;
+}
+function nonNegativeFinite(value, fallback) {
+  return Number.isFinite(value) ? Math.max(0, value) : fallback;
+}
+
+// src/solutions/reactive-layout/browser/index.ts
+var CanvasMeasureAdapter = class {
+  ctx = null;
+  currentFont = "";
+  emojiCorrection;
+  constructor(opts) {
+    this.emojiCorrection = opts?.emojiCorrection ?? 1;
+  }
+  getContext() {
+    if (this.ctx !== null) return this.ctx;
+    const globalOffscreenCanvas = globalThis.OffscreenCanvas;
+    if (typeof globalOffscreenCanvas === "undefined") {
+      throw new TypeError("CanvasMeasureAdapter requires a browser with OffscreenCanvas support");
+    }
+    const canvas = new globalOffscreenCanvas(0, 0);
+    const ctx = canvas.getContext("2d");
+    if (ctx === null) throw new TypeError("CanvasMeasureAdapter: failed to get 2D context");
+    this.ctx = ctx;
+    return ctx;
+  }
+  measureSegment(text, font) {
+    const ctx = this.getContext();
+    if (font !== this.currentFont) {
+      ctx.font = font;
+      this.currentFont = font;
+    }
+    let width = ctx.measureText(text).width;
+    if (this.emojiCorrection !== 1 && /\p{Emoji_Presentation}/u.test(text)) {
+      width *= this.emojiCorrection;
+    }
+    return { width };
+  }
+  clearCache() {
+    this.currentFont = "";
+  }
+};
+function canvasTextMeasurements(opts) {
+  const targetId = opts.targetId ?? "text";
+  const adapter = opts.graph.state(
+    new CanvasMeasureAdapter({ emojiCorrection: opts.emojiCorrection }),
+    {
+      name: opts.name ? `${opts.name}:measure-capability` : `${targetId}-canvas-measure-capability`
+    }
+  );
+  return textMeasurementProvider({
+    graph: opts.graph,
+    text: opts.text,
+    font: opts.font,
+    adapter,
+    segmentAdapter: opts.segmentAdapter,
+    targetId: opts.targetId,
+    source: opts.source ?? "canvasTextMeasurements",
+    name: opts.name
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CanvasMeasureAdapter,
+  canvasTextMeasurements
+});
+//# sourceMappingURL=index.cjs.map