@fedify/vocab-tools 2.0.0-dev.12 → 2.0.0-dev.158

package/dist/fs-B12zeNxV.js

@@ -0,0 +1,19 @@
+import { join } from "node:path";
+import { readdir } from "node:fs/promises";
+
+//#region src/fs.ts
+/**
+* Recursively read a directory, yielding the paths of all files.  File paths
+* are relative to the directory, and directories are not yielded.
+* @param dir The directory to read.
+* @returns An async iterable of file paths.
+*/
+async function* readDirRecursive(dir) {
+	for (const entry of await readdir(dir, { withFileTypes: true })) if (entry.isDirectory()) {
+		const path = join(dir, entry.name);
+		for await (const subentry of readDirRecursive(path)) yield join(entry.name, subentry);
+	} else yield entry.name;
+}
+
+//#endregion
+export { readDirRecursive };

package/dist/fs.test.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/fs.test.js

@@ -0,0 +1,28 @@
+import { readDirRecursive } from "./fs-B12zeNxV.js";
+import { deepStrictEqual } from "node:assert";
+import { join } from "node:path";
+import { test } from "node:test";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+
+//#region src/fs.test.ts
+test("readDirRecursive()", async () => {
+	const dir = await mkdtemp(join(tmpdir(), "fedify-test-"));
+	await mkdir(join(dir, "a"));
+	await writeFile(join(dir, "a", "aa.txt"), "aa");
+	await writeFile(join(dir, "a", "ab.txt"), "aa");
+	await mkdir(join(dir, "a", "aa"));
+	await writeFile(join(dir, "a", "aa", "aaa.txt"), "aaa");
+	await mkdir(join(dir, "b"));
+	await writeFile(join(dir, "b", "ba.txt"), "ba");
+	await writeFile(join(dir, "b", "bb.txt"), "bb");
+	deepStrictEqual(new Set(await Array.fromAsync(readDirRecursive(dir))), new Set([
+		join("a", "aa", "aaa.txt"),
+		join("a", "aa.txt"),
+		join("a", "ab.txt"),
+		join("b", "ba.txt"),
+		join("b", "bb.txt")
+	]));
+});
+
+//#endregion

package/dist/mod.cjs

@@ -31,7 +31,7 @@ const es_toolkit = __toESM(require("es-toolkit"));
 
 //#region deno.json
 var name = "@fedify/vocab-tools";
-var version = "2.0.0-dev.12+0e4c2ede";
+var version = "2.0.0-dev.158+628cd89e";
 var license = "MIT";
 var exports$1 = { ".": "./src/mod.ts" };
 var author = {
@@ -48,6 +48,7 @@ var exclude = [
 	"node_modules",
 	"src/schema.yaml"
 ];
+var publish = { "exclude": ["**/*.test.ts"] };
 var tasks = {
 	"check": "deno fmt --check && deno lint && deno check src/*.ts",
 	"test": "deno test -A"
@@ -60,6 +61,7 @@ var deno_default = {
 	author,
 	imports,
 	exclude,
+	publish,
 	tasks
 };
 

package/dist/mod.js

@@ -8,7 +8,7 @@ import { pascalCase } from "es-toolkit";
 
 //#region deno.json
 var name = "@fedify/vocab-tools";
-var version = "2.0.0-dev.12+0e4c2ede";
+var version = "2.0.0-dev.158+628cd89e";
 var license = "MIT";
 var exports = { ".": "./src/mod.ts" };
 var author = {
@@ -25,6 +25,7 @@ var exclude = [
 	"node_modules",
 	"src/schema.yaml"
 ];
+var publish = { "exclude": ["**/*.test.ts"] };
 var tasks = {
 	"check": "deno fmt --check && deno lint && deno check src/*.ts",
 	"test": "deno test -A"
@@ -37,6 +38,7 @@ var deno_default = {
 	author,
 	imports,
 	exclude,
+	publish,
 	tasks
 };
 

package/dist/schema-s8NE7Bb_.js

@@ -0,0 +1,96 @@
+import { readDirRecursive } from "./fs-B12zeNxV.js";
+import { join, posix } from "node:path";
+import { Validator } from "@cfworker/json-schema";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { parse } from "yaml";
+
+//#region src/schema.ts
+/**
+* Type guard to check if a property is not functional (has pluralName).
+*/
+function isNonFunctionalProperty(property) {
+	return property.functional !== true;
+}
+/**
+* Type guard to check if a property has singular accessor.
+*/
+function hasSingularAccessor(property) {
+	if (property.functional === true) return true;
+	return isNonFunctionalProperty(property) && property.singularAccessor === true;
+}
+/**
+* An error that occurred while loading a schema file.
+*/
+var SchemaError = class extends Error {
+	/**
+	* The path of the schema file.
+	*/
+	path;
+	/**
+	* Constructs a new `SchemaError`.
+	* @param path The path of the schema file.
+	* @param message The error message.
+	*/
+	constructor(path, message) {
+		super(message);
+		this.path = path;
+	}
+};
+async function loadSchemaValidator() {
+	const thisFile = import.meta.url;
+	const schemaFile = new URL(posix.join(posix.dirname(thisFile), "schema.yaml"));
+	let content;
+	if (schemaFile.protocol !== "file:") {
+		const response = await fetch(schemaFile);
+		content = await response.text();
+	} else content = await readFile(fileURLToPath(schemaFile), { encoding: "utf-8" });
+	const schemaObject = parse(content);
+	return new Validator(schemaObject);
+}
+let schemaValidator = void 0;
+async function loadSchema(path) {
+	const content = await readFile(path, { encoding: "utf-8" });
+	const schema = parse(content);
+	if (schemaValidator == null) schemaValidator = await loadSchemaValidator();
+	const result = schemaValidator.validate(schema);
+	const errors = [];
+	if (result.valid) return schema;
+	for (const e of result.errors) errors.push(new SchemaError(path, `${path}:${e.instanceLocation}: ${e.error}`));
+	throw new AggregateError(errors);
+}
+/**
+* Loads all schema files in the directory.
+* @param dir The path of the directory to load schema files from.
+* @returns A map from the qualified URI of a type to its {@link SchemaFile}.
+* @throws {@link AggregateError} if any schema file is invalid.  It contains
+*         all {@link SchemaError}s of the invalid schema files.
+*/
+async function loadSchemaFiles(dir) {
+	if (typeof dir !== "string") throw new TypeError("Expected a directory path in string");
+	const result = {};
+	const errors = [];
+	for await (const relPath of readDirRecursive(dir)) {
+		if (!relPath.match(/\.ya?ml$/i)) continue;
+		if (relPath.match(/(^|[/\\])schema.yaml$/i)) continue;
+		const path = join(dir, relPath);
+		let schema;
+		try {
+			schema = await loadSchema(path);
+		} catch (e) {
+			if (e instanceof AggregateError && e.errors.length > 0 && e.errors[0] instanceof SchemaError) {
+				errors.push(...e.errors);
+				continue;
+			}
+			throw e;
+		}
+		result[schema.uri] = schema;
+	}
+	if (errors.length > 0) throw new AggregateError(errors);
+	const entries = Object.entries(result);
+	entries.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0);
+	return Object.fromEntries(entries);
+}
+
+//#endregion
+export { hasSingularAccessor, isNonFunctionalProperty, loadSchemaFiles };

package/dist/schema.test.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/schema.test.js

@@ -0,0 +1,140 @@
+import "./fs-B12zeNxV.js";
+import { hasSingularAccessor, isNonFunctionalProperty } from "./schema-s8NE7Bb_.js";
+import { deepStrictEqual, ok } from "node:assert";
+import { test } from "node:test";
+
+//#region src/schema.test.ts
+test("isNonFunctionalProperty: returns true for non-functional property", () => {
+	const property = {
+		singularName: "name",
+		pluralName: "names",
+		uri: "https://example.com/name",
+		description: "A name property",
+		range: ["https://example.com/Text"],
+		functional: false
+	};
+	ok(isNonFunctionalProperty(property));
+	if (isNonFunctionalProperty(property)) {
+		const _pluralName = property.pluralName;
+		const _singularAccessor = property.singularAccessor;
+		const _container = property.container;
+	}
+});
+test("isNonFunctionalProperty: returns true for property without functional field", () => {
+	const property = {
+		singularName: "name",
+		pluralName: "names",
+		uri: "https://example.com/name",
+		description: "A name property",
+		range: ["https://example.com/Text"]
+	};
+	ok(isNonFunctionalProperty(property));
+});
+test("isNonFunctionalProperty: returns false for functional property", () => {
+	const property = {
+		singularName: "id",
+		uri: "https://example.com/id",
+		description: "An ID property",
+		range: ["https://example.com/ID"],
+		functional: true
+	};
+	ok(!isNonFunctionalProperty(property));
+});
+test("hasSingularAccessor: returns true for functional property", () => {
+	const property = {
+		singularName: "id",
+		uri: "https://example.com/id",
+		description: "An ID property",
+		range: ["https://example.com/ID"],
+		functional: true
+	};
+	ok(hasSingularAccessor(property));
+});
+test("hasSingularAccessor: returns true for non-functional property with singularAccessor", () => {
+	const property = {
+		singularName: "name",
+		pluralName: "names",
+		uri: "https://example.com/name",
+		description: "A name property",
+		range: ["https://example.com/Text"],
+		functional: false,
+		singularAccessor: true
+	};
+	ok(hasSingularAccessor(property));
+});
+test("hasSingularAccessor: returns false for non-functional property without singularAccessor", () => {
+	const property = {
+		singularName: "name",
+		pluralName: "names",
+		uri: "https://example.com/name",
+		description: "A name property",
+		range: ["https://example.com/Text"],
+		functional: false,
+		singularAccessor: false
+	};
+	ok(!hasSingularAccessor(property));
+});
+test("hasSingularAccessor: returns false for non-functional property with undefined singularAccessor", () => {
+	const property = {
+		singularName: "name",
+		pluralName: "names",
+		uri: "https://example.com/name",
+		description: "A name property",
+		range: ["https://example.com/Text"]
+	};
+	ok(!hasSingularAccessor(property));
+});
+test("Type guard combinations: functional property with redundantProperties", () => {
+	const property = {
+		singularName: "type",
+		uri: "https://www.w3.org/ns/activitystreams#type",
+		description: "The type of the object",
+		range: ["https://example.com/Type"],
+		functional: true,
+		redundantProperties: [{ uri: "https://www.w3.org/1999/02/22-rdf-syntax-ns#type" }]
+	};
+	ok(!isNonFunctionalProperty(property));
+	ok(hasSingularAccessor(property));
+});
+test("Type guard combinations: non-functional property with container", () => {
+	const property = {
+		singularName: "item",
+		pluralName: "items",
+		uri: "https://example.com/item",
+		description: "List of items",
+		range: ["https://example.com/Item"],
+		functional: false,
+		container: "list"
+	};
+	ok(isNonFunctionalProperty(property));
+	ok(!hasSingularAccessor(property));
+	if (isNonFunctionalProperty(property)) deepStrictEqual(property.container, "list");
+});
+test("Type guard combinations: non-functional property with graph container", () => {
+	const property = {
+		singularName: "member",
+		pluralName: "members",
+		uri: "https://example.com/member",
+		description: "Graph of members",
+		range: ["https://example.com/Member"],
+		functional: false,
+		container: "graph"
+	};
+	ok(isNonFunctionalProperty(property));
+	ok(!hasSingularAccessor(property));
+	if (isNonFunctionalProperty(property)) deepStrictEqual(property.container, "graph");
+});
+test("Type guard combinations: untyped property", () => {
+	const property = {
+		singularName: "value",
+		pluralName: "values",
+		uri: "https://example.com/value",
+		description: "Untyped values",
+		untyped: true,
+		range: ["https://example.com/Value"]
+	};
+	ok(isNonFunctionalProperty(property));
+	ok(!hasSingularAccessor(property));
+});
+
+//#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fedify/vocab-tools",
-  "version": "2.0.0-dev.12+0e4c2ede",
+  "version": "2.0.0-dev.158+628cd89e",
   "description": "Code generator for Activity Vocabulary APIs",
   "homepage": "https://fedify.dev/",
   "repository": {

package/src/class.test.ts

@@ -1,5 +1,5 @@
 import { deepStrictEqual } from "node:assert";
-import { basename, dirname, join } from "node:path";
+import { basename, dirname, extname, join } from "node:path";
 import { test } from "node:test";
 import metadata from "../deno.json" with { type: "json" };
 import { generateClasses, sortTopologically } from "./class.ts";
@@ -88,7 +88,7 @@ if ("Deno" in globalThis) {
 
 async function getEntireCode() {
   const packagesDir = dirname(dirname(import.meta.dirname!));
-  const schemaDir = join(packagesDir, "fedify", "src", "vocab");
+  const schemaDir = join(packagesDir, "vocab", "src");
   const types = await loadSchemaFiles(schemaDir);
   const entireCode = (await Array.fromAsync(generateClasses(types)))
     .join("")
@@ -106,7 +106,7 @@ async function changeNodeSnapshotPath() {
       return join(
         dirname(path),
         "__snapshots__",
-        basename(path) + ".node.snap",
+        basename(path.replace(extname(path), ".ts")) + ".node.snap",
       );
     },
   );

package/tsdown.config.ts

@@ -1,20 +1,55 @@
-import { cp } from "node:fs/promises";
-import { join } from "node:path";
+import { cp, glob } from "node:fs/promises";
+import { join, sep } from "node:path";
 import { defineConfig } from "tsdown";
 
-export default defineConfig({
-  entry: ["src/mod.ts"],
-  dts: true,
-  format: ["esm", "cjs"],
-  platform: "node",
-  external: [/^node:/],
-  hooks: {
-    "build:done": async (ctx) => {
-      await cp(
-        join("src", "schema.yaml"),
-        join(ctx.options.outDir, "schema.yaml"),
-        { force: true },
-      );
+export default [
+  defineConfig({
+    entry: ["src/mod.ts"],
+    dts: true,
+    format: ["esm", "cjs"],
+    platform: "neutral",
+    external: [/^node:/],
+    hooks: {
+      "build:done": async (ctx) => {
+        await cp(
+          join("src", "schema.yaml"),
+          join(ctx.options.outDir, "schema.yaml"),
+          { force: true },
+        );
+      },
     },
-  },
-});
+  }),
+  defineConfig({
+    entry: (await Array.fromAsync(glob(`src/**/*.test.ts`)))
+      .map((f) => f.replace(sep, "/")),
+    format: ["esm"],
+    platform: "node",
+    external: [
+      /^node:/,
+      /^bun:/,
+    ],
+    inputOptions: {
+      onwarn(warning, defaultHandler) {
+        if (
+          warning.code === "UNRESOLVED_IMPORT" &&
+          warning.id?.endsWith(".test.ts") &&
+          warning.exporter &&
+          ["bun:test", "@std/testing/snapshot"].includes(warning.exporter)
+        ) {
+          return;
+        }
+        defaultHandler(warning);
+      },
+    },
+    hooks: {
+      "build:done": async (ctx) => {
+        await cp(
+          join("src", "__snapshots__"),
+          join(ctx.options.outDir, "__snapshots__"),
+          { recursive: true },
+        );
+      },
+    },
+  }),
+];
+// cSpell: ignore onwarn