@shaclmate/compiler 4.0.40 → 4.0.42

package/dist/ast/{ObjectType.js → StructType.js}

@@ -5,52 +5,27 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { PropertyPath } from "@rdfx/resource";
-import { NTriplesIdentifier } from "@rdfx/string";
-import genericToposort from "toposort";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractType } from "./AbstractType.js";
 import { arrayEquals } from "./equals.js";
 import { Type } from "./Type.js";
-export class ObjectType extends AbstractType {
+export class StructType extends AbstractType {
     /**
-     * Ancestor (parents, their parents, ad nauseum) ObjectTypes of this ObjectType.
+     * Fields of this StructType.
      *
      * Mutable to support cycle-handling logic in the compiler.
      */
-    #ancestorObjectTypes = [];
+    #fields = [];
+    fieldNames = new Set();
     /**
-     * Immediate child ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #childObjectTypes = [];
-    /**
-     * Descendant (children, their children, ad nauseum) ObjectTypes of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #descendantObjectTypes = [];
-    /**
-     * Immediate parent ObjectTypes of this Object types.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #parentObjectTypes = [];
-    /**
-     * Properties of this ObjectType.
-     *
-     * Mutable to support cycle-handling logic in the compiler.
-     */
-    #properties = [];
-    /**
-     * If true, the code for this ObjectType is defined externally and should not be generated.
+     * If true, the code for this StructType is defined externally and should not be generated.
      *
      * Defaults to false.
      */
     extern;
     /**
-     * The expected rdf:type of instances of this ObjectType.
+     * The expected rdf:type of instances of this StructType.
      *
      * This is usually the identifier of an sh:NodeShape that is also an rdfs:Class (i.e., a node shape with implicit
      * class targets).
@@ -63,7 +38,7 @@ export class ObjectType extends AbstractType {
     /**
      * Type discriminant.
      */
-    kind = "Object";
+    kind = "Struct";
     nodeKinds = nodeKinds;
     /**
      * Was this type synthesized or did it come from SHACL?
@@ -79,7 +54,7 @@ export class ObjectType extends AbstractType {
     /**
      * TypeScript imports to add to generated code.
      *
-     * This is often used in conjunction with extern=true to import the extern'd ObjectType code in order for generated
+     * This is often used in conjunction with extern=true to import the extern'd StructType code in order for generated
      * code to reference it.
      *
      * import { MyType } from "./MyType.js"
@@ -94,48 +69,26 @@ export class ObjectType extends AbstractType {
         this.toRdfTypes = toRdfTypes;
         this.tsImports = tsImports;
     }
-    get ancestorObjectTypes() {
-        return this.#ancestorObjectTypes;
-    }
-    get childObjectTypes() {
-        return this.#childObjectTypes;
-    }
-    get descendantObjectTypes() {
-        return this.#descendantObjectTypes;
-    }
-    get parentObjectTypes() {
-        return this.#parentObjectTypes;
-    }
-    get properties() {
-        return this.#properties;
+    get fields() {
+        return this.#fields;
     }
     get recursive() {
-        return this.properties.some((property) => property.recursive);
-    }
-    addAncestorObjectTypes(...ancestorObjectTypes) {
-        this.#ancestorObjectTypes.push(...ancestorObjectTypes);
-    }
-    addChildObjectTypes(...childObjectTypes) {
-        this.#childObjectTypes.push(...childObjectTypes);
-    }
-    addDescendantObjectTypes(...descendantObjectTypes) {
-        this.#descendantObjectTypes.push(...descendantObjectTypes);
-    }
-    addParentObjectTypes(...parentObjectTypes) {
-        this.#parentObjectTypes.push(...parentObjectTypes);
+        return this.fields.some((field) => field.recursive);
     }
-    addProperties(...properties) {
-        this.#properties.push(...properties);
-        for (const property of properties) {
-            invariant(Object.is(property.objectType, this));
+    addFields(...fields) {
+        for (const field of fields) {
+            invariant(Object.is(field.structType, this), "field has unexpected .structType");
+            invariant(!this.fieldNames.has(field.name), `${field.structType.shapeIdentifier}: duplicate field name: ${field.name}`);
+            this.#fields.push(field);
+            this.fieldNames.add(field.name);
         }
     }
     equals(other) {
         // Don't recurse
         return this.shapeIdentifier.equals(other.shapeIdentifier);
     }
-    sortProperties() {
-        this.#properties.sort((left, right) => {
+    sortFields() {
+        this.#fields.sort((left, right) => {
             if (left.order < right.order) {
                 return -1;
             }
@@ -150,18 +103,14 @@ export class ObjectType extends AbstractType {
             ...super.toJSON(),
             fromRdfType: this.fromRdfType.extract(),
             identifierType: this.identifierType.toJSON(),
-            parentObjectTypes: this.parentObjectTypes.length > 0
-                ? this.parentObjectTypes.map((parentObjectType) => parentObjectType.name.extract() ??
-                    parentObjectType.shapeIdentifier)
-                : undefined,
             synthetic: this.synthetic ? true : undefined,
             toRdfTypes: this.toRdfTypes.length > 0 ? this.toRdfTypes : undefined,
         };
     }
 }
 const nodeKinds = new Set(["BlankNode", "IRI"]);
-(function (ObjectType) {
-    class Property {
+(function (StructType) {
+    class Field {
         /**
          * Documentation comment from rdfs:comment.
          */
@@ -171,7 +120,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          */
         description;
         /**
-         * Should the property and its value be displayed in a toString()-type representation?
+         * Should the field and its value be displayed in a toString()-type representation?
          */
         display;
         /**
@@ -179,42 +128,42 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
          */
         label;
         /**
-         * The property should be mutable in generated code i.e., it should be re-assignable. The property value may or may
+         * The field should be mutable in generated code i.e., it should be re-assignable. The field value may or may
          * not be mutable.
          */
         mutable;
         /**
-         * Name of this property, derived from sh:name or shaclmate:name.
+         * Name of this field, derived from sh:name or shaclmate:name.
          */
         name;
         /**
-         * Object type this property belongs to.
-         */
-        objectType;
-        /**
-         * Relative order of this property, derived from sh:order.
+         * Relative order of this field, derived from sh:order.
          */
         order;
         /**
-         * SHACL property path (https://www.w3.org/TR/shacl/#property-paths)
+         * SHACL property path (https://www.w3.org/TR/shacl/#field-paths)
          */
         path;
         /**
-         * Identifier of the property shape.
+         * Identifier of the field shape.
          */
         shapeIdentifier;
         /**
-         * Type of this property.
+         * StructType this field belongs to.
+         */
+        structType;
+        /**
+         * Type of this field.
          */
         type;
-        constructor({ comment, description, display, label, mutable, name, objectType, order, path, shapeIdentifier, type, }) {
+        constructor({ comment, description, display, label, mutable, name, order, path, shapeIdentifier, structType, type, }) {
             this.comment = comment;
             this.description = description;
             this.display = display;
             this.label = label;
             this.mutable = mutable;
             this.name = name;
-            this.objectType = objectType;
+            this.structType = structType;
             this.order = order;
             this.path = path;
             this.shapeIdentifier = shapeIdentifier;
@@ -224,35 +173,35 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
             return this.shapeIdentifier.equals(other.shapeIdentifier);
         }
         /**
-         * Does the property directly or indirectly reference the ObjectType itself?
+         * Does the field directly or indirectly reference the StructType itself?
          */
         get recursive() {
             const DEBUG = false;
-            const rootObjectType = this.objectType;
-            const rootProperty = this;
+            const rootField = this;
+            const rootStructType = this.structType;
             function helper(stack) {
                 const currentStackFrame = stack.at(-1);
-                const { objectType, property, propertyType } = currentStackFrame;
+                const { field, fieldType, structType } = currentStackFrame;
                 if (DEBUG) {
                     process.stderr.write(`${[
                         stack.length.toString(),
-                        rootObjectType,
-                        rootProperty,
-                        objectType,
-                        property,
-                        propertyType
-                            ? `[${propertyType.map(Type.toString).join(", ")}]`
+                        rootField,
+                        rootStructType,
+                        field,
+                        fieldType
+                            ? `[${fieldType.map(Type.toString).join(", ")}]`
                             : "undefined",
+                        structType,
                     ].join(",")}\n`);
                 }
                 for (const lowerStackFrame of stack.slice(0, -1)) {
-                    if (!Type.equals(currentStackFrame.objectType, lowerStackFrame.objectType)) {
+                    if (!Type.equals(currentStackFrame.structType, lowerStackFrame.structType)) {
                         continue;
                     }
-                    if (!currentStackFrame.property.equals(lowerStackFrame.property)) {
+                    if (!currentStackFrame.field.equals(lowerStackFrame.field)) {
                         continue;
                     }
-                    if (!arrayEquals(Type.equals)(currentStackFrame.propertyType ?? [], lowerStackFrame.propertyType ?? [])) {
+                    if (!arrayEquals(Type.equals)(currentStackFrame.fieldType ?? [], lowerStackFrame.fieldType ?? [])) {
                         continue;
                     }
                     // We've seen this combination before and don't want to recurse further, to avoid infinite recursion
@@ -261,49 +210,49 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                     }
                     return true;
                 }
-                if (!propertyType) {
+                if (!fieldType) {
                     return helper(stack.concat({
-                        objectType,
-                        property,
-                        propertyType: [property.type],
+                        field,
+                        fieldType: [field.type],
+                        structType,
                     }));
                 }
-                invariant(propertyType.length > 0);
-                const currentPropertyType = propertyType.at(-1);
-                switch (currentPropertyType.kind) {
+                invariant(fieldType.length > 0);
+                const currentFieldType = fieldType.at(-1);
+                switch (currentFieldType.kind) {
                     case "BlankNode":
                     case "Identifier":
                     case "Iri":
                     case "Literal":
                     case "Term":
                         return false;
-                    case "LazyObjectOption":
-                    case "LazyObjectSet":
-                    case "LazyObject": {
+                    case "LazyOption":
+                    case "LazySet":
+                    case "Lazy": {
                         if (helper(stack.concat({
-                            objectType,
-                            property,
-                            propertyType: propertyType.concat(currentPropertyType.partialType),
+                            field,
+                            fieldType: fieldType.concat(currentFieldType.partialType),
+                            structType,
                         }))) {
                             return true;
                         }
                         if (helper(stack.concat({
-                            objectType,
-                            property,
-                            propertyType: propertyType.concat(currentPropertyType.resolveType),
+                            field,
+                            fieldType: fieldType.concat(currentFieldType.resolveType),
+                            structType,
                         }))) {
                             return true;
                         }
                         return false;
                     }
-                    case "Object": {
+                    case "Struct": {
                         if (DEBUG) {
-                            process.stderr.write(`recurse into ${currentPropertyType}`);
+                            process.stderr.write(`recurse into ${currentFieldType}`);
                         }
-                        for (const property of currentPropertyType.properties) {
+                        for (const field of currentFieldType.fields) {
                             if (helper(stack.concat({
-                                objectType: currentPropertyType,
-                                property,
+                                structType: currentFieldType,
+                                field,
                             }))) {
                                 return true;
                             }
@@ -313,13 +262,13 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                     case "Intersection":
                     case "Union": {
                         if (DEBUG) {
-                            process.stderr.write(`recurse into ${currentPropertyType}`);
+                            process.stderr.write(`recurse into ${currentFieldType}`);
                         }
-                        for (const member of currentPropertyType.members) {
+                        for (const member of currentFieldType.members) {
                             if (helper(stack.concat({
-                                objectType,
-                                property,
-                                propertyType: propertyType.concat(member.type),
+                                field,
+                                fieldType: fieldType.concat(member.type),
+                                structType,
                             }))) {
                                 return true;
                             }
@@ -331,13 +280,13 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
                     case "Option":
                     case "Set":
                         return helper(stack.concat({
-                            objectType,
-                            property,
-                            propertyType: propertyType.concat(currentPropertyType.itemType),
+                            field,
+                            fieldType: fieldType.concat(currentFieldType.itemType),
+                            structType,
                         }));
                 }
             }
-            return helper([{ objectType: rootObjectType, property: rootProperty }]);
+            return helper([{ structType: rootStructType, field: rootField }]);
         }
         toJSON() {
             return {
@@ -359,31 +308,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
     }
     __decorate([
         Memoize()
-    ], Property.prototype, "recursive", null);
-    ObjectType.Property = Property;
-})(ObjectType || (ObjectType = {}));
-(function (ObjectType) {
-    function toposort(objectTypes) {
-        const objectTypesByShapeIdentifier = {};
-        const objectTypeGraphNodes = [];
-        const objectTypeGraphEdges = [];
-        for (const objectType of objectTypes) {
-            const objectTypeShapeIdentifier = NTriplesIdentifier.stringify(objectType.shapeIdentifier);
-            invariant(!objectTypesByShapeIdentifier[objectTypeShapeIdentifier]);
-            objectTypesByShapeIdentifier[objectTypeShapeIdentifier] = objectType;
-            objectTypeGraphNodes.push(objectTypeShapeIdentifier);
-            for (const parentAstObjectType of objectType.parentObjectTypes) {
-                objectTypeGraphEdges.push([
-                    objectTypeShapeIdentifier,
-                    NTriplesIdentifier.stringify(parentAstObjectType.shapeIdentifier),
-                ]);
-            }
-        }
-        return genericToposort
-            .array(objectTypeGraphNodes, objectTypeGraphEdges)
-            .map((objectTypeIdentifier) => objectTypesByShapeIdentifier[objectTypeIdentifier])
-            .reverse();
-    }
-    ObjectType.toposort = toposort;
-})(ObjectType || (ObjectType = {}));
-//# sourceMappingURL=ObjectType.js.map
+    ], Field.prototype, "recursive", null);
+    StructType.Field = Field;
+})(StructType || (StructType = {}));
+//# sourceMappingURL=StructType.js.map

package/dist/ast/StructUnionType.d.ts

@@ -0,0 +1,4 @@
+import type { StructType } from "./StructType.js";
+import type { UnionType } from "./UnionType.js";
+export type StructUnionType = UnionType<UnionType<StructType> | StructType>;
+//# sourceMappingURL=StructUnionType.d.ts.map

package/dist/ast/StructUnionType.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=StructUnionType.js.map

package/dist/ast/Type.d.ts

@@ -3,17 +3,17 @@ import type { DefaultValueType } from "./DefaultValueType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
 import type { IriType } from "./IriType.js";
-import type { LazyObjectOptionType } from "./LazyObjectOptionType.js";
-import type { LazyObjectSetType } from "./LazyObjectSetType.js";
-import type { LazyObjectType } from "./LazyObjectType.js";
+import type { LazyOptionType } from "./LazyOptionType.js";
+import type { LazySetType } from "./LazySetType.js";
+import type { LazyType } from "./LazyType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
-import type { ObjectType } from "./ObjectType.js";
 import type { OptionType } from "./OptionType.js";
 import type { SetType } from "./SetType.js";
+import type { StructType } from "./StructType.js";
 import type { TermType } from "./TermType.js";
 import type { UnionType } from "./UnionType.js";
-export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType | LiteralType | ObjectType | OptionType | SetType | TermType | UnionType;
+export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyOptionType | LazySetType | LazyType | ListType | LiteralType | StructType | OptionType | SetType | TermType | UnionType;
 export declare namespace Type {
     function equals(left: Type, right: Type): boolean;
 }

package/dist/ast/Type.js

@@ -17,15 +17,15 @@ export var Type;
                 return left.equals(right);
             case "Literal":
                 return left.equals(right);
-            case "LazyObjectOption":
+            case "LazyOption":
                 return left.equals(right);
-            case "LazyObjectSet":
+            case "LazySet":
                 return left.equals(right);
-            case "LazyObject":
+            case "Lazy":
                 return left.equals(right);
             case "List":
                 return left.equals(right);
-            case "Object":
+            case "Struct":
                 return left.equals(right);
             case "Option":
                 return left.equals(right);

package/dist/ast/UnionType.d.ts

@@ -1,12 +1,12 @@
 import type { Maybe } from "purify-ts";
 import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
+import type { StructUnionType } from "./StructUnionType.js";
 /**
  * A disjunction/union of types, corresponding to an sh:xone.
  */
 export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionType.MemberType> extends AbstractCompoundType<UnionType.Member<MemberTypeT>, MemberTypeT> {
     readonly kind = "Union";
-    isObjectUnionType(): this is ObjectUnionType;
+    isStructUnionType(): this is StructUnionType;
     toJSON(): {
         members: {
             discriminantValue: string | number | undefined;

package/dist/ast/UnionType.js

@@ -4,10 +4,10 @@ import { AbstractCompoundType } from "./AbstractCompoundType.js";
  */
 export class UnionType extends AbstractCompoundType {
     kind = "Union";
-    isObjectUnionType() {
+    isStructUnionType() {
         return (this.members.length > 0 &&
-            this.members.every((member) => member.type.kind === "Object" ||
-                (member.type.kind === "Union" && member.type.isObjectUnionType())));
+            this.members.every((member) => member.type.kind === "Struct" ||
+                (member.type.kind === "Union" && member.type.isStructUnionType())));
     }
     toJSON() {
         return {

package/dist/ast/index.d.ts

@@ -4,17 +4,17 @@ export * from "./DefaultValueType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
 export * from "./IriType.js";
-export * from "./LazyObjectOptionType.js";
-export * from "./LazyObjectSetType.js";
-export * from "./LazyObjectType.js";
+export * from "./LazyOptionType.js";
+export * from "./LazySetType.js";
+export * from "./LazyType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
-export * from "./ObjectCompoundType.js";
-export * from "./ObjectIntersectionType.js";
-export * from "./ObjectType.js";
-export * from "./ObjectUnionType.js";
 export * from "./OptionType.js";
 export * from "./SetType.js";
+export * from "./StructCompoundType.js";
+export * from "./StructIntersectionType.js";
+export * from "./StructType.js";
+export * from "./StructUnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";
 export * from "./UnionType.js";

package/dist/ast/index.js

@@ -4,17 +4,17 @@ export * from "./DefaultValueType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
 export * from "./IriType.js";
-export * from "./LazyObjectOptionType.js";
-export * from "./LazyObjectSetType.js";
-export * from "./LazyObjectType.js";
+export * from "./LazyOptionType.js";
+export * from "./LazySetType.js";
+export * from "./LazyType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
-export * from "./ObjectCompoundType.js";
-export * from "./ObjectIntersectionType.js";
-export * from "./ObjectType.js";
-export * from "./ObjectUnionType.js";
 export * from "./OptionType.js";
 export * from "./SetType.js";
+export * from "./StructCompoundType.js";
+export * from "./StructIntersectionType.js";
+export * from "./StructType.js";
+export * from "./StructUnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";
 export * from "./UnionType.js";

package/dist/generators/AstJsonGenerator.js

@@ -1,9 +1,13 @@
 export class AstJsonGenerator {
     generate(ast) {
         return JSON.stringify({
-            objectTypes: ast.namedObjectTypes.map((objectType) => ({
-                ...objectType.toJSON(),
-                properties: objectType.properties.map((property) => property.toJSON()),
+            namedTypes: ast.namedTypes.map((namedType) => ({
+                ...namedType.toJSON(),
+                ...(namedType.kind === "Struct"
+                    ? {
+                        properties: namedType.fields.map((property) => property.toJSON()),
+                    }
+                    : {}),
             })),
         }, undefined, 2);
     }