@fedify/vocab-tools 2.0.0-pr.458.1785

package/src/constructor.ts

@@ -0,0 +1,337 @@
+import { getFieldName } from "./field.ts";
+import { hasSingularAccessor, isNonFunctionalProperty } from "./schema.ts";
+import type { PropertySchema, TypeSchema } from "./schema.ts";
+import {
+  areAllScalarTypes,
+  emitOverride,
+  getTypeGuards,
+  getTypeNames,
+} from "./type.ts";
+
+function generateParameterType(
+  property: PropertySchema,
+  types: Record<string, TypeSchema>,
+): string {
+  const range = property.range;
+  const scalar = areAllScalarTypes(range, types);
+  const code: string[] = [];
+  if (hasSingularAccessor(property)) {
+    if (scalar) {
+      code.push(
+        `${property.singularName}?: ${getTypeNames(range, types)} | null;`,
+      );
+    } else {
+      code.push(
+        `${property.singularName}?: ${
+          getTypeNames(range, types)
+        } | URL | null;`,
+      );
+    }
+  }
+  if (isNonFunctionalProperty(property)) {
+    if (scalar) {
+      code.push(
+        `${property.pluralName}?: (${getTypeNames(range, types, true)})[];`,
+      );
+    } else {
+      code.push(
+        `${property.pluralName}?: (${getTypeNames(range, types)} | URL)[];`,
+      );
+    }
+  }
+  return code.join("\n");
+}
+
+async function* generateParametersType(
+  typeUri: string,
+  types: Record<string, TypeSchema>,
+  parentheses = true,
+  excludeProperties: string[] = [],
+): AsyncIterable<string> {
+  const type = types[typeUri];
+  if (parentheses) yield "{\n";
+  if (type.extends == null) {
+    yield `id?: URL | null;\n`;
+  } else {
+    for await (
+      const code of generateParametersType(type.extends, types, false, [
+        ...excludeProperties,
+        ...type.properties.map((p) => p.singularName),
+      ])
+    ) {
+      yield code;
+    }
+  }
+  for (const property of type.properties) {
+    if (excludeProperties.includes(property.singularName)) continue;
+    yield generateParameterType(property, types);
+  }
+  if (parentheses) yield "}\n";
+}
+
+export async function* generateConstructor(
+  typeUri: string,
+  types: Record<string, TypeSchema>,
+): AsyncIterable<string> {
+  const type = types[typeUri];
+  yield `
+  /**
+   * Constructs a new instance of ${type.name} with the given values.
+   * @param values The values to initialize the instance with.
+   * @param options The options to use for initialization.
+   */
+  constructor(
+    values:
+  `;
+  for await (const code of generateParametersType(typeUri, types)) yield code;
+  yield `,
+    options: {
+      documentLoader?: DocumentLoader,
+      contextLoader?: DocumentLoader,
+      tracerProvider?: TracerProvider,
+    } = {},
+  ) {
+  `;
+  if (type.extends == null) {
+    yield `
+    this.#documentLoader = options.documentLoader;
+    this.#contextLoader = options.contextLoader;
+    this.#tracerProvider = options.tracerProvider;
+    if ("$warning" in options) {
+      this.#warning = options.$warning as unknown as {
+        category: string[];
+        message: string;
+        values?: Record<string, unknown>;
+      };
+    }
+    if (values.id == null || values.id instanceof URL) {
+      this.id = values.id ?? null;
+    } else {
+      throw new TypeError("The id must be a URL.");
+    }
+    `;
+  } else {
+    yield "super(values, options);";
+  }
+  for (const property of type.properties) {
+    const fieldName = await getFieldName(property.uri);
+    const trustFieldName = await getFieldName(property.uri, "#_trust");
+    const allScalarTypes = areAllScalarTypes(property.range, types);
+    if (hasSingularAccessor(property)) {
+      let typeGuards = getTypeGuards(
+        property.range,
+        types,
+        `values.${property.singularName}`,
+      );
+      let typeNames = getTypeNames(property.range, types);
+      const scalar = areAllScalarTypes(property.range, types);
+      if (!scalar) {
+        typeGuards =
+          `${typeGuards} || values.${property.singularName} instanceof URL`;
+        typeNames = `${typeNames} | URL`;
+      }
+      yield `
+        if ("${property.singularName}" in values && \
+            values.${property.singularName} != null) {
+          if (${typeGuards}) {
+            // @ts-ignore: type is checked above.
+            this.${fieldName} = [values.${property.singularName}];
+      `;
+      if (!allScalarTypes) yield `this.${trustFieldName}.add(0);`;
+      yield `
+          } else {
+            throw new TypeError(
+              "The ${property.singularName} must be of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+    }
+    if (isNonFunctionalProperty(property)) {
+      let typeGuards = getTypeGuards(property.range, types, `v`);
+      let typeNames = getTypeNames(property.range, types);
+      const scalar = areAllScalarTypes(property.range, types);
+      if (!scalar) {
+        typeGuards = `${typeGuards} || v instanceof URL`;
+        typeNames = `${typeNames} | URL`;
+      }
+      yield `
+        if ("${property.pluralName}" in values && \
+            values.${property.pluralName} != null) {
+      `;
+      if (property && property.singularAccessor) {
+        yield `
+          if ("${property.singularName}" in values &&
+              values.${property.singularName} != null) {
+            throw new TypeError(
+              "Cannot initialize both ${property.singularName} and " +
+                "${property.pluralName} at the same time.",
+            );
+          }
+        `;
+      }
+      yield `
+          if (Array.isArray(values.${property.pluralName}) &&
+              values.${property.pluralName}.every(v => ${typeGuards})) {
+            // @ts-ignore: type is checked above.
+            this.${fieldName} = values.${property.pluralName};
+      `;
+      if (!allScalarTypes) {
+        yield `
+            for (let i = 0; i < values.${property.pluralName}.length; i++) {
+              this.${trustFieldName}.add(i);
+            }
+        `;
+      }
+      yield `
+          } else {
+            throw new TypeError(
+              "The ${property.pluralName} must be an array of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+    }
+  }
+  yield "}\n";
+}
+
+export async function* generateCloner(
+  typeUri: string,
+  types: Record<string, TypeSchema>,
+): AsyncIterable<string> {
+  const type = types[typeUri];
+  yield `
+  /**
+   * Clones this instance, optionally updating it with the given values.
+   * @param values The values to update the clone with.
+   * @options The options to use for cloning.
+   * @returns The cloned instance.
+   */
+  ${emitOverride(typeUri, types)} clone(
+    values:
+  `;
+  for await (const code of generateParametersType(typeUri, types)) yield code;
+  yield `
+    = {},
+    options: {
+      documentLoader?: DocumentLoader,
+      contextLoader?: DocumentLoader,
+    } = {}
+  ): ${type.name} {
+    if (this._warning != null) {
+      getLogger(this._warning.category).warn(
+        this._warning.message,
+        this._warning.values
+      );
+      // @ts-ignore: $warning is not recognized as a property, but it is.
+      options = { ...options, $warning: this._warning };
+    }
+  `;
+  if (type.extends == null) {
+    yield `
+    // @ts-ignore: this.constructor is not recognized as a constructor, but it is.
+    const clone: ${type.name} = new this.constructor(
+      { id: values.id ?? this.id },
+      options
+    );
+    `;
+  } else {
+    yield `const clone = super.clone(values, options) as unknown as ${type.name};`;
+  }
+  for (const property of type.properties) {
+    const fieldName = await getFieldName(property.uri);
+    const trustFieldName = await getFieldName(property.uri, "#_trust");
+    const allScalarTypes = areAllScalarTypes(property.range, types);
+    yield `clone.${fieldName} = this.${fieldName};`;
+    if (!allScalarTypes) {
+      yield `clone.${trustFieldName} = new Set(this.${trustFieldName});`;
+    }
+    if (hasSingularAccessor(property)) {
+      let typeGuards = getTypeGuards(
+        property.range,
+        types,
+        `values.${property.singularName}`,
+      );
+      let typeNames = getTypeNames(property.range, types);
+      const scalar = areAllScalarTypes(property.range, types);
+      if (!scalar) {
+        typeGuards =
+          `${typeGuards} || values.${property.singularName} instanceof URL`;
+        typeNames = `${typeNames} | URL`;
+      }
+      yield `
+        if ("${property.singularName}" in values && \
+            values.${property.singularName} != null) {
+          if (${typeGuards}) {
+            // @ts-ignore: type is checked above.
+            clone.${fieldName} = [values.${property.singularName}];
+      `;
+      if (!allScalarTypes) {
+        yield `clone.${trustFieldName} = new Set([0]);`;
+      }
+      yield `
+          } else {
+            throw new TypeError(
+              "The ${property.singularName} must be of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+    }
+    if (isNonFunctionalProperty(property)) {
+      let typeGuards = getTypeGuards(property.range, types, `v`);
+      let typeNames = getTypeNames(property.range, types);
+      const scalar = areAllScalarTypes(property.range, types);
+      if (!scalar) {
+        typeGuards = `${typeGuards} || v instanceof URL`;
+        typeNames = `${typeNames} | URL`;
+      }
+      yield `
+        if ("${property.pluralName}" in values && \
+            values.${property.pluralName} != null) {
+      `;
+      if (property.singularAccessor) {
+        yield `
+          if ("${property.singularName}" in values &&
+              values.${property.singularName} != null) {
+            throw new TypeError(
+              "Cannot update both ${property.singularName} and " +
+                "${property.pluralName} at the same time.",
+            );
+          }
+        `;
+      }
+      yield `
+          if (Array.isArray(values.${property.pluralName}) &&
+              values.${property.pluralName}.every(v => ${typeGuards})) {
+            // @ts-ignore: type is checked above.
+            clone.${fieldName} = values.${property.pluralName};
+      `;
+      if (!allScalarTypes) {
+        yield `
+            clone.${trustFieldName} = new Set();
+            for (let i = 0; i < values.${property.pluralName}.length; i++) {
+              clone.${trustFieldName}.add(i);
+            }
+        `;
+      }
+      yield `
+          } else {
+            throw new TypeError(
+              "The ${property.pluralName} must be an array of type " +
+              ${JSON.stringify(typeNames)} + ".",
+            );
+          }
+        }
+      `;
+    }
+  }
+  yield `
+    return clone;
+  }
+  `;
+}

package/src/field.ts

@@ -0,0 +1,46 @@
+import { encodeBase58 } from "byte-encodings/base58";
+import type { PropertySchema, TypeSchema } from "./schema.ts";
+import { areAllScalarTypes, getTypeNames } from "./type.ts";
+
+export async function getFieldName(
+  propertyUri: string,
+  prefix = "#",
+): Promise<string> {
+  const hashedUri = await crypto.subtle.digest(
+    "SHA-1",
+    new TextEncoder().encode(propertyUri),
+  );
+  const match = propertyUri.match(/#([A-Za-z0-9_]+)$/);
+  const suffix = match == null ? "" : `_${match[1]}`;
+  return `${prefix}_${encodeBase58(hashedUri)}${suffix}`;
+}
+
+export async function generateField(
+  property: PropertySchema,
+  types: Record<string, TypeSchema>,
+  prefix = "#",
+): Promise<string> {
+  const fieldName = await getFieldName(property.uri, prefix);
+  if (areAllScalarTypes(property.range, types)) {
+    return `${fieldName}: (${
+      getTypeNames(property.range, types, true)
+    })[] = [];\n`;
+  } else {
+    const typeNames = getTypeNames(property.range, types);
+    const trustFieldName = await getFieldName(property.uri, `${prefix}_trust`);
+    return `
+      ${fieldName}: (${typeNames} | URL)[] = [];
+      ${trustFieldName}: Set<number> = new Set();
+    `;
+  }
+}
+
+export async function* generateFields(
+  typeUri: string,
+  types: Record<string, TypeSchema>,
+): AsyncIterable<string> {
+  const type = types[typeUri];
+  for (const property of type.properties) {
+    yield await generateField(property, types);
+  }
+}

package/src/fs.test.ts

@@ -0,0 +1,31 @@
+import { deepStrictEqual } from "node:assert";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "node:test";
+import { readDirRecursive } from "./fs.ts";
+
+test("readDirRecursive()", async () => {
+  // Create a temporary directory that has fixtures in it:
+  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");
+
+  // Read the directory recursively:
+  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"),
+    ]),
+  );
+});

package/src/fs.ts

@@ -0,0 +1,21 @@
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * 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.
+ */
+export async function* readDirRecursive(dir: string): AsyncIterable<string> {
+  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;
+    }
+  }
+}

package/src/generate.ts

@@ -0,0 +1,24 @@
+import { open } from "node:fs/promises";
+import { generateClasses } from "./class.ts";
+import { loadSchemaFiles } from "./schema.ts";
+
+export default async function generateVocab(
+  schemaDir: string,
+  generatedPath: string,
+) {
+  const types = await loadSchemaFiles(schemaDir);
+  const encoder = new TextEncoder();
+
+  const file = await open(generatedPath, "w");
+  const writer = file.createWriteStream();
+
+  for await (const code of generateClasses(types)) {
+    writer.write(encoder.encode(code));
+  }
+
+  await new Promise<void>((resolve, reject) => {
+    writer.once("finish", () => file.close().then(resolve, reject));
+    writer.once("error", reject);
+    writer.end();
+  });
+}

package/src/inspector.ts

@@ -0,0 +1,96 @@
+import { getFieldName } from "./field.ts";
+import type { TypeSchema } from "./schema.ts";
+import { hasSingularAccessor, isNonFunctionalProperty } from "./schema.ts";
+import { emitOverride } from "./type.ts";
+
+export async function* generateInspector(
+  typeUri: string,
+  types: Record<string, TypeSchema>,
+): AsyncIterable<string> {
+  const type = types[typeUri];
+  yield `
+  protected ${
+    emitOverride(typeUri, types)
+  } _getCustomInspectProxy(): Record<string, unknown> {
+  `;
+  if (type.extends == null) {
+    yield `
+    const proxy: Record<string, unknown> = {};
+    if (this.id != null) {
+      proxy.id = {
+        [Symbol.for("Deno.customInspect")]: (
+          inspect: typeof Deno.inspect,
+          options: Deno.InspectOptions,
+        ): string => "URL " + inspect(this.id!.href, options),
+        [Symbol.for("nodejs.util.inspect.custom")]: (
+          _depth: number,
+          options: unknown,
+          inspect: (value: unknown, options: unknown) => string,
+        ): string => "URL " + inspect(this.id!.href, options),
+      };
+    }
+    `;
+  } else {
+    yield "const proxy: Record<string, unknown> = super._getCustomInspectProxy();";
+  }
+  for (const property of type.properties) {
+    const fieldName = await getFieldName(property.uri);
+    const localName = await getFieldName(property.uri, "");
+    yield `
+      const ${localName} = this.${fieldName}
+        // deno-lint-ignore no-explicit-any
+        .map((v: any) => v instanceof URL
+          ? {
+              [Symbol.for("Deno.customInspect")]: (
+                inspect: typeof Deno.inspect,
+                options: Deno.InspectOptions,
+              ): string => "URL " + inspect(v.href, options),
+              [Symbol.for("nodejs.util.inspect.custom")]: (
+                _depth: number,
+                options: unknown,
+                inspect: (value: unknown, options: unknown) => string,
+              ): string => "URL " + inspect(v.href, options),
+            }
+          : v);
+    `;
+    if (hasSingularAccessor(property)) {
+      yield `
+      if (${localName}.length == 1) {
+        proxy.${property.singularName} = ${localName}[0];
+      }
+      `;
+    }
+    if (isNonFunctionalProperty(property)) {
+      yield `
+      if (${localName}.length > 1
+          || !(${JSON.stringify(property.singularName)} in proxy)
+          && ${localName}.length > 0) {
+        proxy.${property.pluralName} = ${localName};
+      }
+      `;
+    }
+  }
+  yield `
+    return proxy;
+  }
+
+  // @ts-ignore: suppressing TS4127
+  ${emitOverride(typeUri, types)} [Symbol.for("Deno.customInspect")](
+    inspect: typeof Deno.inspect,
+    options: Deno.InspectOptions,
+  ): string {
+    const proxy = this._getCustomInspectProxy();
+    return ${JSON.stringify(type.name + " ")} + inspect(proxy, options);
+  }
+
+  // @ts-ignore: suppressing TS4127
+  ${emitOverride(typeUri, types)} [Symbol.for("nodejs.util.inspect.custom")](
+    _depth: number,
+    options: unknown,
+    inspect: (value: unknown, options: unknown) => string,
+  ): string {
+    const proxy = this._getCustomInspectProxy();
+    return ${JSON.stringify(type.name + " ")} + inspect(proxy, options);
+  }
+  `;
+}

package/src/mod.ts

@@ -0,0 +1,7 @@
+export { default as generateVocab } from "./generate.ts";
+export {
+  loadSchemaFiles,
+  type PropertySchema,
+  type TypeSchema,
+} from "./schema.ts";
+export { areAllScalarTypes } from "./type.ts";