@acid-cat/catalog 0.10.0 → 0.10.2

package/README.md

@@ -9,6 +9,8 @@ pnpm add -D @acid-cat/catalog
 ```
 
 ```ts
+import { writeFile } from "node:fs/promises";
+
 import { Catalog } from "@acid-cat/catalog";
 
 const catalog = new Catalog({ title: "Neighbourhood lending library" });

package/dist/canonical.d.ts

@@ -4,7 +4,5 @@
  */
 /** A catalog in canonical form, as text. */
 export declare function canonicalText(catalog: unknown): string;
-/** Put a catalog's members in canonical order. */
-export declare function canonicalCatalog(catalog: unknown): unknown;
 /** Order strings by Unicode code point, as Python, Go and Rust compare them. */
 export declare function byCodePoint(left: string, right: string): number;

package/dist/canonical.js

@@ -1,4 +1,4 @@
-//#region src/canonical.ts
+// src/canonical.ts
 const isObject = (value) => value !== null && typeof value === "object";
 const CATALOG_ORDER = [
 	"acidcat",
@@ -33,7 +33,10 @@ const EVENT_ORDER = [
 function canonicalText(catalog) {
 	return `${write(canonicalCatalog(catalog), "")}\n`;
 }
-/** Put a catalog's members in canonical order. */
+/**
+* Put a catalog's members in canonical order. Each object becomes a `Map`, not a plain object, because a plain object
+* puts integer-like keys such as "9" and "10" first, in numeric order, whatever order they were added in.
+*/
 function canonicalCatalog(catalog) {
 	return ordered(catalog, CATALOG_ORDER, (key, value) => {
 		if (key === "targets") return byKey(value, (target) => ordered(target, TARGET_ORDER, sortedMember));
@@ -45,15 +48,15 @@ function canonicalCatalog(catalog) {
 }
 /** The known members in their order, then every other member sorted by key. A value that is not an object is sorted. */
 function ordered(value, order, each) {
-	if (!isObject(value)) return sorted(value);
-	const known = order.filter((key) => key in value);
+	if (!isObject(value) || Array.isArray(value)) return sorted(value);
+	const known = order.filter((key) => Object.hasOwn(value, key));
 	const others = Object.keys(value).filter((key) => !order.includes(key)).sort(byCodePoint);
-	return Object.fromEntries([...known, ...others].map((key) => [key, each(key, value[key])]));
+	return new Map([...known, ...others].map((key) => [key, each(key, value[key])]));
 }
 /** A map keyed by name or id: its keys sorted, each value shaped by `each`. A value that is not an object is sorted. */
 function byKey(value, each) {
-	if (!isObject(value)) return sorted(value);
-	return Object.fromEntries(Object.keys(value).sort(byCodePoint).map((key) => [key, each(value[key])]));
+	if (!isObject(value) || Array.isArray(value)) return sorted(value);
+	return new Map(Object.keys(value).sort(byCodePoint).map((key) => [key, each(value[key])]));
 }
 function sortedMember(_key, value) {
 	return sorted(value);
@@ -74,21 +77,21 @@ function byCodePoint(left, right) {
 	}
 	return a.length - b.length;
 }
-/** Write a JSON value with two-space indentation, one member or item per line. */
+/** Write a JSON value with two-space indentation, one member or item per line. A `Map` keeps its order. */
 function write(value, indent) {
 	if (Array.isArray(value)) {
 		if (value.length === 0) return "[]";
 		const inner = `${indent}  `;
 		return `[\n${value.map((item) => inner + write(item, inner)).join(",\n")}\n${indent}]`;
 	}
-	if (isObject(value)) {
-		const keys = Object.keys(value);
-		if (keys.length === 0) return "{}";
+	if (value instanceof Map) {
+		const entries = [...value];
+		if (entries.length === 0) return "{}";
 		const inner = `${indent}  `;
-		return `{\n${keys.map((key) => `${inner}${JSON.stringify(key)}: ${write(value[key], inner)}`).join(",\n")}\n${indent}}`;
+		return `{\n${entries.map(([key, member]) => `${inner}${JSON.stringify(key)}: ${write(member, inner)}`).join(",\n")}\n${indent}}`;
 	}
+	if (isObject(value)) return write(sorted(value), indent);
 	if (typeof value === "number" && !Number.isFinite(value)) throw new TypeError("A catalog holds only finite numbers");
 	return JSON.stringify(value);
 }
-//#endregion
-export { byCodePoint, canonicalCatalog, canonicalText };
+export { byCodePoint, canonicalText };

package/dist/index.js

@@ -1,5 +1,5 @@
 import { canonicalText } from "./canonical.js";
-//#region src/index.ts
+// src/index.ts
 /**
 * Write an AcidCat catalog in TypeScript, and render it to the JSON document the toolchain checks.
 *
@@ -56,22 +56,25 @@ var Catalog = class {
 		}
 		for (const [name, schema] of this.#types) {
 			if (!TYPE_NAME.test(name)) problems.push(`the type name ${name} is malformed`);
+			if (!isJsonObject(schema)) problems.push(`the type ${name} is not a JSON object`);
 			problems.push(...this.#referenceProblems(schema).map((problem) => `the type ${name} ${problem}`));
 		}
 		for (const [id, capability] of this.#capabilities) {
-			problems.push(...this.#entryProblems(id, capability));
 			const schemas = [
-				capability.input,
-				capability.output,
-				capability.state,
-				...Object.values(capability.failures ?? {})
+				["input", capability.input],
+				["output", capability.output],
+				["state", capability.state],
+				...Object.entries(capability.failures ?? {}).map(([tag, schema]) => [`failure ${tag}`, schema])
 			];
-			for (const schema of schemas) if (schema !== void 0) problems.push(...this.#referenceProblems(schema).map((problem) => `${id} ${problem}`));
+			problems.push(...schemaProblems(id, schemas));
+			problems.push(...this.#entryProblems(id, capability));
+			for (const [, schema] of schemas) if (schema !== void 0) problems.push(...this.#referenceProblems(schema).map((problem) => `${id} ${problem}`));
 		}
 		for (const [id, event] of this.#events) {
 			if (this.#capabilities.has(id)) problems.push(`${id} is both a capability and an event`);
+			problems.push(...schemaProblems(id, [["input", event.input], ["payload", event.payload]]));
 			problems.push(...this.#entryProblems(id, event));
-			if (event.payload !== void 0 && this.#resolve(event.payload).type !== "object") problems.push(`${id} payload does not describe an object`);
+			if (isJsonObject(event.payload) && this.#resolve(event.payload).type !== "object") problems.push(`${id} payload does not describe an object`);
 			for (const schema of [event.input, event.payload]) if (schema !== void 0) problems.push(...this.#referenceProblems(schema).map((problem) => `${id} ${problem}`));
 		}
 		return problems;
@@ -84,7 +87,7 @@ var Catalog = class {
 		const audience = entry.audience ?? [];
 		if (new Set(audience).size !== audience.length) problems.push(`${id} repeats a target in its audience`);
 		for (const target of audience) if (!this.#targets.has(target)) problems.push(`${id} names the undeclared target ${target}`);
-		if (entry.input !== void 0 && this.#resolve(entry.input).type !== "object") problems.push(`${id} input does not describe an object`);
+		if (isJsonObject(entry.input) && this.#resolve(entry.input).type !== "object") problems.push(`${id} input does not describe an object`);
 		return problems;
 	}
 	/** The catalog as a JSON value. Throws when the catalog breaks a rule. */
@@ -124,12 +127,13 @@ var Catalog = class {
 	}
 	#resolve(schema) {
 		const name = typeof schema.$ref === "string" ? REFERENCE.exec(schema.$ref)?.[1] : void 0;
-		return name === void 0 ? schema : this.#types.get(name) ?? schema;
+		const resolved = name === void 0 ? schema : this.#types.get(name) ?? schema;
+		return isJsonObject(resolved) ? resolved : {};
 	}
 	#referenceProblems(schema) {
 		const problems = [];
 		visit(schema, (node) => {
-			if ("$defs" in node) problems.push("carries its own $defs; declare shared types with type()");
+			if (Object.hasOwn(node, "$defs")) problems.push("carries its own $defs; declare shared types with type()");
 			if (node.$ref === void 0) return;
 			const name = typeof node.$ref === "string" ? REFERENCE.exec(node.$ref)?.[1] : void 0;
 			if (name === void 0 || !this.#types.has(name)) problems.push(`references ${typeof node.$ref === "string" ? node.$ref : JSON.stringify(node.$ref)}, which is not a type`);
@@ -137,11 +141,20 @@ var Catalog = class {
 		return problems;
 	}
 };
+/**
+* The schemas of a capability or an event that are not JSON objects. The types of this library allow only objects,
+* but a JavaScript caller can still give a boolean schema such as `true`.
+*/
+function schemaProblems(id, schemas) {
+	return schemas.filter(([, schema]) => schema !== void 0 && !isJsonObject(schema)).map(([member]) => `${id} ${member} is not a JSON object`);
+}
 function compact(value) {
 	return Object.fromEntries(Object.entries(value).filter(([, member]) => member !== void 0));
 }
 /** Tell if a value is an object that is not `null`. Each of its members is read as `unknown`. */
 const isRecord = (value) => value !== null && typeof value === "object";
+/** Tell if a value is a JSON object: an object that is not `null` and not an array. */
+const isJsonObject = (value) => isRecord(value) && !Array.isArray(value);
 function visit(value, onObject) {
 	if (Array.isArray(value)) value.forEach((item) => visit(item, onObject));
 	else if (isRecord(value)) {
@@ -149,5 +162,4 @@ function visit(value, onObject) {
 		Object.values(value).forEach((item) => visit(item, onObject));
 	}
 }
-//#endregion
 export { Catalog, canonicalText };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acid-cat/catalog",
-  "version": "0.10.0",
+  "version": "0.10.2",
   "description": "Write an AcidCat catalog in TypeScript and render it in canonical form.",
   "keywords": [
     "acidcat",
@@ -31,7 +31,7 @@
     "access": "public"
   },
   "devDependencies": {
-    "@types/node": "26.6.5",
+    "@types/node": "26.6.6",
     "typescript": "7.0.2"
   }
 }