@fedify/vocab-tools 2.4.0-dev.1666 → 2.4.0-dev.1727

package/src/class.ts

@@ -93,6 +93,7 @@ async function* generateClass(
     };
     #cachedJsonLd?: unknown;
     readonly #_baseUrl?: URL;
+    #shouldCacheJsonLd = true;
     readonly id: URL | null;
 
     protected get _documentLoader(): DocumentLoader | undefined {
@@ -126,6 +127,20 @@ async function* generateClass(
     protected get _baseUrl(): URL | undefined {
       return this.#_baseUrl;
     }
+
+    protected get _shouldCacheJsonLd(): boolean {
+      return this.#shouldCacheJsonLd;
+    }
+
+    protected set _shouldCacheJsonLd(value: boolean) {
+      this.#shouldCacheJsonLd = value;
+    }
+
+    protected static _shouldCacheDecodedJsonLd(value: unknown): boolean {
+      if (value == null || typeof value !== "object") return true;
+      if (!("_shouldCacheJsonLd" in value)) return true;
+      return (value as { _shouldCacheJsonLd: boolean })._shouldCacheJsonLd;
+    }
     `;
   }
   yield `
@@ -257,6 +272,18 @@ export async function* generateClasses(
     isTemporalDuration,
     isTemporalInstant,
 } from "@fedify/vocab-runtime/temporal";\n`;
+  yield `
+function isValidLanguageTag(language: string): boolean {
+  try {
+    new Intl.Locale(language);
+    return true;
+  } catch (error) {
+    if (error instanceof RangeError) return false;
+    throw error;
+  }
+}
+`;
+  yield "\n\n";
   const portableIriKeys = new Set(["@id", "id"]);
   for (const type of Object.values(types)) {
     for (const property of type.properties) {

package/src/codec.ts

@@ -207,7 +207,7 @@ export async function* generateEncoder(
     yield `
     array = [];
     for (const v of this.${await getFieldName(property.uri)}) {
-      const element = (
+      let element = (
     `;
     if (!areAllScalarTypes(property.range, types)) {
       yield 'v instanceof URL ? { "@id": formatIri(v) } : ';
@@ -217,6 +217,11 @@ export async function* generateEncoder(
     }
     yield `
       );
+      if (Array.isArray(element)) {
+        if (element.length < 1) continue;
+        if (element.length == 1) element = element[0];
+      }
+      if (typeof element === "undefined") continue;
     `;
     if (isNonFunctionalProperty(property) && property.container === "graph") {
       yield `array.push({ "@graph": element });`;
@@ -254,7 +259,10 @@ export async function* generateEncoder(
     if (options.format === "expand") {
       return await jsonld.expand(
         values,
-        { documentLoader: options.contextLoader },
+        {
+          documentLoader: options.contextLoader,
+          keepFreeFloatingNodes: true,
+        },
       );
     }
     const docContext = options.context ??
@@ -394,7 +402,17 @@ export async function* generateDecoder(
     // deno-lint-ignore no-explicit-any
     let values: Record<string, any[]> & { "@id"?: string };
     let expanded: unknown[];
-    if (globalThis.Object.keys(json).length == 0) {
+    if (
+      "_fromSubclass" in options &&
+      options._fromSubclass &&
+      typeof json === "object" &&
+      !Array.isArray(json)
+    ) {
+      values =
+        // deno-lint-ignore no-explicit-any
+        json as (Record<string, any[]> & { "@id"?: string });
+      expanded = [values];
+    } else if (globalThis.Object.keys(json).length == 0) {
       values = {};
       expanded = [values];
     } else {
@@ -455,8 +473,9 @@ export async function* generateDecoder(
     `;
   } else {
     yield `
-    delete values["@type"];
-    const instance = await super.fromJsonLd(values, {
+    const superValues = structuredClone(values);
+    delete superValues["@type"];
+    const instance = await super.fromJsonLd(superValues, {
       ...options,
       // @ts-ignore: an internal option
       _fromSubclass: true,
@@ -466,6 +485,9 @@ export async function* generateDecoder(
     }
     `;
   }
+  yield `
+    let shouldCacheJsonLd = instance._shouldCacheJsonLd;
+  `;
   for (const property of type.properties) {
     const variable = await getFieldName(property.uri, "");
     yield await generateField(property, types, "const ");
@@ -482,13 +504,25 @@ export async function* generateDecoder(
         `;
       }
     }
+    let itemsExpression =
+      `${arrayVariable}.length === 1 && "@list" in ${arrayVariable}[0]
+        ? ${arrayVariable}[0]["@list"]
+        : ${arrayVariable}`;
+    if (
+      isNonFunctionalProperty(property) && property.container === "graph"
+    ) {
+      itemsExpression = `(${itemsExpression}).flatMap((item: unknown) =>
+          item != null && typeof item === "object" && "@graph" in item &&
+            Array.isArray((item as { "@graph": unknown })["@graph"])
+            ? (item as { "@graph": unknown[] })["@graph"]
+            : [item]
+        )`;
+    }
     yield `
     for (
       const v of ${arrayVariable} == null
         ? []
-        : ${arrayVariable}.length === 1 && "@list" in ${arrayVariable}[0]
-        ? ${arrayVariable}[0]["@list"]
-        : ${arrayVariable}
+        : ${itemsExpression}
     ) {
       if (v == null) continue;
     `;
@@ -510,23 +544,18 @@ export async function* generateDecoder(
       }
       `;
     }
+    yield `
+      const decoded =
+    `;
     if (property.range.length == 1) {
-      yield `
-      const decoded = ${
-        getDecoder(
-          property.range[0],
-          types,
-          "v",
-          "options",
-          propertyBaseUrl,
-        )
-      };
-      if (typeof decoded === "undefined") continue;
-      ${variable}.push(decoded);`;
+      yield getDecoder(
+        property.range[0],
+        types,
+        "v",
+        "options",
+        propertyBaseUrl,
+      );
     } else {
-      yield `
-      const decoded =
-      `;
       const decoders = getDecoders(
         property.range,
         types,
@@ -535,19 +564,33 @@ export async function* generateDecoder(
         propertyBaseUrl,
       );
       for (const code of decoders) yield code;
-      yield `
+    }
+    yield `
       ;
-      if (typeof decoded === "undefined") continue;
+    `;
+    yield `
+      if (typeof decoded === "undefined") {
+        shouldCacheJsonLd = false;
+        continue;
+      }
+    `;
+    yield `
+      if (!this._shouldCacheDecodedJsonLd(decoded)) {
+        shouldCacheJsonLd = false;
+      }
       ${variable}.push(decoded);
-      `;
-    }
+    `;
     yield `
     }
     instance.${await getFieldName(property.uri)} = ${variable};
     `;
   }
   yield `
-    if (!("_fromSubclass" in options) || !options._fromSubclass) {
+    instance._shouldCacheJsonLd = shouldCacheJsonLd;
+    if (
+      shouldCacheJsonLd &&
+      (!("_fromSubclass" in options) || !options._fromSubclass)
+    ) {
       try {
         if (cacheJsonLd != null && cacheJsonLd !== expanded) {
           const compactArray = Array.isArray(json) && json.length === 1;

package/src/type.ts

@@ -187,7 +187,8 @@ const scalarTypes: Record<string, ScalarType> = {
     dataCheck(v) {
       return `typeof ${v} === "object" && "@language" in ${v} && "@value" in ${v}
         && typeof ${v}["@language"] === "string"
-        && typeof ${v}["@value"] === "string"`;
+        && typeof ${v}["@value"] === "string"
+        && isValidLanguageTag(${v}["@language"])`;
     },
     decoder(v) {
       return `new LanguageString(${v}["@value"], ${v}["@language"])`;