@orz/ui-code 0.0.0-stage → 0.0.0

package/dist/word-diff.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Word-like tokens of `text`, weighted by how many characters each spends.
+ * This is what `alignGroups` scores a candidate pair with (T-211): the
+ * question there is only "are these two the same block", and a bag of words
+ * answers it without the quadratic cost of a real diff — which matters once
+ * the run being scored is a whole rewritten section rather than one line
+ * hunk. Spaces and punctuation stay out: T-180 already found those to be
+ * the anchors that mean nothing.
+ *
+ * What it weighs is prose. A candidate that can also hold pictures goes
+ * through `bagWith`, which counts those by identity instead (T-239).
+ */
+export type WordBag = {
+    weights: Map<string, number>;
+    total: number;
+};
+export declare function wordBag(text: string): WordBag;
+/** The bag of `text`, plus one entry for each of `urls`.
+ *
+ * An image used to reach the bag as its markdown source, and a word is weighed
+ * by its characters, so `/api/projects/<slug>/attachments/<id>/download/` —
+ * the path every attachment in one deployment shares — became the vocabulary
+ * two unrelated tables had most in common (T-239). Two tables sharing nothing
+ * but the fact of holding attachments scored 0.69 against each other while a
+ * table and its real counterpart scored 0.22, and both numbers get worse the
+ * longer the deployment spells that prefix.
+ *
+ * A url is an identity, not prose: worth counting that this picture is that
+ * picture, worth nothing to count how many characters the path to it spends.
+ * So each one lands as a single fixed-weight entry under a key no prose can
+ * collide with — `wordBag` keeps `isWordLike` segments only, which one
+ * non-word character in front is enough to stay clear of.
+ */
+export declare function bagWith(text: string, urls: string[]): WordBag;
+/** Half-open character range `[start, end)`. */
+export type WordDiffRange = {
+    start: number;
+    end: number;
+};
+/**
+ * Text present in the old side and gone from the new one. `at` is where it
+ * sat in the new text (a caret, not a span — deleted text has no new-side
+ * extent); `from`/`to` locate it in the old text so the caller can quote it.
+ */
+export type WordDiffDeletion = {
+    at: number;
+    from: number;
+    to: number;
+};
+export type WordDiffResult = {
+    ins: WordDiffRange[];
+    del: WordDiffDeletion[];
+};
+/**
+ * Word-level edits with the anchors that cost more than they earn folded into
+ * the change around them (T-180).
+ *
+ * A heavily rewritten line still shares spaces, punctuation and the odd single
+ * character with the line it replaced, and every one of those the word diff
+ * keeps cuts the rewrite apart: the reader is told `format.ts` became `引入`
+ * and `East` became `sindresorhus，纯`, pairings that carry no meaning, while
+ * the sentence's genuinely untouched tail drowns among the fragments. An
+ * anchor is only worth drawing around when it outweighs the change on *both*
+ * sides of it; a lighter one is folded in, and the two sides each run together
+ * into a single coherent before and after.
+ *
+ * No threshold is involved, which is the point: a small edit keeps every
+ * anchor it has and comes out word-level exactly as it did before, while a
+ * line rewritten past the last surviving anchor degrades into the whole-block
+ * before/after T-142 already renders for a pair that shares nothing. Weight is
+ * in characters and a tie leaves the anchor standing — the conservative of the
+ * two tiers T-180 weighed, and tightening it later is the one comparison
+ * below.
+ *
+ * `wordDiff` keeps its bare output beside this one: coalescing answers "what
+ * should the reader see", and anything measuring how much genuinely changed
+ * would read a folded-in anchor as change that is not there.
+ */
+export declare function coalescedWordDiff(oldText: string, newText: string): WordDiffResult;
+/** Word-level edits between two texts, as offsets into each side. */
+export declare function wordDiff(oldText: string, newText: string): WordDiffResult;
+//# sourceMappingURL=word-diff.d.ts.map

package/dist/word-diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-diff.d.ts","sourceRoot":"","sources":["../src/word-diff.ts"],"names":[],"mappings":"AA0BA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,OAAO,GAAG;IAAE,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEtE,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAS7C;AAYD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAQ7D;AAED,gDAAgD;AAChD,MAAM,MAAM,aAAa,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAExE,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,aAAa,EAAE,CAAC;IACrB,GAAG,EAAE,gBAAgB,EAAE,CAAC;CACzB,CAAC;AAsCF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,cAAc,CAuDhB;AAED,qEAAqE;AACrE,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,cAAc,CA4BzE"}

package/dist/word-diff.js

@@ -0,0 +1,209 @@
+import { Diff } from "diff";
+/**
+ * Word segmentation that works without spaces. jsdiff's own `diffWords`
+ * splits on whitespace, so an edited Chinese sentence is one giant token
+ * and the whole paragraph reads as changed — the exact complaint T-142
+ * exists to fix. `Intl.Segmenter` knows where words end in CJK as well as
+ * in English, and keeps whitespace and punctuation as their own segments,
+ * which is what makes "one word replaced" come out as one word replaced.
+ */
+const segmenter = new Intl.Segmenter(undefined, { granularity: "word" });
+class WordDiff extends Diff {
+    tokenize(value) {
+        const tokens = [];
+        for (const { segment } of segmenter.segment(value))
+            tokens.push(segment);
+        return tokens;
+    }
+    join(tokens) {
+        return tokens.join("");
+    }
+}
+const differ = new WordDiff();
+export function wordBag(text) {
+    const weights = new Map();
+    let total = 0;
+    for (const { segment, isWordLike } of segmenter.segment(text)) {
+        if (isWordLike !== true)
+            continue;
+        weights.set(segment, (weights.get(segment) ?? 0) + segment.length);
+        total += segment.length;
+    }
+    return { weights, total };
+}
+/**
+ * What one picture is worth against one character of prose. It is a rate, not
+ * a threshold — it rules nothing out, it only gives an image enough weight to
+ * take part in the score at all. T-239 swept 1 through 20 and every fixture
+ * came out identical; at 40 one picture outweighs all the prose beside it and
+ * a table that lost an image stops resembling its own counterpart, so the
+ * bottom of the flat range is what this takes.
+ */
+const IMAGE_WEIGHT = 1;
+/** The bag of `text`, plus one entry for each of `urls`.
+ *
+ * An image used to reach the bag as its markdown source, and a word is weighed
+ * by its characters, so `/api/projects/<slug>/attachments/<id>/download/` —
+ * the path every attachment in one deployment shares — became the vocabulary
+ * two unrelated tables had most in common (T-239). Two tables sharing nothing
+ * but the fact of holding attachments scored 0.69 against each other while a
+ * table and its real counterpart scored 0.22, and both numbers get worse the
+ * longer the deployment spells that prefix.
+ *
+ * A url is an identity, not prose: worth counting that this picture is that
+ * picture, worth nothing to count how many characters the path to it spends.
+ * So each one lands as a single fixed-weight entry under a key no prose can
+ * collide with — `wordBag` keeps `isWordLike` segments only, which one
+ * non-word character in front is enough to stay clear of.
+ */
+export function bagWith(text, urls) {
+    const bag = wordBag(text);
+    for (const url of urls) {
+        const key = `\u0000${url}`;
+        bag.weights.set(key, (bag.weights.get(key) ?? 0) + IMAGE_WEIGHT);
+        bag.total += IMAGE_WEIGHT;
+    }
+    return bag;
+}
+function diffRuns(oldText, newText) {
+    const runs = [];
+    let edit = null;
+    for (const part of differ.diff(oldText, newText)) {
+        if (part.added || part.removed) {
+            if (edit === null) {
+                edit = { kind: "edit", del: "", ins: "" };
+                runs.push(edit);
+            }
+            if (part.added)
+                edit.ins += part.value;
+            else
+                edit.del += part.value;
+            continue;
+        }
+        edit = null;
+        const last = runs.at(-1);
+        if (last !== undefined && last.kind === "eq")
+            last.text += part.value;
+        else
+            runs.push({ kind: "eq", text: part.value });
+    }
+    return runs;
+}
+/** How much a run of changed text weighs against a neighbouring anchor. */
+function weightOf(run) {
+    return Math.max(run.del.length, run.ins.length);
+}
+/**
+ * Word-level edits with the anchors that cost more than they earn folded into
+ * the change around them (T-180).
+ *
+ * A heavily rewritten line still shares spaces, punctuation and the odd single
+ * character with the line it replaced, and every one of those the word diff
+ * keeps cuts the rewrite apart: the reader is told `format.ts` became `引入`
+ * and `East` became `sindresorhus，纯`, pairings that carry no meaning, while
+ * the sentence's genuinely untouched tail drowns among the fragments. An
+ * anchor is only worth drawing around when it outweighs the change on *both*
+ * sides of it; a lighter one is folded in, and the two sides each run together
+ * into a single coherent before and after.
+ *
+ * No threshold is involved, which is the point: a small edit keeps every
+ * anchor it has and comes out word-level exactly as it did before, while a
+ * line rewritten past the last surviving anchor degrades into the whole-block
+ * before/after T-142 already renders for a pair that shares nothing. Weight is
+ * in characters and a tie leaves the anchor standing — the conservative of the
+ * two tiers T-180 weighed, and tightening it later is the one comparison
+ * below.
+ *
+ * `wordDiff` keeps its bare output beside this one: coalescing answers "what
+ * should the reader see", and anything measuring how much genuinely changed
+ * would read a folded-in anchor as change that is not there.
+ */
+export function coalescedWordDiff(oldText, newText) {
+    if (oldText === newText)
+        return { ins: [], del: [] };
+    const runs = diffRuns(oldText, newText);
+    // The first and last run are never anchors with a change on either side, so
+    // the text a line opens and closes with survives however heavy the rewrite
+    // between them — which is how the evidence line keeps its untouched tail.
+    for (let i = 1; i + 1 < runs.length;) {
+        const anchor = runs[i];
+        const before = runs[i - 1];
+        const after = runs[i + 1];
+        if (anchor?.kind !== "eq" ||
+            before?.kind !== "edit" ||
+            after?.kind !== "edit" ||
+            anchor.text.length >= weightOf(before) ||
+            anchor.text.length >= weightOf(after)) {
+            i++;
+            continue;
+        }
+        runs.splice(i - 1, 3, {
+            kind: "edit",
+            del: before.del + anchor.text + after.del,
+            ins: before.ins + anchor.text + after.ins,
+        });
+        // Leaving `i` where it is lands on the anchor after the merged run, which
+        // now weighs itself against the heavier thing folding produced — that is
+        // how a run of light anchors collapses together in one pass. An anchor
+        // already found heavy enough is never revisited: letting a growing
+        // neighbour come back for it would erode surviving anchors one at a time
+        // until only the first and last stood, which is the aggressive tier T-180
+        // ruled against.
+    }
+    const ins = [];
+    const del = [];
+    let oldPos = 0;
+    let newPos = 0;
+    for (const run of runs) {
+        if (run.kind === "eq") {
+            oldPos += run.text.length;
+            newPos += run.text.length;
+            continue;
+        }
+        if (run.del !== "") {
+            del.push({ at: newPos, from: oldPos, to: oldPos + run.del.length });
+            oldPos += run.del.length;
+        }
+        if (run.ins !== "") {
+            ins.push({ start: newPos, end: newPos + run.ins.length });
+            newPos += run.ins.length;
+        }
+    }
+    return { ins, del };
+}
+/** Word-level edits between two texts, as offsets into each side. */
+export function wordDiff(oldText, newText) {
+    const ins = [];
+    const del = [];
+    if (oldText === newText)
+        return { ins, del };
+    let oldPos = 0;
+    let newPos = 0;
+    for (const part of differ.diff(oldText, newText)) {
+        const length = part.value.length;
+        if (part.added) {
+            const last = ins.at(-1);
+            if (last !== undefined && last.end === newPos)
+                last.end = newPos + length;
+            else
+                ins.push({ start: newPos, end: newPos + length });
+            newPos += length;
+        }
+        else if (part.removed) {
+            const last = del.at(-1);
+            if (last !== undefined && last.at === newPos && last.to === oldPos) {
+                last.to = oldPos + length;
+            }
+            else {
+                del.push({ at: newPos, from: oldPos, to: oldPos + length });
+            }
+            oldPos += length;
+        }
+        else {
+            oldPos += length;
+            newPos += length;
+        }
+    }
+    return { ins, del };
+}
+//# sourceMappingURL=word-diff.js.map

package/dist/word-diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"word-diff.js","sourceRoot":"","sources":["../src/word-diff.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@orz/ui-code",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "Syntax-highlighted code and diff blocks on pierre, a CJK-aware word differ, and the code renderer for the @orz/ui-content registry",
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/orzFly/ui.git",
+    "directory": "packages/ui-code"
+  },
+  "type": "module",
+  "sideEffects": [
+    "**/*.css"
+  ],
+  "exports": {
+    ".": {
+      "@orz/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./word-diff": {
+      "@orz/source": "./src/word-diff.ts",
+      "types": "./dist/word-diff.d.ts",
+      "default": "./dist/word-diff.js"
+    },
+    "./styles.css": "./styles.css"
+  },
+  "files": [
+    "dist",
+    "styles.css"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@pierre/diffs": "^1.6.1",
+    "lucide-react": "^1",
+    "react": "^19",
+    "react-dom": "^19",
+    "@orz/ui": "^0.0.0",
+    "@orz/ui-content": "^0.0.0"
+  },
+  "dependencies": {
+    "diff": "^9.0.0"
+  },
+  "devDependencies": {
+    "@pierre/diffs": "^1.6.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/node": "^22.20.5",
+    "@types/react": "^19.2.18",
+    "@types/react-dom": "^19.2.4",
+    "happy-dom": "^21.0.3",
+    "lucide-react": "^1.31.0",
+    "react": "^19.2.8",
+    "react-dom": "^19.2.8",
+    "vitest": "^5.0.5",
+    "@orz/themes": "0.0.0",
+    "@orz/ui": "0.0.0",
+    "@orz/ui-content": "0.0.0"
+  },
+  "scripts": {
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
 }

package/styles.css

@@ -0,0 +1,34 @@
+/* Tailwind resolves an imported file's @source against that file, so a
+   consumer importing this stylesheet scans the classes in the package's
+   shipped JS without writing an @source of its own. */
+@source "./dist";
+
+/* Every pierre code surface renders in a shadow root and resolves its
+   palette with light-dark(); declarations from the outer tree win over
+   shadow :host rules, which is what lets these lines keep pierre in step
+   with the app theme.
+
+   The bg/fg pairs override what the syntax theme wrote into :host, and every
+   other chrome color pierre uses — line-number gutter, context rows, hunk
+   separators, the addition/deletion tints — is color-mix()'d off them, so
+   aligning these four aligns the whole surface, including themes with no
+   syntax counterpart to map to (T-144). */
+diffs-container {
+  color-scheme: light;
+  --diffs-light-bg: var(--background);
+  --diffs-dark-bg: var(--background);
+  --diffs-light: var(--foreground);
+  --diffs-dark: var(--foreground);
+}
+.dark diffs-container {
+  color-scheme: dark;
+}
+
+/* A patch's +/- counts take the theme's diff colours, mixed toward the
+   foreground so small text stays legible. */
+.diff-addition-text {
+  color: color-mix(in oklab, var(--foreground) 75%, var(--diff-addition));
+}
+.diff-deletion-text {
+  color: color-mix(in oklab, var(--foreground) 75%, var(--diff-deletion));
+}