@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/generators/ts/synthesizeUberObjectUnionType.js

@@ -1,16 +1,18 @@
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { BlankNodeType } from "./BlankNodeType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
+import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 /**
  * Synthesize the $Object union.
  */
 export function synthesizeUberObjectUnionType(parameters) {
-    const objectTypes = parameters.objectTypes.filter((objectType) => !objectType.extern);
-    const nodeKinds = objectTypes.reduce((nodeKinds, objectType) => {
-        for (const nodeKind of objectType.identifierType.nodeKinds) {
+    const namedObjectTypes = parameters.namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
+    invariant(namedObjectTypes.length > 0);
+    const nodeKinds = namedObjectTypes.reduce((nodeKinds, namedObjectType) => {
+        for (const nodeKind of namedObjectType.identifierType.nodeKinds) {
             nodeKinds.add(nodeKind);
         }
         return nodeKinds;
@@ -40,11 +42,10 @@ export function synthesizeUberObjectUnionType(parameters) {
                 break;
         }
     }
-    return new ObjectUnionType({
+    return new NamedObjectUnionType({
         comment: Maybe.empty(),
-        export_: true,
-        features: objectTypes.reduce((features, objectType) => {
-            for (const feature of objectType.features) {
+        features: namedObjectTypes.reduce((features, namedObjectType) => {
+            for (const feature of namedObjectType.features) {
                 features.add(feature);
             }
             features.delete("graphql");
@@ -52,8 +53,12 @@ export function synthesizeUberObjectUnionType(parameters) {
         }, new Set()),
         identifierType,
         label: Maybe.empty(),
-        memberTypes: objectTypes,
+        members: namedObjectTypes.map((namedObjectType) => ({
+            discriminantValue: Maybe.empty(),
+            type: namedObjectType,
+        })),
         name: `${syntheticNamePrefix}Object`,
+        recursive: false,
     });
 }
 //# sourceMappingURL=synthesizeUberObjectUnionType.js.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.d.ts

@@ -1,11 +1,11 @@
-import type { ObjectType } from "./ObjectType.js";
+import type { NamedObjectType } from "./NamedObjectType.js";
 import { type Code } from "./ts-poet-wrapper.js";
-export declare function unsupportedObjectSetMethodDeclarations({ objectType, }: {
-    objectType: {
+export declare function unsupportedObjectSetMethodDeclarations({ namedObjectType, }: {
+    namedObjectType: {
         readonly filterType: Code;
         readonly identifierTypeAlias: Code;
-        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
+        readonly objectSetMethodNames: NamedObjectType.ObjectSetMethodNames;
         readonly name: string;
     };
-}): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, Code>>;
+}): Readonly<Record<keyof NamedObjectType.ObjectSetMethodNames, Code>>;
 //# sourceMappingURL=unsupportedObjectSetMethodDeclarations.d.ts.map

package/dist/generators/ts/unsupportedObjectSetMethodDeclarations.js

@@ -7,9 +7,9 @@ async ${name}(${parameters}): ${returnType} {
   return ${imports.Left}(new Error("${name}: not supported")) satisfies Awaited<${returnType}>;
 }`;
 }
-export function unsupportedObjectSetMethodDeclarations({ objectType, }) {
+export function unsupportedObjectSetMethodDeclarations({ namedObjectType, }) {
     const methodSignatures = objectSetMethodSignatures({
-        objectType,
+        namedObjectType,
         parameterNamePrefix: "_",
     });
     return {

package/dist/input/NodeShape.d.ts

@@ -31,7 +31,6 @@ export declare class NodeShape extends ShaclAstNodeShape<any, Ontology, Property
     get comment(): Maybe<string>;
     get descendantNodeShapes(): Either<Error, readonly NodeShape[]>;
     get discriminantValue(): Maybe<string>;
-    get export(): Maybe<boolean>;
     get extern(): Maybe<boolean>;
     get fromRdfType(): Maybe<NamedNode>;
     get identifierIn(): readonly NamedNode[];

package/dist/input/NodeShape.js

@@ -55,9 +55,6 @@ export class NodeShape extends ShaclAstNodeShape {
     get discriminantValue() {
         return this.generatedNodeShape.discriminantValue;
     }
-    get export() {
-        return this.generatedNodeShape.export_;
-    }
     get extern() {
         return this.generatedNodeShape.extern;
     }

package/dist/input/ShapesGraph.d.ts

@@ -1,4 +1,4 @@
-import { ShapesGraph as _ShapesGraph } from "@shaclmate/shacl-ast";
+import { ShapesGraph as _ShapesGraph, type CurieFactory } from "@shaclmate/shacl-ast";
 import type { Either } from "purify-ts";
 import type { Resource } from "rdfjs-resource";
 import { NodeShape, Ontology, PropertyGroup, PropertyShape, type Shape } from "./index.js";
@@ -15,7 +15,8 @@ export declare namespace ShapesGraph {
         protected createPropertyGroup({ resource, }: {
             resource: Resource;
         }): Either<Error, PropertyGroup>;
-        protected createPropertyShape({ resource, shapesGraph, }: {
+        protected createPropertyShape({ curieFactory, resource, shapesGraph, }: {
+            curieFactory: CurieFactory;
             resource: Resource;
             shapesGraph: ShapesGraph;
         }): Either<Error, PropertyShape>;

package/dist/input/ShapesGraph.js

@@ -1,4 +1,4 @@
-import { ShapesGraph as _ShapesGraph } from "@shaclmate/shacl-ast";
+import { ShapesGraph as _ShapesGraph, } from "@shaclmate/shacl-ast";
 import { owl, rdf, rdfs } from "@tpluscode/rdf-ns-builders";
 import { ancestorClassIris } from "./ancestorClassIris.js";
 import { descendantClassIris } from "./descendantClassIris.js";
@@ -8,7 +8,7 @@ export var ShapesGraph;
 (function (ShapesGraph) {
     class Factory extends _ShapesGraph.Factory {
         createNodeShape({ resource, shapesGraph, }) {
-            return generated.NodeShape.$fromRdf(resource, {
+            return generated.NodeShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedShape) => {
@@ -38,22 +38,27 @@ export var ShapesGraph;
             });
         }
         createOntology({ resource, }) {
-            return generated.Ontology.$fromRdf(resource, {
+            return generated.Ontology.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedOntology) => new Ontology(generatedOntology));
         }
         createPropertyGroup({ resource, }) {
-            return generated.PropertyGroup.$fromRdf(resource, {
+            return generated.PropertyGroup.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
             }).map((generatedPropertyGroup) => new PropertyGroup(generatedPropertyGroup));
         }
-        createPropertyShape({ resource, shapesGraph, }) {
-            return generated.PropertyShape.$fromRdf(resource, {
+        createPropertyShape({ curieFactory, resource, shapesGraph, }) {
+            return generated.PropertyShape.$fromRdfResource(resource, {
                 ignoreRdfType: true,
                 preferredLanguages: this.preferredLanguages,
-            }).map((generatedShape) => new PropertyShape(generatedShape, shapesGraph));
+            }).map((generatedShape) => new PropertyShape({
+                ...generatedShape,
+                path: (generatedShape.path.termType === "NamedNode"
+                    ? curieFactory.create(generatedShape.path).extract()
+                    : undefined) ?? generatedShape.path,
+            }, shapesGraph));
         }
     }
     const factory = new Factory();