ldkit 2.5.2 → 2.7.0

package/esm/scripts/schema_to_script.js

@@ -1,5 +1,5 @@
 import { dbo, dc, dcterms, foaf, gr, ldkit, owl, rdf, rdfs, schema, sioc, skos, xsd, } from "../namespaces.js";
-const NAMESPACES = [
+export const NAMESPACES = [
     dbo,
     dc,
     dcterms,
@@ -14,12 +14,12 @@ const NAMESPACES = [
     skos,
     xsd,
 ];
-export function schemaToScript(schemas) {
-    const printer = new SchemaPrinter();
+export function schemaToScript(schemas, extraNamespaces = [], options = {}) {
+    const printer = new SchemaPrinter(extraNamespaces, options);
     return printer.print(schemas);
 }
 class SchemaPrinter {
-    constructor() {
+    constructor(extraNamespaces = [], options = {}) {
         Object.defineProperty(this, "usedNamespaces", {
             enumerable: true,
             configurable: true,
@@ -32,6 +32,68 @@ class SchemaPrinter {
             writable: true,
             value: "  "
         });
+        // Sorted by IRI length desc so longer prefixes match before shorter ones.
+        Object.defineProperty(this, "extraNamespaces", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extraNamespaceTerms", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "shadowedBuiltins", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "schemaLocations", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "currentFile", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extraNamespaceFiles", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extraNamespaceTermsOverride", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "extraNamespacesImportFrom", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "crossFileImports", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        this.extraNamespaces = [...extraNamespaces].sort((a, b) => b.iri.length - a.iri.length);
+        this.shadowedBuiltins = new Set(this.extraNamespaces.map((ns) => ns.prefix));
+        this.schemaLocations = options.schemaLocations ?? new Map();
+        this.currentFile = options.currentFile;
+        this.extraNamespaceFiles = options.extraNamespaceFiles ?? new Map();
+        this.extraNamespaceTermsOverride = options.extraNamespaceTermsOverride;
+        this.extraNamespacesImportFrom = options.extraNamespacesImportFrom;
     }
     print(schemas) {
         const orderedSchemas = this.orderSchemasByDependencies(schemas);
@@ -41,18 +103,20 @@ class SchemaPrinter {
             const printedSchema = this.printSchema(schema);
             printedSchemas.push(printedSchema);
         }
-        if (this.usedNamespaces.size > 0) {
-            printedSchemas.unshift(this.printImports());
+        const header = this.printHeader();
+        if (header) {
+            printedSchemas.unshift(header);
         }
         return printedSchemas.join("\n");
     }
     orderSchemasByDependencies(schemas) {
         const orderedSchemas = [];
         const processedSchemas = new Set();
+        const localNames = new Set(schemas.map((s) => s.name));
         const dependencies = schemas.map((schema) => {
             return {
                 schemaName: schema.name,
-                dependencies: this.getSchemaDependencies(schema),
+                dependencies: this.getSchemaDependencies(schema).filter((dep) => localNames.has(dep)),
             };
         });
         let unresolved = schemas.length;
@@ -93,9 +157,25 @@ class SchemaPrinter {
             this.usedNamespaces.add(this.printPrefix(ldkit));
             return;
         }
+        for (const ns of this.extraNamespaces) {
+            if (value.startsWith(ns.iri)) {
+                const localPart = value.substring(ns.iri.length);
+                let terms = this.extraNamespaceTerms.get(ns.prefix);
+                if (!terms) {
+                    terms = new Set();
+                    this.extraNamespaceTerms.set(ns.prefix, terms);
+                }
+                terms.add(localPart);
+                return;
+            }
+        }
         for (const namespace of NAMESPACES) {
             if (value.startsWith(namespace.$iri)) {
-                this.usedNamespaces.add(this.printPrefix(namespace));
+                const name = this.printPrefix(namespace);
+                if (this.shadowedBuiltins.has(name)) {
+                    return;
+                }
+                this.usedNamespaces.add(name);
                 return;
             }
         }
@@ -114,11 +194,88 @@ class SchemaPrinter {
             }
         }
     }
-    printImports() {
-        const namespacesString = Array.from(this.usedNamespaces)
-            .toSorted()
-            .join(", ");
-        return `import { ${namespacesString} } from "ldkit/namespaces";\n`;
+    trackCrossFileRef(schemaRef) {
+        if (!this.currentFile)
+            return;
+        const refFile = this.schemaLocations.get(schemaRef);
+        if (!refFile || refFile === this.currentFile)
+            return;
+        let names = this.crossFileImports.get(refFile);
+        if (!names) {
+            names = new Set();
+            this.crossFileImports.set(refFile, names);
+        }
+        names.add(schemaRef);
+    }
+    printHeader() {
+        const lines = [];
+        const usedPrefixes = new Set(this.extraNamespaces.map((ns) => ns.prefix))
+            .intersection(new Set(this.extraNamespaceTerms.keys()));
+        const usedExtras = this.extraNamespaces.filter((ns) => usedPrefixes.has(ns.prefix));
+        const declaredExtras = [];
+        const importedByFile = new Map();
+        if (this.extraNamespacesImportFrom !== undefined) {
+            if (usedExtras.length > 0) {
+                importedByFile.set(this.extraNamespacesImportFrom, new Set(usedExtras.map((ns) => ns.prefix)));
+            }
+        }
+        else {
+            for (const ns of usedExtras) {
+                const home = this.extraNamespaceFiles.get(ns.prefix);
+                if (!home || !this.currentFile || home === this.currentFile) {
+                    declaredExtras.push(ns);
+                    continue;
+                }
+                let names = importedByFile.get(home);
+                if (!names) {
+                    names = new Set();
+                    importedByFile.set(home, names);
+                }
+                names.add(ns.prefix);
+            }
+        }
+        if (declaredExtras.length > 0) {
+            lines.push(`import { createNamespace } from "ldkit";`);
+        }
+        if (this.usedNamespaces.size > 0) {
+            const namespacesString = Array.from(this.usedNamespaces)
+                .toSorted()
+                .join(", ");
+            lines.push(`import { ${namespacesString} } from "ldkit/namespaces";`);
+        }
+        const crossFileEntries = [...this.crossFileImports.entries()]
+            .toSorted(([a], [b]) => a.localeCompare(b));
+        for (const [file, names] of crossFileEntries) {
+            const sortedNames = [...names].toSorted().join(", ");
+            lines.push(`import { ${sortedNames} } from "./${file}";`);
+        }
+        const importedExtraEntries = [...importedByFile.entries()]
+            .toSorted(([a], [b]) => a.localeCompare(b));
+        for (const [file, prefixes] of importedExtraEntries) {
+            const sortedPrefixes = [...prefixes].toSorted().join(", ");
+            lines.push(`import { ${sortedPrefixes} } from "./${file}";`);
+        }
+        if (lines.length > 0) {
+            lines.push("");
+        }
+        for (const ns of declaredExtras) {
+            const termSet = this.extraNamespaceTermsOverride?.get(ns.prefix) ??
+                this.extraNamespaceTerms.get(ns.prefix);
+            const terms = Array.from(termSet).toSorted();
+            lines.push(`export const ${ns.prefix} = createNamespace(`);
+            lines.push(`  {`);
+            lines.push(`    iri: ${JSON.stringify(ns.iri)},`);
+            lines.push(`    prefix: ${JSON.stringify(`${ns.prefix}:`)},`);
+            lines.push(`    terms: [`);
+            for (const term of terms) {
+                lines.push(`      ${JSON.stringify(term)},`);
+            }
+            lines.push(`    ],`);
+            lines.push(`  } as const,`);
+            lines.push(`);`);
+            lines.push("");
+        }
+        return lines.join("\n");
     }
     printSchema(schema) {
         const type = this.printType(schema);
@@ -167,6 +324,7 @@ class SchemaPrinter {
             builder.push(this.indent(subSchema));
         }
         else if (prop.schemaRef) {
+            this.trackCrossFileRef(prop.schemaRef);
             builder.push(this.indent(`"@schema": ${prop.schemaRef},`));
         }
         const flags = ["optional", "array", "multilang", "inverse"];
@@ -198,13 +356,29 @@ class SchemaPrinter {
         if (value === "@id") {
             return `${this.printPrefix(ldkit)}.IRI`;
         }
+        for (const ns of this.extraNamespaces) {
+            if (value.startsWith(ns.iri)) {
+                const localPart = value.substring(ns.iri.length);
+                return this.formatNamespaceAccess(ns.prefix, localPart);
+            }
+        }
         for (const namespace of NAMESPACES) {
             if (value.startsWith(namespace.$iri)) {
-                return `${this.printPrefix(namespace)}.${value.substring(namespace.$iri.length)}`;
+                const name = this.printPrefix(namespace);
+                if (this.shadowedBuiltins.has(name)) {
+                    return `"${value}"`;
+                }
+                return `${name}.${value.substring(namespace.$iri.length)}`;
             }
         }
         return `"${value}"`;
     }
+    formatNamespaceAccess(prefix, localPart) {
+        if (/^[A-Za-z_$]\w*$/.test(localPart)) {
+            return `${prefix}.${localPart}`;
+        }
+        return `${prefix}["${localPart}"]`;
+    }
     printKey(key) {
         if (key.match(/^[a-zA-Z0-9_]+$/)) {
             return key;

package/esm/scripts/shacl_to_schema.d.ts

@@ -0,0 +1,11 @@
+import { type ExtraNamespace, type SchemaSpec } from "./schema_to_script.js";
+export type ShaclConversionResult = {
+    schemas: SchemaSpec[];
+    extraNamespaces: ExtraNamespace[];
+    schemaSourcePrefixes: Map<string, string>;
+};
+export type ShaclConversionOptions = {
+    prefixAliases?: Record<string, string>;
+};
+export declare function shaclToSchema(turtle: string, options?: ShaclConversionOptions): ShaclConversionResult;
+//# sourceMappingURL=shacl_to_schema.d.ts.map

package/esm/scripts/shacl_to_schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shacl_to_schema.d.ts","sourceRoot":"","sources":["../../src/scripts/shacl_to_schema.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,UAAU,EAChB,MAAM,uBAAuB,CAAC;AAkE/B,MAAM,MAAM,qBAAqB,GAAG;IAClC,OAAO,EAAE,UAAU,EAAE,CAAC;IACtB,eAAe,EAAE,cAAc,EAAE,CAAC;IAClC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAC3C,CAAC;AAEF,MAAM,MAAM,sBAAsB,GAAG;IACnC,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC,CAAC;AAEF,wBAAgB,aAAa,CAC3B,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,sBAA2B,GACnC,qBAAqB,CAGvB"}