@shaclmate/compiler 2.0.13 → 2.0.14

package/input/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./NodeShape.js";
+export * from "./Ontology.js";
+export { PropertyGroup } from "@shaclmate/shacl-ast";
+export * from "./PropertyShape.js";
+export * from "./Shape.js";
+export * from "./ShapesGraph.js";
+//# sourceMappingURL=index.d.ts.map

package/input/index.js

@@ -0,0 +1,7 @@
+export * from "./NodeShape.js";
+export * from "./Ontology.js";
+export { PropertyGroup } from "@shaclmate/shacl-ast";
+export * from "./PropertyShape.js";
+export * from "./Shape.js";
+export * from "./ShapesGraph.js";
+//# sourceMappingURL=index.js.map

package/input/tsFeatures.d.ts

@@ -0,0 +1,10 @@
+import type * as rdfjs from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import { TsFeature } from "../enums/index.js";
+type TsFeatureIri = rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_TsFeature_Create" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash" | "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson" | "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf">;
+export declare function tsFeatures(generated: {
+    readonly tsFeatureExcludes: readonly TsFeatureIri[];
+    readonly tsFeatureIncludes: readonly TsFeatureIri[];
+}): Maybe<Set<TsFeature>>;
+export {};
+//# sourceMappingURL=tsFeatures.d.ts.map

package/input/tsFeatures.js

@@ -0,0 +1,42 @@
+import { Maybe } from "purify-ts";
+import { TsFeature } from "../enums/index.js";
+function iriToTsFeature(iri) {
+    switch (iri.value) {
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_Create":
+            return "create";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_Equals":
+            return "equals";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromJson":
+            return "fromJson";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_FromRdf":
+            return "fromRdf";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_Hash":
+            return "hash";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonSchema":
+            return "jsonSchema";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_JsonUiSchema":
+            return "jsonUiSchema";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_Sparql":
+            return "sparql";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToJson":
+            return "toJson";
+        case "http://minorg.github.io/shaclmate/ns#_TsFeature_ToRdf":
+            return "toRdf";
+    }
+}
+export function tsFeatures(generated) {
+    const tsFeatureIncludes = generated.tsFeatureIncludes.map(iriToTsFeature);
+    const tsFeatureExcludes = generated.tsFeatureExcludes.map(iriToTsFeature);
+    if (tsFeatureIncludes.length > 0) {
+        return Maybe.of(new Set(tsFeatureIncludes));
+    }
+    if (tsFeatureExcludes.length > 0) {
+        const tsFeatures = new Set(TsFeature.MEMBERS);
+        for (const tsFeatureExclude of tsFeatureExcludes) {
+            tsFeatures.delete(tsFeatureExclude);
+        }
+        return Maybe.of(tsFeatures);
+    }
+    return Maybe.empty();
+}
+//# sourceMappingURL=tsFeatures.js.map

package/package.json

@@ -1,32 +1,37 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.13",
+    "@shaclmate/shacl-ast": "2.0.14",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
     "@rdfjs/types": "^1.1.0",
     "@sindresorhus/base62": "^0.1.0",
     "@tpluscode/rdf-ns-builders": "^4.3.0",
-    "@types/n3": "^1.21.1",
     "@types/rdfjs__prefix-map": "^0.1.5",
     "@types/rdfjs__term-map": "^2.0.10",
     "@types/rdfjs__term-set": "^2.0.9",
+    "@types/toposort": "2.0.7",
     "change-case": "^5.4.4",
-    "n3": "^1.21.3",
     "pino": "^9.1.0",
     "reserved-identifiers": "^1.0.0",
+    "toposort": "2.0.2",
     "ts-invariant": "^0.10.3",
     "ts-morph": "^24.0.0",
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/runtime": "2.0.13"
+    "@shaclmate/runtime": "2.0.14",
+    "oxigraph": "^0.4.0"
   },
   "files": [
     "*.d.ts",
     "*.js",
+    "_ShapesGraphToAstTransformer/*.d.ts",
+    "_ShapesGraphToAstTransformer/*.js",
     "ast/*.d.ts",
     "ast/*.js",
+    "enums/*.d.ts",
+    "enums/*.js",
     "generators/*.d.ts",
     "generators/*.js",
     "generators/json/*.d.ts",
@@ -35,8 +40,8 @@
     "generators/ts/*.js",
     "generators/ts/_ObjectType/*.d.ts",
     "generators/ts/_ObjectType/*.js",
-    "vocabularies/*.d.ts",
-    "vocabularies/*.js"
+    "input/*.d.ts",
+    "input/*.js"
   ],
   "main": "index.js",
   "license": "Apache-2.0",
@@ -59,7 +64,8 @@
     "test:coverage": "biome check && vitest run --coverage",
     "test:watch": "vitest watch",
     "unlink": "npm unlink -g @shaclmate/compiler",
-    "watch": "tsc -w --preserveWatchOutput"
+    "watch": "tsc -w --preserveWatchOutput",
+    "watch:noEmit": "tsc --noEmit -w --preserveWatchOutput"
   },
   "repository": {
     "type": "git",
@@ -67,5 +73,5 @@
   },
   "type": "module",
   "types": "index.d.ts",
-  "version": "2.0.13"
+  "version": "2.0.14"
 }

package/ast/MintingStrategy.d.ts

@@ -1,8 +0,0 @@
-/**
- * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
- */
-export declare enum MintingStrategy {
-    SHA256 = 1,
-    UUIDv4 = 2
-}
-//# sourceMappingURL=MintingStrategy.d.ts.map

package/ast/MintingStrategy.js

@@ -1,9 +0,0 @@
-/**
- * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
- */
-export var MintingStrategy;
-(function (MintingStrategy) {
-    MintingStrategy[MintingStrategy["SHA256"] = 1] = "SHA256";
-    MintingStrategy[MintingStrategy["UUIDv4"] = 2] = "UUIDv4";
-})(MintingStrategy || (MintingStrategy = {}));
-//# sourceMappingURL=MintingStrategy.js.map

package/generators/ts/Configuration.d.ts

@@ -1,29 +0,0 @@
-type Feature = "equals" | "fromRdf" | "hash" | "toRdf" | "sparql-graph-patterns";
-export declare class Configuration {
-    readonly dataFactoryImport: string;
-    readonly dataFactoryVariable: string;
-    readonly features: Set<Feature>;
-    readonly objectTypeDeclarationType: "class" | "interface";
-    readonly objectTypeDiscriminatorPropertyName: string;
-    readonly objectTypeIdentifierPropertyName: string;
-    constructor(parameters?: {
-        dataFactoryImport?: string;
-        dataFactoryVariable?: string;
-        features?: Set<Feature>;
-        objectTypeDeclarationType?: "class" | "interface";
-        objectTypeIdentifierPropertyName?: string;
-        objectTypeDiscriminatorPropertyName?: string;
-    });
-}
-export declare namespace Configuration {
-    namespace Defaults {
-        const dataFactoryImport = "import { DataFactory as dataFactory } from \"n3\"";
-        const dataFactoryVariable = "dataFactory";
-        const features: Set<Feature>;
-        const objectTypeDeclarationType: "class";
-        const objectTypeDiscriminatorPropertyName = "type";
-        const objectTypeIdentifierPropertyName = "identifier";
-    }
-}
-export {};
-//# sourceMappingURL=Configuration.d.ts.map

package/generators/ts/Configuration.js

@@ -1,40 +0,0 @@
-export class Configuration {
-    constructor(parameters) {
-        this.features = new Set(parameters?.features ? [...parameters.features] : []);
-        this.dataFactoryImport =
-            parameters?.dataFactoryImport ?? Configuration.Defaults.dataFactoryImport;
-        this.dataFactoryVariable =
-            parameters?.dataFactoryVariable ??
-                Configuration.Defaults.dataFactoryVariable;
-        if (this.features.size === 0) {
-            this.features = Configuration.Defaults.features;
-        }
-        this.objectTypeDeclarationType =
-            parameters?.objectTypeDeclarationType ??
-                Configuration.Defaults.objectTypeDeclarationType;
-        this.objectTypeIdentifierPropertyName =
-            parameters?.objectTypeIdentifierPropertyName ??
-                Configuration.Defaults.objectTypeIdentifierPropertyName;
-        this.objectTypeDiscriminatorPropertyName =
-            parameters?.objectTypeDiscriminatorPropertyName ??
-                Configuration.Defaults.objectTypeDiscriminatorPropertyName;
-    }
-}
-(function (Configuration) {
-    let Defaults;
-    (function (Defaults) {
-        Defaults.dataFactoryImport = 'import { DataFactory as dataFactory } from "n3"';
-        Defaults.dataFactoryVariable = "dataFactory";
-        Defaults.features = new Set([
-            "equals",
-            "fromRdf",
-            "hash",
-            "toRdf",
-            "sparql-graph-patterns",
-        ]);
-        Defaults.objectTypeDeclarationType = "class";
-        Defaults.objectTypeDiscriminatorPropertyName = "type";
-        Defaults.objectTypeIdentifierPropertyName = "identifier";
-    })(Defaults = Configuration.Defaults || (Configuration.Defaults = {}));
-})(Configuration || (Configuration = {}));
-//# sourceMappingURL=Configuration.js.map

package/generators/ts/IntersectionType.d.ts

@@ -1,14 +0,0 @@
-import { Type } from "./Type.js";
-export declare class IntersectionType extends Type {
-    readonly kind = "IntersectionType";
-    readonly memberTypes: readonly Type[];
-    constructor({ memberTypes, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
-        memberTypes: readonly Type[];
-    });
-    get name(): string;
-    equalsFunction(): string;
-    fromRdfExpression(): string;
-    hashStatements(): readonly string[];
-    toRdfExpression(): string;
-}
-//# sourceMappingURL=IntersectionType.d.ts.map

package/generators/ts/IntersectionType.js

@@ -1,26 +0,0 @@
-import { invariant } from "ts-invariant";
-import { Type } from "./Type.js";
-export class IntersectionType extends Type {
-    constructor({ memberTypes, ...superParameters }) {
-        super(superParameters);
-        this.kind = "IntersectionType";
-        invariant(memberTypes.length >= 2);
-        this.memberTypes = memberTypes;
-    }
-    get name() {
-        return `(${this.memberTypes.map((type) => type.name).join(" & ")})`;
-    }
-    equalsFunction() {
-        throw new Error("Method not implemented.");
-    }
-    fromRdfExpression() {
-        throw new Error("Method not implemented.");
-    }
-    hashStatements() {
-        throw new Error("Method not implemented.");
-    }
-    toRdfExpression() {
-        throw new Error("Method not implemented.");
-    }
-}
-//# sourceMappingURL=IntersectionType.js.map

package/generators/ts/RdfjsTermType.d.ts

@@ -1,25 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import { Type } from "./Type.js";
-/**
- * Abstract base class for IdentifierType and LiteralType.
- */
-export declare abstract class RdfjsTermType<RdfjsTermT extends BlankNode | Literal | NamedNode> extends Type {
-    readonly defaultValue: Maybe<RdfjsTermT>;
-    readonly hasValue: Maybe<RdfjsTermT>;
-    abstract readonly kind: "IdentifierType" | "LiteralType";
-    constructor({ defaultValue, hasValue, ...superParameters }: {
-        defaultValue: Maybe<RdfjsTermT>;
-        hasValue: Maybe<RdfjsTermT>;
-    } & ConstructorParameters<typeof Type>[0]);
-    equalsFunction(): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    propertySparqlGraphPatternExpression({ variables, }: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression;
-    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    protected abstract fromRdfResourceValueExpression({ variables, }: {
-        variables: {
-            resourceValue: string;
-        };
-    }): string;
-}
-//# sourceMappingURL=RdfjsTermType.d.ts.map

package/generators/ts/RdfjsTermType.js

@@ -1,46 +0,0 @@
-import { Type } from "./Type.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression";
-/**
- * Abstract base class for IdentifierType and LiteralType.
- */
-export class RdfjsTermType extends Type {
-    constructor({ defaultValue, hasValue, ...superParameters }) {
-        super(superParameters);
-        this.defaultValue = defaultValue;
-        this.hasValue = hasValue;
-    }
-    equalsFunction() {
-        return "purifyHelpers.Equatable.booleanEquals";
-    }
-    fromRdfExpression({ variables, }) {
-        const chain = [`${variables.resourceValues}.head()`];
-        this.hasValue.ifJust((hasValue) => {
-            chain.push(`chain<rdfjsResource.Resource.ValueError, ${this.name}>(_identifier => _identifier.equals(${rdfjsTermExpression(hasValue, this.configuration)}) ? purify.Either.of(_identifier) : purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: _identifier, expectedValueType: "${hasValue.termType}", focusResource: ${variables.resource}, predicate: ${variables.predicate})))`);
-        });
-        this.defaultValue.ifJust((defaultValue) => {
-            chain.push(`alt(purify.Either.of(new rdfjsResource.Resource.Value({ subject: ${variables.resource}, predicate: ${variables.predicate}, object: ${rdfjsTermExpression(defaultValue, this.configuration)} })))`);
-        });
-        chain.push(`chain(value => ${this.fromRdfResourceValueExpression({
-            variables: { resourceValue: "value" },
-        })})`);
-        return chain.join(".");
-    }
-    propertySparqlGraphPatternExpression({ variables, }) {
-        let expression = super
-            .propertySparqlGraphPatternExpression({
-            variables,
-        })
-            .toSparqlGraphPatternExpression()
-            .toString();
-        if (this.defaultValue.isJust()) {
-            expression = `sparqlBuilder.GraphPattern.optional(${expression})`;
-        }
-        return new Type.SparqlGraphPatternExpression(expression);
-    }
-    toRdfExpression({ variables, }) {
-        return this.defaultValue
-            .map((defaultValue) => `!${variables.value}.equals(${rdfjsTermExpression(defaultValue, this.configuration)}) ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
-    }
-}
-//# sourceMappingURL=RdfjsTermType.js.map

package/generators/ts/_ObjectType/fromRdfFunctionDeclaration.d.ts

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function fromRdfFunctionDeclaration(this: ObjectType): FunctionDeclarationStructure;
-//# sourceMappingURL=fromRdfFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/fromRdfFunctionDeclaration.js

@@ -1,72 +0,0 @@
-import { StructureKind } from "ts-morph";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-const variables = {
-    ignoreRdfType: "ignoreRdfType",
-    options: "_options",
-    resource: "resource",
-};
-export function fromRdfFunctionDeclaration() {
-    this.ensureAtMostOneSuperObjectType();
-    const propertiesByName = {};
-    let statements = [];
-    this.rdfType.ifJust((rdfType) => {
-        statements.push(`if (!${variables.options}?.${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${rdfjsTermExpression(rdfType, this.configuration)})) { return purify.Left(new rdfjsResource.Resource.ValueError({ focusResource: ${variables.resource}, message: \`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\`, predicate: ${rdfjsTermExpression(rdfType, this.configuration)} })); }`);
-    });
-    for (const ancestorObjectType of this.ancestorObjectTypes) {
-        for (const property of ancestorObjectType.properties) {
-            if (property.fromRdfStatements({ variables }).length > 0) {
-                propertiesByName[property.name] = {
-                    initializer: `_super.${property.name}`,
-                    type: property.type.name,
-                };
-            }
-        }
-    }
-    for (const property of this.properties) {
-        const propertyFromRdfStatements = property.fromRdfStatements({
-            variables,
-        });
-        if (propertyFromRdfStatements.length > 0) {
-            propertiesByName[property.name] = {
-                type: property.type.name,
-            };
-            statements.push(...propertyFromRdfStatements);
-        }
-    }
-    let construction = `{ ${Object.entries(propertiesByName)
-        .map(([name, { initializer }]) => initializer ? `${name}: ${initializer}` : name)
-        .join(", ")} }`;
-    let returnType = `{ ${Object.entries(propertiesByName)
-        .map(([name, { type }]) => `${name}: ${type}`)
-        .join(", ")} }`;
-    if (this.configuration.objectTypeDeclarationType === "class" &&
-        !this.abstract) {
-        construction = `new ${this.name}(${construction})`;
-        returnType = this.name;
-    }
-    statements.push(`return purify.Either.of(${construction})`);
-    if (this.parentObjectTypes.length > 0) {
-        statements = [
-            `return ${this.parentObjectTypes[0].name}.fromRdf(${variables.resource}, { ${variables.ignoreRdfType}: true }).chain(_super => { ${statements.join("\n")} })`,
-        ];
-    }
-    return {
-        isExported: true,
-        kind: StructureKind.Function,
-        name: "fromRdf",
-        parameters: [
-            {
-                name: variables.resource,
-                type: this.rdfjsResourceType().name,
-            },
-            {
-                hasQuestionToken: true,
-                name: variables.options,
-                type: `{ ${variables.ignoreRdfType}?: boolean }`,
-            },
-        ],
-        returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${returnType}>`,
-        statements,
-    };
-}
-//# sourceMappingURL=fromRdfFunctionDeclaration.js.map

package/generators/ts/_ObjectType/sparqlGraphPatternsClassDeclaration.d.ts

@@ -1,4 +0,0 @@
-import { type ClassDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function sparqlGraphPatternsClassDeclaration(this: ObjectType): ClassDeclarationStructure;
-//# sourceMappingURL=sparqlGraphPatternsClassDeclaration.d.ts.map

package/generators/ts/_ObjectType/sparqlGraphPatternsClassDeclaration.js

@@ -1,46 +0,0 @@
-import { StructureKind } from "ts-morph";
-import { rdfjsTermExpression } from "../rdfjsTermExpression";
-const ignoreRdfTypeVariable = "ignoreRdfType";
-const optionsVariable = "_options";
-const subjectVariable = "subject";
-export function sparqlGraphPatternsClassDeclaration() {
-    this.ensureAtMostOneSuperObjectType();
-    const constructorStatements = [];
-    if (this.parentObjectTypes.length > 0) {
-        constructorStatements.push(`super(${subjectVariable}, { ignoreRdfType: true });`);
-    }
-    else {
-        constructorStatements.push(`super(${subjectVariable});`);
-    }
-    this.rdfType.ifJust((rdfType) => constructorStatements.push(`if (!${optionsVariable}?.${ignoreRdfTypeVariable}) { this.add(...new sparqlBuilder.RdfTypeGraphPatterns(${subjectVariable}, ${rdfjsTermExpression(rdfType, this.configuration)})); }`));
-    for (const property of this.properties) {
-        property
-            .sparqlGraphPatternExpression()
-            .ifJust((sparqlGraphPattern) => constructorStatements.push(`this.add(${sparqlGraphPattern});`));
-    }
-    return {
-        ctors: [
-            {
-                parameters: [
-                    {
-                        name: subjectVariable,
-                        type: "sparqlBuilder.ResourceGraphPatterns.SubjectParameter",
-                    },
-                    {
-                        hasQuestionToken: true,
-                        name: optionsVariable,
-                        type: `{ ${ignoreRdfTypeVariable}?: boolean }`,
-                    },
-                ],
-                statements: constructorStatements,
-            },
-        ],
-        extends: this.parentObjectTypes.length > 0
-            ? `${this.parentObjectTypes[0].name}.SparqlGraphPatterns`
-            : "sparqlBuilder.ResourceGraphPatterns",
-        isExported: true,
-        kind: StructureKind.Class,
-        name: "SparqlGraphPatterns",
-    };
-}
-//# sourceMappingURL=sparqlGraphPatternsClassDeclaration.js.map

package/generators/ts/rdfjsTermExpression.d.ts

@@ -1,5 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-export declare function rdfjsTermExpression(rdfjsTerm: BlankNode | Literal | NamedNode, { dataFactoryVariable }: {
-    dataFactoryVariable: string;
-}): string;
-//# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/vocabularies/dashDataset.d.ts

@@ -1,3 +0,0 @@
-import type { DatasetCore } from "@rdfjs/types";
-export declare const dashDataset: DatasetCore;
-//# sourceMappingURL=dashDataset.d.ts.map