@shaclmate/compiler 4.0.49 → 4.0.51

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.js

@@ -67,8 +67,13 @@ export function transformShapeToAstStructType(shape, shapeStack) {
             const isClass = nodeShape.subClassOf.length > 0 ||
                 nodeShape.types.some((type) => type.equals(owl.Class) || type.equals(rdfs.Class));
             let fromRdfType = nodeShape.fromRdfType.alt(nodeShape.rdfType);
-            if (isClass && nodeShapeIdentifier.termType === "NamedNode") {
-                fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
+            if (isClass) {
+                if (nodeShapeIdentifier.termType === "NamedNode") {
+                    fromRdfType = fromRdfType.alt(Maybe.of(nodeShapeIdentifier));
+                }
+            }
+            else if (nodeShape.targetClasses.length > 0) {
+                fromRdfType = fromRdfType.alt(Maybe.of(nodeShape.targetClasses[0]));
             }
             const toRdfTypes = nodeShape.toRdfTypes.concat();
             if (toRdfTypes.length === 0) {

package/dist/generators/ts/ObjectType.d.ts

@@ -69,6 +69,7 @@ export declare class ObjectType extends AbstractType {
     protected get createFunction(): Code;
     protected get thisVariable(): Code;
     protected get toJsonFunction(): Code;
+    protected get toRdfTypesVariable(): Maybe<Code>;
     protected get toStringFunction(): Code;
     private get inlineExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;

package/dist/generators/ts/ObjectType.js

@@ -40,7 +40,7 @@ import { ObjectType_valueSparqlConstructTriplesFunctionExpression } from "./_Obj
 import { ObjectType_valueSparqlWherePatternsFunctionExpression } from "./_ObjectType/ObjectType_valueSparqlWherePatternsFunctionExpression.js";
 import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
 import { AbstractType } from "./AbstractType.js";
-import { code, def, joinCode } from "./ts-poet-wrapper.js";
+import { arrayOf, code, def, joinCode } from "./ts-poet-wrapper.js";
 import { tsComment } from "./tsComment.js";
 export class ObjectType extends AbstractType {
     toRdfTypes;
@@ -339,6 +339,14 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
             .map((name) => code `${name}.toJson`)
             .orDefaultLazy(() => ObjectType_toJsonFunctionExpression.call(this));
     }
+    get toRdfTypesVariable() {
+        if (this.toRdfTypes.length === 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of(this.name
+            .map((name) => code `${name}.schema.toRdfTypes`)
+            .orDefaultLazy(() => code `${arrayOf(...this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)))}`));
+    }
     get toStringFunction() {
         return this.name
             .map((name) => code `${name}.${this.configuration.syntheticNamePrefix}toString`)
@@ -478,6 +486,9 @@ __decorate([
 __decorate([
     Memoize()
 ], ObjectType.prototype, "toJsonFunction", null);
+__decorate([
+    Memoize()
+], ObjectType.prototype, "toRdfTypesVariable", null);
 __decorate([
     Memoize()
 ], ObjectType.prototype, "toStringFunction", null);

package/dist/generators/ts/Snippets.d.ts

@@ -22,6 +22,7 @@ export declare class Snippets {
     get DateFilter(): Snippet;
     get DateSchema(): Snippet;
     get DefaultValueSchema(): Snippet;
+    get EqualsFunction(): Snippet;
     get EqualsResult(): Snippet;
     get FocusSparqlConstructTriplesFunction(): Snippet;
     get FocusSparqlWherePatternsFunction(): Snippet;
@@ -147,6 +148,8 @@ export declare class Snippets {
     get parseBlankNode(): Snippet;
     get parseIdentifier(): Snippet;
     get parseIri(): Snippet;
+    get propertyEquals(): Snippet;
+    get rdfResourceIdentifierValues(): Snippet;
     get sequenceRecord(): Snippet;
     get setFromRdfResourceValues(): Snippet;
     get setSparqlConstructTriples(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -53,6 +53,7 @@ import { snippets_decodeBigDecimalLiteral } from "./_snippets/snippets_decodeBig
 import { snippets_deduplicateSparqlPatterns } from "./_snippets/snippets_deduplicateSparqlPatterns.js";
 import { snippets_defaultValueFromRdfResourceValues } from "./_snippets/snippets_defaultValueFromRdfResourceValues.js";
 import { snippets_defaultValueSparqlWherePatterns } from "./_snippets/snippets_defaultValueSparqlWherePatterns.js";
+import { snippets_EqualsFunction } from "./_snippets/snippets_EqualsFunction.js";
 import { snippets_EqualsResult } from "./_snippets/snippets_EqualsResult.js";
 import { snippets_ensureRdfResourceType } from "./_snippets/snippets_ensureRdfResourceType.js";
 import { snippets_FocusSparqlConstructTriplesFunction } from "./_snippets/snippets_FocusSparqlConstructTriplesFunction.js";
@@ -125,7 +126,9 @@ import { snippets_PropertyPath } from "./_snippets/snippets_PropertyPath.js";
 import { snippets_parseBlankNode } from "./_snippets/snippets_parseBlankNode.js";
 import { snippets_parseIdentifier } from "./_snippets/snippets_parseIdentifier.js";
 import { snippets_parseIri } from "./_snippets/snippets_parseIri.js";
+import { snippets_propertyEquals } from "./_snippets/snippets_propertyEquals.js";
 import { snippets_RdfVocabularies } from "./_snippets/snippets_RdfVocabularies.js";
+import { snippets_rdfResourceIdentifierValues } from "./_snippets/snippets_rdfResourceIdentifierValues.js";
 import { snippets_ShaclPropertySchema } from "./_snippets/snippets_ShaclPropertySchema.js";
 import { snippets_SparqlFilterPattern } from "./_snippets/snippets_SparqlFilterPattern.js";
 import { snippets_SparqlPattern } from "./_snippets/snippets_SparqlPattern.js";
@@ -205,6 +208,9 @@ export class Snippets {
     get DefaultValueSchema() {
         return this.snippet(snippets_DefaultValueSchema);
     }
+    get EqualsFunction() {
+        return this.snippet(snippets_EqualsFunction);
+    }
     get EqualsResult() {
         return this.snippet(snippets_EqualsResult);
     }
@@ -596,6 +602,12 @@ export class Snippets {
     get parseIri() {
         return this.snippet(snippets_parseIri);
     }
+    get propertyEquals() {
+        return this.snippet(snippets_propertyEquals);
+    }
+    get rdfResourceIdentifierValues() {
+        return this.snippet(snippets_rdfResourceIdentifierValues);
+    }
     get sequenceRecord() {
         return this.snippet(snippets_sequenceRecord);
     }
@@ -716,6 +728,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "DefaultValueSchema", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "EqualsFunction", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "EqualsResult", null);
@@ -1088,6 +1103,12 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "parseIri", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "propertyEquals", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "rdfResourceIdentifierValues", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "sequenceRecord", null);

package/dist/generators/ts/_ObjectType/AbstractProperty.d.ts

@@ -126,11 +126,8 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "express
      */
     abstract fromRdfResourceValuesInitializer(parameters: {
         variables: {
-            context: Code;
             focusResource: Code;
-            graph: Code;
-            objectSet: Code;
-            preferredLanguages: Code;
+            options: Code;
         };
     }): Maybe<Code>;
     /**

package/dist/generators/ts/_ObjectType/IdentifierProperty.js

@@ -123,20 +123,9 @@ export class IdentifierProperty extends AbstractProperty {
         })}`);
     }
     fromRdfResourceValuesInitializer({ variables, }) {
-        const options = {
-            context: variables.context,
-            graph: variables.graph,
-            focusResource: variables.focusResource,
-            preferredLanguages: variables.preferredLanguages,
-            propertyPath: this.rdfjsTermExpression(rdf.subject),
-            schema: this.typeSchemaVariable,
-        };
-        if (this.configuration.features.has("ObjectSet")) {
-            options["objectSet"] = variables.objectSet;
-        }
         return Maybe.of(code `${this.name}: ${this.type.fromRdfResourceValuesFunction}(
-          new ${this.reusables.imports.Resource}.Value(${{ dataFactory: this.reusables.imports.dataFactory, focusResource: variables.focusResource, propertyPath: this.rdfjsTermExpression(rdf.subject), term: code `${variables.focusResource}.identifier` }}).toValues(),
-          ${options}
+          ${this.reusables.snippets.rdfResourceIdentifierValues}(${variables.focusResource}),
+          { ...${variables.options}, focusResource: ${variables.focusResource}, propertyPath: ${this.rdfjsTermExpression(rdf.subject)}, schema: ${this.typeSchemaVariable} }
         ).chain(values => values.head())`);
     }
     hashStatements({ variables, }) {

package/dist/generators/ts/_ObjectType/ObjectType_equalsFunctionExpression.js

@@ -1,11 +1,15 @@
-import { code, joinCode } from "../ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 export function ObjectType_equalsFunctionExpression() {
     const chain = [];
     for (const property of this.properties) {
         if (property.kind === "Discriminant") {
             continue;
         }
-        chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: code `left` } })}, ${property.accessExpression({ variables: { object: code `right` } })}).mapLeft(propertyValuesUnequal => ({ left, right, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
+        chain.push(code `${this.reusables.snippets.propertyEquals}(
+        { equalsFunction: ${property.type.equalsFunction}, name: ${literalOf(property.name)} },
+        [left, ${property.accessExpression({ variables: { object: code `left` } })}],
+        [right, ${property.accessExpression({ variables: { object: code `right` } })}],
+      )`);
     }
     return code `\
 ((left, right) =>

package/dist/generators/ts/_ObjectType/ObjectType_fromRdfResourceFunctionExpression.js

@@ -1,22 +1,14 @@
 import { invariant } from "ts-invariant";
 import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
 export function ObjectType_fromRdfResourceFunctionExpression() {
-    const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-    const optionsVariable = `_${syntheticNamePrefix}options`;
+    const optionsVariable = code `options`;
     const variables = {
         context: code `${optionsVariable}.context`,
         graph: code `${optionsVariable}.graph`,
         ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
         objectSet: code `${optionsVariable}.objectSet`,
         preferredLanguages: code `${optionsVariable}.preferredLanguages`,
-        resource: code `${syntheticNamePrefix}resource`,
-    };
-    const propertyFromRdfResourceValuesVariables = {
-        context: variables.context,
-        focusResource: variables.resource,
-        graph: variables.graph,
-        objectSet: variables.objectSet,
-        preferredLanguages: variables.preferredLanguages,
+        resource: code `resource`,
     };
     const chains = [];
     this.fromRdfTypeVariable.ifJust((fromRdfTypeVariable) => {
@@ -27,7 +19,10 @@ export function ObjectType_fromRdfResourceFunctionExpression() {
     });
     const propertyFromRdfResourceValuesInitializers = this.properties.flatMap((property) => property
         .fromRdfResourceValuesInitializer({
-        variables: propertyFromRdfResourceValuesVariables,
+        variables: {
+            focusResource: variables.resource,
+            options: optionsVariable,
+        },
     })
         .toList());
     invariant(Object.keys(propertyFromRdfResourceValuesInitializers).length > 0);

package/dist/generators/ts/_ObjectType/ObjectType_schemaExpression.js

@@ -1,5 +1,5 @@
 import { invariant } from "ts-invariant";
-import { code } from "../ts-poet-wrapper.js";
+import { arrayOf, code } from "../ts-poet-wrapper.js";
 export function ObjectType_schemaExpression() {
     const schema = {};
     this.fromRdfType.ifJust((fromRdfType) => {
@@ -13,6 +13,9 @@ export function ObjectType_schemaExpression() {
     }
     invariant(Object.keys(properties).length > 0);
     schema["properties"] = properties;
+    if (this.toRdfTypes.length > 0) {
+        schema["toRdfTypes"] = arrayOf(...this.toRdfTypes.map((toRdfType) => this.rdfjsTermExpression(toRdfType)));
+    }
     return code `${schema} as const`;
 }
 //# sourceMappingURL=ObjectType_schemaExpression.js.map

package/dist/generators/ts/_ObjectType/ObjectType_toRdfResourceFunctionExpression.js

@@ -2,9 +2,9 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { code, joinCode } from "../ts-poet-wrapper.js";
 export function ObjectType_toRdfResourceFunctionExpression() {
     const statements = [];
-    if (this.toRdfTypes.length > 0) {
-        statements.push(code `if (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
-    }
+    this.toRdfTypesVariable.ifJust((toRdfTypesVariable) => {
+        statements.push(code `if (!${variables.ignoreRdfType}) { ${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${toRdfTypesVariable}, ${variables.graph}); }`);
+    });
     for (const property of this.properties) {
         statements.push(...property.toRdfRdfResourceValuesStatements({
             variables: {

package/dist/generators/ts/_ObjectType/ShaclProperty.js

@@ -166,22 +166,14 @@ export class ShaclProperty extends AbstractProperty {
         })}`);
     }
     fromRdfResourceValuesInitializer({ variables, }) {
-        const parameters = {
-            context: variables.context,
-            graph: variables.graph,
-            focusResource: variables.focusResource,
-            // Assume the property has the correct range and ignore the object's RDF type.
-            // This also accommodates the case where the object of a property is a dangling identifier that's not the
-            // subject of any statements.
-            ignoreRdfType: true,
-            preferredLanguages: variables.preferredLanguages,
-            propertySchema: this.schemaVariable,
-            typeFromRdfResourceValues: this.type.fromRdfResourceValuesFunction,
-        };
-        if (this.configuration.features.has("ObjectSet")) {
-            parameters["objectSet"] = variables.objectSet;
-        }
-        return Maybe.of(code `${this.name}: ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schemaType}>(${parameters})`);
+        return Maybe.of(code `${this.name}:
+        ${this.reusables.snippets.shaclPropertyFromRdf}<${this.type.expression}, ${this.type.schemaType}>({
+          ...${variables.options},
+          focusResource: ${variables.focusResource},
+          ignoreRdfType: true,
+          propertySchema: ${this.schemaVariable},
+          typeFromRdfResourceValues: ${this.type.fromRdfResourceValuesFunction} 
+        })`);
     }
     hashStatements({ variables, }) {
         return [

package/dist/generators/ts/_snippets/snippets_EqualsFunction.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_EqualsFunction: SnippetFactory;
+//# sourceMappingURL=snippets_EqualsFunction.d.ts.map

package/dist/generators/ts/_snippets/snippets_EqualsFunction.js

@@ -0,0 +1,4 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_EqualsFunction = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}EqualsFunction`, code `\
+export type ${syntheticNamePrefix}EqualsFunction<T> = (left: T, right: T) => ${snippets.EqualsResult};`);
+//# sourceMappingURL=snippets_EqualsFunction.js.map

package/dist/generators/ts/_snippets/snippets_propertyEquals.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_propertyEquals: SnippetFactory;
+//# sourceMappingURL=snippets_propertyEquals.d.ts.map

package/dist/generators/ts/_snippets/snippets_propertyEquals.js

@@ -0,0 +1,11 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_propertyEquals = ({ snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}propertyEquals`, code `\
+function ${syntheticNamePrefix}propertyEquals<ObjectT, PropertyValueT>(
+  property: Readonly<{ equalsFunction: ${snippets.EqualsFunction}<PropertyValueT>; name: string; }>,
+  left: readonly [ObjectT, PropertyValueT],
+  right: readonly [ObjectT, PropertyValueT]
+): ${snippets.EqualsResult} {
+  return property.equalsFunction(left[1], right[1])
+    .mapLeft(propertyValuesUnequal => ({ left: left[0], right: right[0], propertyName: property.name, propertyValuesUnequal, type: "property" as const }));
+}`);
+//# sourceMappingURL=snippets_propertyEquals.js.map

package/dist/generators/ts/_snippets/snippets_rdfResourceIdentifierValues.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_rdfResourceIdentifierValues: SnippetFactory;
+//# sourceMappingURL=snippets_rdfResourceIdentifierValues.d.ts.map

package/dist/generators/ts/_snippets/snippets_rdfResourceIdentifierValues.js

@@ -0,0 +1,12 @@
+import { rdf } from "@tpluscode/rdf-ns-builders";
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_rdfResourceIdentifierValues = ({ imports, rdfjsTermExpression, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}rdfResourceIdentifierValues`, code `\
+function ${syntheticNamePrefix}rdfResourceIdentifierValues(resource: ${imports.Resource}): ${imports.Resource}.Values {
+  return new ${imports.Resource}.Value({
+    dataFactory: ${imports.dataFactory},
+    focusResource: resource,
+    propertyPath: ${rdfjsTermExpression(rdf.subject)},
+    term: resource.identifier,
+  }).toValues();
+}`);
+//# sourceMappingURL=snippets_rdfResourceIdentifierValues.js.map

package/dist/input/ShapesGraph.d.ts

@@ -3,7 +3,7 @@ import type { Either } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { Ast } from "../ast/Ast.js";
 import type { Generator } from "../generators/Generator.js";
-import * as generated from "./generated.js";
+import * as generated from "./input.shaclmate.js";
 export declare class ShapesGraph extends AbstractShapesGraph<generated.NodeShape, generated.Ontology, generated.PropertyGroup, generated.PropertyShape> {
     protected readonly typeFunctions: {
         readonly NodeShape: typeof generated.NodeShape;

package/dist/input/ShapesGraph.js

@@ -1,7 +1,7 @@
 import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
 import { Compiler } from "../Compiler.js";
 import { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import * as generated from "./generated.js";
+import * as generated from "./input.shaclmate.js";
 const typeFunctions = {
     NodeShape: generated.NodeShape,
     Ontology: generated.Ontology,

package/dist/input/index.d.ts

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

package/dist/input/index.js

@@ -1,3 +1,3 @@
-export { NodeShape, Ontology, PropertyGroup, PropertyShape, Shape, } from "./generated.js";
+export { NodeShape, Ontology, PropertyGroup, PropertyShape, Shape, } from "./input.shaclmate.js";
 export * from "./ShapesGraph.js";
 //# sourceMappingURL=index.js.map