@jigs.design/compiler 0.0.0-stage → 0.1.0

package/dist/signature.js

@@ -0,0 +1,25 @@
+import { parsePickle } from "./parse.js";
+//#region src/signature.ts
+function formatAttr(prop) {
+	if (prop.shorthand === true) return prop.name;
+	if (prop.value.kind === "literal") return typeof prop.value.value === "string" ? `${prop.name}=${JSON.stringify(prop.value.value)}` : `${prop.name}={${JSON.stringify(prop.value.value)}}`;
+	return `${prop.name}={${prop.value.code}}`;
+}
+/** A `<slot/>` anywhere in the define's body, ignoring nested defines. */
+function hasSlot(nodes) {
+	for (const node of nodes) {
+		if (node.type !== "element" || node.name === "define") continue;
+		if (node.name === "slot" || hasSlot(node.children)) return true;
+	}
+	return false;
+}
+/** `<statCard label value delta={0} note="">…</statCard>` when the define has a slot. */
+function recipeSignature(recipe) {
+	const define = parsePickle(recipe.source).children.find((node) => node.type === "element" && node.name === "define");
+	if (define === void 0) return `<${recipe.name}>`;
+	const attrs = define.props.filter((prop) => prop.name !== "name").map((prop) => formatAttr(prop));
+	const open = attrs.length === 0 ? `<${recipe.name}>` : `<${recipe.name} ${attrs.join(" ")}>`;
+	return hasSlot(define.children) ? `${open}…</${recipe.name}>` : open;
+}
+//#endregion
+export { recipeSignature };

package/dist/spec.d.ts

@@ -0,0 +1,29 @@
+//#region src/spec.d.ts
+/** What the compiler checks a literal prop against. */
+export type PropSpec = {
+  kind: "boolean";
+} | {
+  default?: string;
+  kind: "enum";
+  values: ReadonlyArray<string>;
+} | {
+  kind: "handler";
+} | {
+  default?: number;
+  kind: "number";
+  max?: number;
+  min?: number;
+} | {
+  kind: "rows";
+} | {
+  kind: "string";
+};
+/** One component the compiler knows: what it may contain and its props. */
+export interface ComponentSpec {
+  /** What the component may contain; `none` drops children at compile time. */
+  children: "block" | "inline" | "none";
+  props: Readonly<Record<string, PropSpec>>;
+}
+/** The components a document may use, by tag name. */
+export type CompileCatalog = Readonly<Record<string, ComponentSpec>>;
+//#endregion

package/dist/spec.js

@@ -0,0 +1,14 @@
+//#region src/spec.ts
+/** Whether a literal written in the source fits `spec`. */
+function isValidValue(spec, value) {
+	switch (spec.kind) {
+		case "boolean": return typeof value === "boolean";
+		case "enum": return typeof value === "string" && spec.values.includes(value);
+		case "number": return typeof value === "number" && Number.isFinite(value) && (spec.min === void 0 || value >= spec.min) && (spec.max === void 0 || value <= spec.max);
+		case "string": return typeof value === "string";
+		case "handler":
+		case "rows": return false;
+	}
+}
+//#endregion
+export { isValidValue };

package/dist/suggest.d.ts

@@ -0,0 +1,8 @@
+//#region src/suggest.d.ts
+/**
+ * Up to `count` candidates closest to `name`, nearest first. A candidate that
+ * contains `name` or is contained in it counts as close; otherwise it must be
+ * within a third of the name's length.
+ */
+export declare function nearest(name: string, candidates: Iterable<string>, count: number): Array<string>;
+//#endregion

package/dist/suggest.js

@@ -0,0 +1,53 @@
+//#region src/suggest.ts
+/** Edit distance, case-insensitive, where swapping two neighbours counts as one edit. */
+function distance(a, b) {
+	const left = a.toLowerCase();
+	const right = b.toLowerCase();
+	const rows = [Array.from({ length: right.length + 1 }, (_, index) => index)];
+	for (let row = 1; row <= left.length; row++) {
+		const current = [row];
+		const above = rows[row - 1] ?? [];
+		for (let column = 1; column <= right.length; column++) {
+			const cost = left.charAt(row - 1) === right.charAt(column - 1) ? 0 : 1;
+			let best = Math.min((above[column] ?? 0) + 1, (current[column - 1] ?? 0) + 1, (above[column - 1] ?? 0) + cost);
+			if (row > 1 && column > 1 && left.charAt(row - 1) === right.charAt(column - 2) && left.charAt(row - 2) === right.charAt(column - 1)) best = Math.min(best, (rows[row - 2]?.[column - 2] ?? 0) + 1);
+			current.push(best);
+		}
+		rows.push(current);
+	}
+	return rows[left.length]?.[right.length] ?? 0;
+}
+/**
+* Up to `count` candidates closest to `name`, nearest first. A candidate that
+* contains `name` or is contained in it counts as close; otherwise it must be
+* within a third of the name's length.
+*/
+function nearest(name, candidates, count) {
+	const lower = name.toLowerCase();
+	const limit = Math.max(1, Math.floor(name.length / 3));
+	const scored = [];
+	for (const candidate of candidates) {
+		if (candidate === name) continue;
+		const other = candidate.toLowerCase();
+		const contains = Math.min(lower.length, other.length) >= 3 && (other.includes(lower) || lower.includes(other));
+		const score = distance(name, candidate);
+		if (score <= limit || contains) scored.push({
+			candidate,
+			score: contains ? Math.min(score, limit) : score
+		});
+	}
+	return scored.toSorted((a, b) => a.score - b.score || a.candidate.localeCompare(b.candidate)).slice(0, count).map((entry) => entry.candidate);
+}
+/** The `count` candidates nearest to `name`, however far, for listing a few alternatives. */
+function closest(name, candidates, count) {
+	const lower = name.toLowerCase();
+	return candidates.map((candidate) => {
+		const other = candidate.toLowerCase();
+		return {
+			candidate,
+			score: Math.min(lower.length, other.length) >= 3 && (other.includes(lower) || lower.includes(other)) ? 0 : distance(name, candidate)
+		};
+	}).toSorted((a, b) => a.score - b.score || a.candidate.localeCompare(b.candidate)).slice(0, count).map((entry) => entry.candidate);
+}
+//#endregion
+export { closest, nearest };

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "@jigs.design/compiler",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Today's Pickle compiler: parser, checker against a catalog, code generator, recipes, and the edit helpers. The v2 rewrite replaces it.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/yoamomonstruos/pickle.git",
+    "directory": "packages/compiler"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "acorn": "8.19.0"
+  }
 }