@acid-cat/catalog 0.10.0 → 0.10.1

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.
 *
@@ -129,7 +129,7 @@ var Catalog = class {
 	#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`);
@@ -149,5 +149,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.1",
   "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"
   }
 }