@parity-app/cli 0.6.1 → 0.6.3

package/dist/src-DzU4U2rh.mjs

@@ -0,0 +1,129 @@
+import { a as applyLibraryEdits, f as parseLibraryEdits, p as parseLibraryManifest, u as libraryManifestExtension } from "./src-YQY8r4mh.mjs";
+import { createRequire } from "node:module";
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { existsSync } from "node:fs";
+import semver from "semver";
+// ../core/src/jsonc.ts
+/** Parses JSON with comments and trailing commas, as tsconfig files allow. Comment markers inside strings are kept. */
+function parseJsonc(text) {
+	let output = "";
+	let index = 0;
+	while (index < text.length) {
+		const char = text[index];
+		if (char === "\"") {
+			const start = index++;
+			while (index < text.length && text[index] !== "\"") index += text[index] === "\\" ? 2 : 1;
+			output += text.slice(start, ++index);
+		} else if (char === "/" && text[index + 1] === "/") while (index < text.length && text[index] !== "\n") index++;
+		else if (char === "/" && text[index + 1] === "*") {
+			const end = text.indexOf("*/", index + 2);
+			index = end === -1 ? text.length : end + 2;
+		} else {
+			output += char;
+			index++;
+		}
+	}
+	return JSON.parse(output.replace(/,(\s*[}\]])/g, "$1"));
+}
+// ../registry/src/index.ts
+const require = createRequire(import.meta.url);
+/**
+* The folder the registry's files are in. The published CLI bundles this module and ships the files beside it, where
+* the package can't be resolved. Otherwise they're found through the package's own `package.json`, so it's the same
+* whether this module runs from source or bundled into the app.
+*/
+function registryDir() {
+	const bundled = join(import.meta.dirname, "libraries");
+	if (existsSync(bundled)) return bundled;
+	return join(dirname(require.resolve("@parity-app/registry/package.json")), "libraries");
+}
+let cache;
+/** Every file in the registry, read once. One that doesn't parse is skipped with a warning. */
+function registryEntries(dir = registryDir()) {
+	if (dir !== registryDir()) return readEntries(dir);
+	cache ??= readEntries(dir);
+	return cache;
+}
+async function readEntries(dir) {
+	const files = (await readdir(dir).catch(() => [])).filter((file) => file.endsWith(libraryManifestExtension)).sort();
+	const entries = [];
+	for (const file of files) {
+		const path = join(dir, file);
+		try {
+			const manifest = parseLibraryManifest(JSON.parse(await readFile(path, "utf8")));
+			if (!manifest.package) throw new TypeError("/package: a registry file names the package it describes");
+			entries.push({
+				file,
+				path,
+				manifest
+			});
+		} catch (error) {
+			console.warn(`Skipping registry file ${file}: ${errorText(error)}`);
+		}
+	}
+	return entries;
+}
+/**
+* The newest file for each package the registry describes, by the version it was made from, with its hand edits
+* applied. A file whose edits can't be read is used as it is, with a warning.
+*/
+async function newestEntries(dir) {
+	const newest = /* @__PURE__ */ new Map();
+	for (const entry of await registryEntries(dir)) {
+		const name = entry.manifest.package.name;
+		const current = newest.get(name);
+		if (!current || compareGenerated(entry.manifest, current.manifest) > 0) newest.set(name, entry);
+	}
+	return Promise.all([...newest.values()].map(async (entry) => {
+		try {
+			return {
+				...entry,
+				manifest: (await withEdits(entry.path, entry.manifest)).manifest
+			};
+		} catch (error) {
+			console.warn(`Using registry file ${entry.file} without its edits: ${errorText(error)}`);
+			return entry;
+		}
+	}));
+}
+/**
+* A library file at `path` with its hand edits applied: its own `edits`, or the shared file it names beside it. Edits
+* for exports it doesn't have are its `orphans`, reported rather than dropped silently. Throws when the edits can't be
+* read.
+*/
+async function withEdits(path, manifest) {
+	if (manifest.edits === void 0) return {
+		manifest,
+		orphans: []
+	};
+	return applyLibraryEdits(manifest, await readLibraryEdits(manifest.edits, dirname(path)));
+}
+/**
+* Hand edits as a library file writes them: inline, or the path of a shared file, which is read from `from` and may
+* have comments.
+*/
+async function readLibraryEdits(edits, from) {
+	return parseLibraryEdits(typeof edits === "string" ? parseJsonc(await readFile(resolve(from, edits), "utf8")) : edits);
+}
+function errorText(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/** Whether a manifest describes this version of its package. A manifest without a range covers every version. */
+function covers(manifest, version) {
+	const range = manifest.package?.range;
+	if (!range) return true;
+	if (!version) return false;
+	const parsed = semver.coerce(version, { includePrerelease: true });
+	return parsed !== null && semver.satisfies(parsed, range, { includePrerelease: true });
+}
+function compareGenerated(a, b) {
+	const left = semver.coerce(a.package?.version);
+	const right = semver.coerce(b.package?.version);
+	if (!left || !right) {
+		if (left) return 1;
+		return right ? -1 : 0;
+	}
+	return semver.compare(left, right);
+}
+export { registryEntries as a, registryDir as i, newestEntries as n, withEdits as o, readLibraryEdits as r, parseJsonc as s, covers as t };

package/dist/{src-C4faIpux.mjs → src-YQY8r4mh.mjs}

@@ -1,12 +1,34 @@
-import "./schema-BpGSCLEu.mjs";
+import "./schema-CiVy9tZT.mjs";
 import { z } from "zod";
 // ../core/src/adapters.ts
 const packageVersions = z.record(z.string(), z.string());
-z.looseObject({
+const exportsTarget = z.lazy(() => z.union([
+	z.string(),
+	z.null(),
+	z.array(exportsTarget),
+	z.record(z.string(), exportsTarget)
+]));
+/**
+* The parts of a package.json Parity reads: the dependencies adapters detect a stack by, and where an installed
+* package's entry points and a workspace's packages are (PAR-573). It's someone else's file, so the fields Parity
+* doesn't read pass through unchecked.
+*/
+const packageManifest = z.looseObject({
 	name: z.string().optional(),
+	version: z.string().optional(),
 	dependencies: packageVersions.optional(),
 	devDependencies: packageVersions.optional(),
-	scripts: z.record(z.string(), z.string()).optional()
+	scripts: z.record(z.string(), z.string()).optional(),
+	/** Entry points by subpath (`.`, `./tailwind.css`), or where the package's one entry point leads. */
+	exports: exportsTarget.optional(),
+	types: z.string().optional(),
+	typings: z.string().optional(),
+	module: z.string().optional(),
+	main: z.string().optional(),
+	/** The stylesheet a project imports to use the package, as some packages name it. */
+	style: z.string().optional(),
+	/** A workspace root's package folders, as npm, Yarn and Bun write them. */
+	workspaces: z.union([z.array(z.string()), z.looseObject({ packages: z.array(z.string()).optional() })]).optional()
 });
 // ../core/src/devices.ts
 const deviceKinds = [
@@ -1341,7 +1363,8 @@ function expectStringRecord(value, path) {
 const named = /* @__PURE__ */ new WeakSet();
 /**
 * A new node for a component, ready to show something: required props get their default or first option, and a
-* component that takes children gets its own name as text, so it isn't an empty box, unless `given` has its own.
+* component that takes children gets its own name as text, so it isn't an empty box, unless `given` has its own or the
+* component sets its own size (`fixedSize`), where the name would be cut off ("Avata").
 */
 function componentNode(component, info, taken, given = {}) {
 	const props = { ...given };
@@ -1353,7 +1376,7 @@ function componentNode(component, info, taken, given = {}) {
 		else if (prop.kind === "number") props[prop.name] = 0;
 		else if (prop.kind === "string") props[prop.name] = prop.name;
 	}
-	const labelled = !("children" in given) && info?.props.some((prop) => prop.name === "children" && prop.kind === "node");
+	const labelled = !("children" in given) && !info?.fixedSize && info?.props.some((prop) => prop.name === "children" && prop.kind === "node");
 	if (labelled) props.children = component.split("/").at(-1) ?? component;
 	const node = {
 		type: "component",
@@ -1434,10 +1457,10 @@ function withLibraryContext(node, sources, around, taken) {
 		};
 	};
 	let placed = node;
-	const sample = source.sample;
+	const sample = source.sample ?? (named.has(node) ? usedIn(node.component, sources) : void 0);
 	if (sample) {
 		const given = { ...node.props };
-		if (sample.props && "children" in sample.props && named.has(node)) delete given.children;
+		if (named.has(node)) delete given.children;
 		const { props, slots } = held({
 			...sample.props,
 			...given
@@ -1514,6 +1537,39 @@ function withLibraryContext(node, sources, around, taken) {
 	}
 }
 /**
+* How a part with no sample of its own is used in its library's other samples: with the children the first use gives it,
+* or none when it's used without any (`<MarkerIcon />`) or with elements the sample can't show (an icon, `[]`).
+* Undefined when no sample uses it.
+*/
+function usedIn(component, sources) {
+	const find = (children) => {
+		for (const child of children ?? []) {
+			if (typeof child === "string") continue;
+			if (isSampleRender(child)) {
+				const found = find(child.$render);
+				if (found) return found;
+				continue;
+			}
+			if (child.component === component) return child;
+			const found = find(child.children) ?? find(elementProps(child.props));
+			if (found) return found;
+		}
+	};
+	const library = sources[component]?.library;
+	for (const source of Object.values(sources)) {
+		if (source.library !== library || !source.sample) continue;
+		const found = find(source.sample.children) ?? find(elementProps(source.sample.props));
+		if (found) return { children: found.children ?? [] };
+	}
+}
+/** The elements and render functions a sample gives as props' values, as children are. */
+function elementProps(props) {
+	return Object.values(props ?? {}).flatMap((value) => {
+		if (isSampleRender(value)) return [value];
+		return isSampleElement(value) ? value.$element : [];
+	});
+}
+/**
 * A library file's component as the canvas inserts it, with its parents and sample named by component id.
 * Discovery has already rewritten module imports for the name the project installed the package under.
 */
@@ -1564,4 +1620,4 @@ function sampleIds(sample, library) {
 		...sample.children ? { children: sample.children.map(child) } : {}
 	};
 }
-export { deviceKinds as A, parseCanvasDocument as C, collectCustomProperties as D, parseModeSettings as E, viewportHeightProperty as O, paramTypes as S, generateId as T, imageFits as _, applyLibraryEdits as a, linkEndKinds as b, isSampleElement as c, parentSignals as d, parseLibraryEdits as f, containerKinds as g, canvasObjectKinds as h, withLibraryContext as i, lengthToPixels as j, viewportWidthProperty as k, isSampleRender as l, renderSlotOf as m, librarySource as n, componentEvidence as o, parseLibraryManifest as p, sampleIds as r, isMadeValue as s, componentNode as t, libraryManifestExtension as u, lenses as v, styleKeys as w, linkTypes as x, linkAllowed as y };
+export { deviceKinds as A, parseCanvasDocument as C, collectCustomProperties as D, parseModeSettings as E, packageManifest as M, viewportHeightProperty as O, paramTypes as S, generateId as T, imageFits as _, applyLibraryEdits as a, linkEndKinds as b, isSampleElement as c, parentSignals as d, parseLibraryEdits as f, containerKinds as g, canvasObjectKinds as h, withLibraryContext as i, lengthToPixels as j, viewportWidthProperty as k, isSampleRender as l, renderSlotOf as m, librarySource as n, componentEvidence as o, parseLibraryManifest as p, sampleIds as r, isMadeValue as s, componentNode as t, libraryManifestExtension as u, lenses as v, styleKeys as w, linkTypes as x, linkAllowed as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parity-app/cli",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "license": "MIT",
   "type": "module",
   "description": "Drive the Parity app from a terminal or an agent: read state, run edits, take screenshots, serve MCP.",

package/dist/schema-BpGSCLEu.mjs

@@ -1,113 +0,0 @@
-import { z } from "zod";
-// ../core/src/errors.ts
-/**
-* Why an agent's call failed, as a stable code it can act on without reading the message. The CLI and MCP publish
-* these; the app throws them where it knows the cause.
-*/
-const errorCodes = [
-	"invalid_input",
-	"not_running",
-	"not_answering",
-	"unknown_tab",
-	"tab_not_ready",
-	"unknown_design",
-	"unknown_node",
-	"ambiguous_reference",
-	"unknown_state",
-	"unknown_mode",
-	"unknown_viewport",
-	"unknown_component",
-	"unknown_icon_set",
-	"unknown_edit_id",
-	"conflict",
-	"execution_failed",
-	"app_error"
-];
-/** Details as another process sends them. Each field that's malformed falls back on its own; only the code must hold. */
-const errorDetailsSchema = z.object({
-	code: z.enum(errorCodes),
-	/** Whether sending the same request again, unchanged, can succeed. */
-	retryable: z.boolean().catch(false),
-	/** The request field at fault, as a path: `design`, `state`, `edits/0/find`. */
-	field: z.string().min(1).optional().catch(void 0),
-	/** Valid references to use instead of an unknown or ambiguous one, at most `alternativeLimit` of them. */
-	alternatives: z.array(z.unknown()).transform((items) => items.filter((item) => typeof item === "string").slice(0, 20)).optional().catch(void 0)
-});
-/** An error with a stable code, the field it's about and what to use instead. */
-var CodedError = class extends Error {
-	details;
-	constructor(message, details) {
-		super(message);
-		this.name = "CodedError";
-		this.details = {
-			...details,
-			retryable: details.retryable ?? false
-		};
-	}
-};
-/** An unknown reference, naming the valid ones closest to what was asked for, up to `alternativeLimit`. */
-function unknownReference(code, message, reference, candidates, field) {
-	return new CodedError(message, {
-		code,
-		...field === void 0 ? {} : { field },
-		alternatives: closest(reference, candidates)
-	});
-}
-/**
-* Candidates sharing text with the reference first, ignoring case, then the rest by how few single-character edits
-* away they are, so a typo's intended id makes the cut; ties keep their own order. All of them when they fit.
-*/
-function closest(reference, candidates, limit = 20) {
-	const unique = [...new Set(candidates)];
-	if (unique.length <= limit) return unique;
-	const wanted = reference.toLowerCase();
-	const ranked = unique.map((candidate, index) => {
-		const lower = candidate.toLowerCase();
-		const near = wanted.length > 0 && (lower.includes(wanted) || wanted.includes(lower));
-		return {
-			candidate,
-			index,
-			near: near ? 0 : 1,
-			distance: near ? 0 : editDistance(wanted, lower)
-		};
-	});
-	ranked.sort((a, b) => a.near - b.near || a.distance - b.distance || a.index - b.index);
-	return ranked.slice(0, limit).map(({ candidate }) => candidate);
-}
-/** How many single-character insertions, deletions or substitutions turn one string into the other. */
-function editDistance(a, b) {
-	let previous = Array.from({ length: b.length + 1 }, (_, index) => index);
-	for (let i = 1; i <= a.length; i++) {
-		const row = [i];
-		for (let j = 1; j <= b.length; j++) row[j] = Math.min(previous[j] + 1, row[j - 1] + 1, previous[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
-		previous = row;
-	}
-	return previous[b.length];
-}
-/** A thrown value's details, when it carries them. */
-function errorDetails(error) {
-	return error instanceof CodedError ? error.details : void 0;
-}
-/** Details that came from another process, checked before they're trusted. Anything malformed reads as none. */
-function readErrorDetails(value) {
-	return errorDetailsSchema.safeParse(value).data;
-}
-z.record(z.string(), z.unknown());
-/** Text with something besides whitespace, trimmed. */
-const nonBlankString = z.string().trim().min(1, "can't be blank");
-z.number();
-/** JSON text holding what `schema` checks. Text that isn't JSON fails as `expected JSON`. */
-function jsonText(schema) {
-	return z.string().transform((text, context) => {
-		try {
-			return JSON.parse(text);
-		} catch {
-			context.addIssue({
-				code: "custom",
-				message: "expected JSON"
-			});
-			return z.NEVER;
-		}
-	}).pipe(schema);
-}
-export { errorCodes as a, unknownReference as c, closest as i, nonBlankString as n, errorDetails as o, CodedError as r, readErrorDetails as s, jsonText as t };

package/dist/src-5CrSA_RX.mjs

@@ -1,53 +0,0 @@
-import { p as parseLibraryManifest, u as libraryManifestExtension } from "./src-C4faIpux.mjs";
-import { createRequire } from "node:module";
-import { readFile, readdir } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { existsSync } from "node:fs";
-import semver from "semver";
-// ../registry/src/index.ts
-const require = createRequire(import.meta.url);
-/**
-* The folder the registry's files are in. The published CLI bundles this module and ships the files beside it, where
-* the package can't be resolved. Otherwise they're found through the package's own `package.json`, so it's the same
-* whether this module runs from source or bundled into the app.
-*/
-function registryDir() {
-	const bundled = join(import.meta.dirname, "libraries");
-	if (existsSync(bundled)) return bundled;
-	return join(dirname(require.resolve("@parity-app/registry/package.json")), "libraries");
-}
-let cache;
-/** Every file in the registry, read once. One that doesn't parse is skipped with a warning. */
-function registryEntries(dir = registryDir()) {
-	if (dir !== registryDir()) return readEntries(dir);
-	cache ??= readEntries(dir);
-	return cache;
-}
-async function readEntries(dir) {
-	const files = (await readdir(dir).catch(() => [])).filter((file) => file.endsWith(libraryManifestExtension)).sort();
-	const entries = [];
-	for (const file of files) {
-		const path = join(dir, file);
-		try {
-			const manifest = parseLibraryManifest(JSON.parse(await readFile(path, "utf8")));
-			if (!manifest.package) throw new TypeError("/package: a registry file names the package it describes");
-			entries.push({
-				file,
-				path,
-				manifest
-			});
-		} catch (error) {
-			console.warn(`Skipping registry file ${file}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	return entries;
-}
-/** Whether a manifest describes this version of its package. A manifest without a range covers every version. */
-function covers(manifest, version) {
-	const range = manifest.package?.range;
-	if (!range) return true;
-	if (!version) return false;
-	const parsed = semver.coerce(version, { includePrerelease: true });
-	return parsed !== null && semver.satisfies(parsed, range, { includePrerelease: true });
-}
-export { registryDir as n, registryEntries as r, covers as t };

package/dist/src-Cr8pfFJE.mjs

@@ -1 +0,0 @@
-export { t as covers, n as registryDir, r as registryEntries } from "./src-5CrSA_RX.mjs";

package/dist/src-p0vFxRBz.mjs

@@ -1,3 +0,0 @@
-import "./schema-BpGSCLEu.mjs";
-export { a as applyLibraryEdits, t as componentNode, T as generateId, n as librarySource, f as parseLibraryEdits, i as withLibraryContext } from "./src-C4faIpux.mjs";
-import "./src-Zm_PYFFH.mjs";