@savvy-web/silk 2.0.0 → 2.1.1

package/packages/silk-effects/dist/dev/pkg/changesets/utils/dep-diff.js

@@ -1,111 +0,0 @@
-import { sortDependencyRows } from "./dependency-table.js";
-import { Option } from "effect";
-
-//#region ../silk-effects/dist/dev/pkg/changesets/utils/dep-diff.js
-/**
-* Compute per-workspace-package dependency-table rows from two
-* {@link WorkspaceStateSnapshot}s, resolving `catalog:` / `workspace:`
-* specifiers against each side's own catalogs and package versions BEFORE
-* comparing.
-*
-* @remarks
-* Operates on declared dependencies only (the `dependencies` /
-* `devDependencies` / `peerDependencies` / `optionalDependencies` fields
-* of each workspace's `package.json`). Lockfile-only movements
-* (resolved versions changing while declared ranges stay put) are
-* intentionally excluded — those happen on every `pnpm install` and
-* would generate constant noise.
-*
-* Each side carries its own catalogs and package versions, so a specifier
-* is resolved against the snapshot it belongs to: `catalog:silk` resolves
-* to that ref's `silk` catalog entry, `workspace:*` to that ref's target
-* package version. A row is emitted iff the two RESOLVED values differ (or
-* the dependency was added/removed) — a package that merely adopted a
-* `catalog:` specifier without changing the concrete version produces NO
-* row. When a side cannot resolve a specifier (no matching catalog entry,
-* plain range, etc.) it falls back to the raw specifier string.
-*
-* @see {@link DependencyTableRow} for the row schema
-* @see {@link WorkspaceStateSnapshot} for the input shape
-*
-*/
-/** The em-dash sentinel (U+2014) used for added ("from") / removed ("to") cells. */
-const EM_DASH = "—";
-const DEP_TYPE_MAP = [
-	["dependencies", "dependency"],
-	["devDependencies", "devDependency"],
-	["peerDependencies", "peerDependency"],
-	["optionalDependencies", "optionalDependency"]
-];
-/**
-* Resolve a specifier against the snapshot it belongs to, falling back to
-* the raw specifier string when the snapshot cannot resolve it.
-*/
-const resolveOrRaw = (snapshot, dep, spec) => Option.getOrElse(snapshot.resolve(dep, spec), () => spec);
-/**
-* Diff two workspace snapshots and return per-package dependency-table rows,
-* comparing already-resolved specifier values per side.
-*
-* @param before - Snapshot at the older ref (typically the merge base). A
-*   workspace package absent here reports every declared dep as `"added"`.
-* @param after - Snapshot at the newer ref (typically the working tree).
-* @returns One {@link WorkspaceDependencyDiff} entry per workspace package
-*   that has at least one row. Packages with no resolved-value changes are
-*   omitted.
-*
-* @public
-*/
-function computeWorkspaceDependencyDiffs(before, after) {
-	const result = [];
-	for (const afterPkg of after.packages) {
-		const beforePkg = Option.getOrNull(before.package(afterPkg.name));
-		const rows = [];
-		for (const [field, type] of DEP_TYPE_MAP) {
-			const beforeRecord = beforePkg?.[field] ?? {};
-			const afterRecord = afterPkg[field];
-			const seen = /* @__PURE__ */ new Set();
-			for (const [name, beforeSpec] of Object.entries(beforeRecord)) {
-				seen.add(name);
-				const from = resolveOrRaw(before, name, beforeSpec);
-				const afterSpec = afterRecord[name];
-				if (afterSpec === void 0) {
-					rows.push({
-						dependency: name,
-						type,
-						action: "removed",
-						from,
-						to: EM_DASH
-					});
-					continue;
-				}
-				const to = resolveOrRaw(after, name, afterSpec);
-				if (from !== to) rows.push({
-					dependency: name,
-					type,
-					action: "updated",
-					from,
-					to
-				});
-			}
-			for (const [name, afterSpec] of Object.entries(afterRecord)) {
-				if (seen.has(name)) continue;
-				rows.push({
-					dependency: name,
-					type,
-					action: "added",
-					from: EM_DASH,
-					to: resolveOrRaw(after, name, afterSpec)
-				});
-			}
-		}
-		if (rows.length > 0) result.push({
-			package: afterPkg.name,
-			relativePath: afterPkg.relativePath,
-			rows: sortDependencyRows(rows)
-		});
-	}
-	return result;
-}
-
-//#endregion
-export { computeWorkspaceDependencyDiffs };

package/packages/silk-effects/dist/dev/pkg/changesets/utils/dependency-table.cjs

@@ -1,351 +0,0 @@
-const require_index = require('../../../../../../../node_modules/.pnpm/mdast-util-to-string@4.0.0/node_modules/mdast-util-to-string/lib/index.cjs');
-const require_index$1 = require('../../../../../../../node_modules/.pnpm/remark-gfm@4.0.1/node_modules/remark-gfm/lib/index.cjs');
-const require_index$2 = require('../../../../../../../node_modules/.pnpm/remark-stringify@11.0.0/node_modules/remark-stringify/lib/index.cjs');
-const require_index$3 = require('../../../../../../../node_modules/.pnpm/unified@11.0.5/node_modules/unified/lib/index.cjs');
-const require_dependency_table = require('../schemas/dependency-table.cjs');
-let effect = require("effect");
-
-//#region ../silk-effects/dist/dev/pkg/changesets/utils/dependency-table.js
-/**
-* Dependency table utilities for parsing, serializing, collapsing, and sorting
-* dependency table rows between MDAST table nodes and typed representations.
-*
-* @remarks
-* This module provides the low-level functional primitives that the
-* {@link DependencyTable} class wraps with a stateful, fluent API.
-* It operates on arrays of `DependencyTableRow` objects and MDAST `Table`
-* nodes, converting between the two representations.
-*
-* The collapse algorithm merges rows sharing the same `dependency + type`
-* key, applying semantic rules (e.g., added then removed = net zero).
-* Sorting follows a stable order: removed, updated, added, then
-* alphabetically by type and dependency name.
-*
-* @see {@link DependencyTable} for the public class-based API
-*
-* @internal
-*/
-/**
-* Ordered column headers for dependency tables.
-*
-* Defines the canonical header row: `Dependency | Type | Action | From | To`.
-*
-* @internal
-*/
-const COLUMN_HEADERS = [
-	"Dependency",
-	"Type",
-	"Action",
-	"From",
-	"To"
-];
-/**
-* Property keys on {@link DependencyTableRow} corresponding to each column
-* in {@link COLUMN_HEADERS}.
-*
-* Used to map between positional table cells and typed object fields.
-*
-* @internal
-*/
-const COLUMN_KEYS = [
-	"dependency",
-	"type",
-	"action",
-	"from",
-	"to"
-];
-/** Schema decoder for validating raw cell values into a typed row. */
-const decode = effect.Schema.decodeUnknownSync(require_dependency_table.DependencyTableRowSchema);
-/**
-* Parse an MDAST table node into validated dependency table rows.
-*
-* @remarks
-* Validates the header row against {@link COLUMN_HEADERS} (case-insensitive),
-* then decodes each data row through the `DependencyTableRowSchema` for
-* type-safe validation of action values, version strings, and dependency types.
-*
-* @param table - An MDAST `Table` node (from remark-gfm)
-* @returns Array of validated `DependencyTableRow` objects
-* @throws If the table has fewer than 2 rows (header + at least one data row)
-* @throws If the header columns do not match the expected column names
-* @throws If any data row fails schema validation
-*
-* @example
-* ```typescript
-* import { parseDependencyTable } from "../utils/dependency-table.js";
-* import { parseMarkdown } from "../utils/remark-pipeline.js";
-* import type { Table } from "mdast";
-*
-* const tree = parseMarkdown("| Dependency | Type | Action | From | To |\n| --- | --- | --- | --- | --- |\n| foo | dependency | added | — | 1.0.0 |");
-* const table = tree.children.find((n) => n.type === "table") as Table;
-* const rows = parseDependencyTable(table);
-* // rows[0].dependency === "foo"
-* ```
-*
-* @internal
-*/
-function parseDependencyTable(table) {
-	const rows = table.children;
-	if (rows.length < 2) throw new Error("Dependency table must have at least one data row");
-	const headers = rows[0].children.map((cell) => require_index.toString(cell).trim().toLowerCase());
-	const expected = COLUMN_HEADERS.map((h) => h.toLowerCase());
-	if (headers.length !== expected.length || !headers.every((h, i) => h === expected[i])) throw new Error(`Table must have columns: ${COLUMN_HEADERS.join(", ")}. Got: ${headers.join(", ")}`);
-	const result = [];
-	for (let i = 1; i < rows.length; i++) {
-		const cells = rows[i].children;
-		const raw = {};
-		for (let c = 0; c < COLUMN_KEYS.length; c++) raw[COLUMN_KEYS[c]] = require_index.toString(cells[c]).trim();
-		result.push(decode(raw));
-	}
-	return result;
-}
-/**
-* Create a table cell with a text node.
-*
-* @param text - The cell text content
-* @returns An MDAST `TableCell` node
-*
-* @internal
-*/
-function makeCell(text) {
-	return {
-		type: "tableCell",
-		children: [{
-			type: "text",
-			value: text
-		}]
-	};
-}
-/**
-* Create a table row from an array of cell texts.
-*
-* @param texts - Array of cell text values
-* @returns An MDAST `TableRow` node
-*
-* @internal
-*/
-function makeRow(texts) {
-	return {
-		type: "tableRow",
-		children: texts.map(makeCell)
-	};
-}
-/**
-* Serialize dependency table rows into an MDAST `Table` node.
-*
-* @remarks
-* Creates a well-formed GFM table with the canonical header row
-* ({@link COLUMN_HEADERS}) followed by one data row per entry.
-* The inverse of {@link parseDependencyTable}.
-*
-* @param rows - Array of `DependencyTableRow` objects
-* @returns An MDAST `Table` node ready for insertion into an AST
-*
-* @example
-* ```typescript
-* import { serializeDependencyTable } from "../utils/dependency-table.js";
-* import type { DependencyTableRow } from "../schemas/dependency-table.js";
-*
-* const rows: DependencyTableRow[] = [
-*   { dependency: "effect", type: "dependency", action: "updated", from: "3.18.0", to: "3.19.0" },
-* ];
-* const table = serializeDependencyTable(rows);
-* // table.type === "table"
-* // table.children.length === 2 (header + 1 data row)
-* ```
-*
-* @internal
-*/
-function serializeDependencyTable(rows) {
-	return {
-		type: "table",
-		children: [makeRow([...COLUMN_HEADERS]), ...rows.map((row) => makeRow(COLUMN_KEYS.map((key) => row[key])))]
-	};
-}
-/**
-* Serialize dependency table rows to a markdown table string.
-*
-* @remarks
-* Combines {@link serializeDependencyTable} with unified/remark-gfm/remark-stringify
-* to produce a ready-to-use GFM markdown table string. The result is trimmed
-* of leading/trailing whitespace.
-*
-* @param rows - Array of `DependencyTableRow` objects
-* @returns Markdown table string (GFM format)
-*
-* @example
-* ```typescript
-* import { serializeDependencyTableToMarkdown } from "../utils/dependency-table.js";
-* import type { DependencyTableRow } from "../schemas/dependency-table.js";
-*
-* const rows: DependencyTableRow[] = [
-*   { dependency: "effect", type: "dependency", action: "updated", from: "3.18.0", to: "3.19.0" },
-* ];
-* const md = serializeDependencyTableToMarkdown(rows);
-* // "| Dependency | Type | Action | From | To |\n| --- | --- | ..."
-* ```
-*
-* @internal
-*/
-function serializeDependencyTableToMarkdown(rows) {
-	const tree = {
-		type: "root",
-		children: [serializeDependencyTable(rows)]
-	};
-	return require_index$3.unified().use(require_index$1.default).use(require_index$2.default).stringify(tree).trim();
-}
-/**
-* Sort priority for dependency actions: removed first, then updated, then added.
-*
-* @remarks
-* Used by {@link sortDependencyRows} for primary sort ordering. The numeric
-* values define the sort position (lower = earlier in the sorted output).
-*
-* @internal
-*/
-const ACTION_ORDER = {
-	removed: 0,
-	updated: 1,
-	added: 2
-};
-/**
-* Collapse dependency table rows with the same `dependency + type` key.
-*
-* @remarks
-* When multiple changelog entries affect the same dependency, this function
-* merges them into a single row using semantic collapse rules. Rows are
-* grouped by a composite key of `dependency\0type` (null-byte separated).
-*
-* The collapse rules applied by {@link collapseTwo} are:
-*
-* | First action | Second action | Result |
-* |---|---|---|
-* | `updated` | `updated` | `updated` (earliest `from`, latest `to`) |
-* | `added` | `updated` | `added` (final `to`) |
-* | `added` | `removed` | dropped (net zero change) |
-* | `updated` | `removed` | `removed` (original `from`) |
-* | `removed` | `added` | `updated` (original `from`, new `to`) |
-* | other | other | keep later entry |
-*
-* @param rows - Array of `DependencyTableRow` objects (in chronological order)
-* @returns Collapsed array with at most one row per `dependency + type` pair
-*
-* @example
-* ```typescript
-* import { collapseDependencyRows } from "../utils/dependency-table.js";
-* import type { DependencyTableRow } from "../schemas/dependency-table.js";
-*
-* const rows: DependencyTableRow[] = [
-*   { dependency: "effect", type: "dependency", action: "updated", from: "3.17.0", to: "3.18.0" },
-*   { dependency: "effect", type: "dependency", action: "updated", from: "3.18.0", to: "3.19.0" },
-* ];
-* const collapsed = collapseDependencyRows(rows);
-* // collapsed[0].from === "3.17.0", collapsed[0].to === "3.19.0"
-* ```
-*
-* @see {@link DependencyTable} for the public API that wraps this function
-*
-* @internal
-*/
-function collapseDependencyRows(rows) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const key = `${row.dependency}\0${row.type}`;
-		const existing = groups.get(key);
-		if (!existing) {
-			groups.set(key, { ...row });
-			continue;
-		}
-		const merged = collapseTwo(existing, row);
-		if (merged === null) groups.delete(key);
-		else groups.set(key, merged);
-	}
-	return [...groups.values()];
-}
-/**
-* Collapse two rows sharing the same `dependency + type` key into one,
-* or return `null` if they cancel out (net zero).
-*
-* @remarks
-* This is the core merge function called by {@link collapseDependencyRows}.
-* It applies the semantic collapse rules based on the action pair.
-* See {@link collapseDependencyRows} for the full rule table.
-*
-* @param first - The earlier (existing) row
-* @param second - The later (incoming) row
-* @returns The merged row, or `null` to drop the entry entirely
-*
-* @internal
-*/
-function collapseTwo(first, second) {
-	const a = first.action;
-	const b = second.action;
-	if (a === "updated" && b === "updated") return {
-		...first,
-		to: second.to
-	};
-	if (a === "added" && b === "updated") return {
-		...first,
-		to: second.to
-	};
-	if (a === "added" && b === "removed") return null;
-	if (a === "updated" && b === "removed") return {
-		...first,
-		action: "removed",
-		to: "—"
-	};
-	if (a === "removed" && b === "added") return {
-		...first,
-		action: "updated",
-		to: second.to
-	};
-	return { ...second };
-}
-/**
-* Sort dependency table rows into canonical display order.
-*
-* @remarks
-* Applies a three-level stable sort:
-* 1. **Action** — `removed` first, then `updated`, then `added`
-*    (per {@link ACTION_ORDER})
-* 2. **Type** — alphabetically (e.g., `config` before `dependency`)
-* 3. **Dependency name** — alphabetically within each action+type group
-*
-* Returns a new array; the input is not mutated.
-*
-* @param rows - Array of `DependencyTableRow` objects
-* @returns New sorted array
-*
-* @example
-* ```typescript
-* import { sortDependencyRows } from "../utils/dependency-table.js";
-* import type { DependencyTableRow } from "../schemas/dependency-table.js";
-*
-* const rows: DependencyTableRow[] = [
-*   { dependency: "zod", type: "dependency", action: "added", from: "\u2014", to: "3.0.0" },
-*   { dependency: "effect", type: "dependency", action: "removed", from: "3.19.0", to: "\u2014" },
-* ];
-* const sorted = sortDependencyRows(rows);
-* // sorted[0].dependency === "effect" (removed comes first)
-* ```
-*
-* @see {@link DependencyTable} for the public API that wraps this function
-*
-* @internal
-*/
-function sortDependencyRows(rows) {
-	return [...rows].sort((a, b) => {
-		const actionDiff = (ACTION_ORDER[a.action] ?? 99) - (ACTION_ORDER[b.action] ?? 99);
-		if (actionDiff !== 0) return actionDiff;
-		const typeDiff = a.type.localeCompare(b.type);
-		if (typeDiff !== 0) return typeDiff;
-		return a.dependency.localeCompare(b.dependency);
-	});
-}
-
-//#endregion
-exports.collapseDependencyRows = collapseDependencyRows;
-exports.parseDependencyTable = parseDependencyTable;
-exports.serializeDependencyTable = serializeDependencyTable;
-exports.serializeDependencyTableToMarkdown = serializeDependencyTableToMarkdown;
-exports.sortDependencyRows = sortDependencyRows;