@shaclmate/compiler 4.0.41 → 4.0.43

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

@@ -10,21 +10,22 @@ 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 {
     /**
-     * Properties of this ObjectType.
+     * Fields of this StructType.
      *
      * Mutable to support cycle-handling logic in the compiler.
      */
-    #properties = [];
+    #fields = [];
+    fieldNames = new Set();
     /**
-     * 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).
@@ -37,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?
@@ -53,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"
@@ -68,24 +69,26 @@ export class ObjectType extends AbstractType {
         this.toRdfTypes = toRdfTypes;
         this.tsImports = tsImports;
     }
-    get properties() {
-        return this.#properties;
+    get fields() {
+        return this.#fields;
     }
     get recursive() {
-        return this.properties.some((property) => property.recursive);
+        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;
             }
@@ -106,8 +109,8 @@ export class ObjectType extends AbstractType {
     }
 }
 const nodeKinds = new Set(["BlankNode", "IRI"]);
-(function (ObjectType) {
-    class Property {
+(function (StructType) {
+    class Field {
         /**
          * Documentation comment from rdfs:comment.
          */
@@ -117,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;
         /**
@@ -125,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;
@@ -170,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
@@ -207,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;
                             }
@@ -259,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;
                             }
@@ -277,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 {
@@ -305,7 +308,7 @@ const nodeKinds = new Set(["BlankNode", "IRI"]);
     }
     __decorate([
         Memoize()
-    ], Property.prototype, "recursive", null);
-    ObjectType.Property = Property;
-})(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

@@ -3,9 +3,9 @@ export class AstJsonGenerator {
         return JSON.stringify({
             namedTypes: ast.namedTypes.map((namedType) => ({
                 ...namedType.toJSON(),
-                ...(namedType.kind === "Object"
+                ...(namedType.kind === "Struct"
                     ? {
-                        properties: namedType.properties.map((property) => property.toJSON()),
+                        properties: namedType.fields.map((property) => property.toJSON()),
                     }
                     : {}),
             })),

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -3,13 +3,13 @@ export function transformAstToLabeledPropertyGraph(ast) {
     const nodes = [];
     const relationships = [];
     for (const namedType of ast.namedTypes) {
-        if (namedType.kind === "Object") {
-            const namedObjectType = namedType;
+        if (namedType.kind === "Struct") {
+            const namedStructType = namedType;
             const id = typeId(namedType);
             const properties = {
                 name: { type: "string", value: typeName(namedType) },
             };
-            for (const namedObjectTypeProperty of namedObjectType.properties) {
+            for (const namedObjectTypeProperty of namedStructType.fields) {
                 let itemType;
                 switch (namedObjectTypeProperty.type.kind) {
                     case "DefaultValue":
@@ -18,11 +18,11 @@ export function transformAstToLabeledPropertyGraph(ast) {
                     case "Set":
                         itemType = namedObjectTypeProperty.type.itemType;
                         break;
-                    case "LazyObject":
+                    case "Lazy":
                         itemType = namedObjectTypeProperty.type.resolveType;
                         break;
-                    case "LazyObjectOption":
-                    case "LazyObjectSet":
+                    case "LazyOption":
+                    case "LazySet":
                         itemType = namedObjectTypeProperty.type.resolveType.itemType;
                         break;
                     default:
@@ -31,7 +31,7 @@ export function transformAstToLabeledPropertyGraph(ast) {
                 }
                 switch (itemType.kind) {
                     case "Intersection":
-                    case "Object":
+                    case "Struct":
                     case "Union":
                         if (itemType.name.isJust()) {
                             relationships.push({
@@ -52,7 +52,7 @@ export function transformAstToLabeledPropertyGraph(ast) {
             }
             nodes.push({
                 id,
-                label: typeName(namedObjectType),
+                label: typeName(namedStructType),
                 properties: properties,
             });
         }

package/dist/generators/ts/AbstractContainerType.d.ts

@@ -35,7 +35,7 @@ export declare abstract class AbstractContainerType<ItemTypeT extends AbstractCo
         itemType: ItemTypeT;
     } & ConstructorParameters<typeof AbstractType>[0]);
     get recursive(): boolean;
-    get referencesObjectType(): boolean;
+    get referencesNamedType(): boolean;
     protected get itemConversionFunctionDefault(): AbstractType.ConversionFunction;
     protected get itemValidationFunctionDefault(): Code;
     protected get schemaInitializers(): readonly Code[];

package/dist/generators/ts/AbstractContainerType.js

@@ -26,8 +26,8 @@ export class AbstractContainerType extends AbstractType {
     get recursive() {
         return this.itemType.recursive;
     }
-    get referencesObjectType() {
-        return this.itemType.referencesObjectType;
+    get referencesNamedType() {
+        return this.name.isJust() || this.itemType.referencesNamedType;
     }
     get itemConversionFunctionDefault() {
         return {
@@ -45,7 +45,7 @@ export class AbstractContainerType extends AbstractType {
     }
     get schemaInitializers() {
         const initializers = super.schemaInitializers.concat();
-        if (this.recursive || this.itemType.referencesObjectType) {
+        if (this.recursive || this.referencesNamedType) {
             initializers.push(code `get itemType() { return ${this.itemType.schema}; }`);
         }
         else {
@@ -83,9 +83,9 @@ __decorate([
             case "Union":
                 return true;
             case "DefaultValue":
-            case "LazyObjectOption":
-            case "LazyObjectSet":
-            case "LazyObject":
+            case "LazyOption":
+            case "LazySet":
+            case "Lazy":
             case "Option":
             case "Set":
                 return false;

package/dist/generators/ts/AbstractDateType.d.ts

@@ -1,8 +1,8 @@
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDateType extends AbstractPrimitiveType<Date> {
+    protected readonly inlineExpression: Code;
     readonly equalsFunction: Code;
-    readonly expression: Code;
     readonly filterFunction: Code;
     readonly filterType: Code;
     readonly jsTypes: readonly [{
@@ -16,12 +16,6 @@ export declare abstract class AbstractDateType extends AbstractPrimitiveType<Dat
     fromJsonExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromJsonExpression"]>[0]): Code;
     jsonType(): AbstractPrimitiveType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<Date>["toRdfResourceValuesExpression"]>[0]): Code;
-    protected abstract fromRdfResourceValueExpression(variables: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-    protected fromRdfResourceValuesExpressionChain({ variables, }: Parameters<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>[0]): ReturnType<AbstractPrimitiveType<Date>["fromRdfResourceValuesExpressionChain"]>;
 }
 export declare namespace AbstractDateType {
     type ConversionFunction = AbstractPrimitiveType.ConversionFunction;

package/dist/generators/ts/AbstractDateType.js

@@ -8,8 +8,8 @@ import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractDateType extends AbstractPrimitiveType {
+    inlineExpression = code `Date`;
     equalsFunction = code `${this.reusables.snippets.dateEquals}`;
-    expression = code `Date`;
     filterFunction = code `${this.reusables.snippets.filterDate}`;
     filterType = code `${this.reusables.snippets.DateFilter}`;
     jsTypes = [
@@ -30,16 +30,6 @@ export class AbstractDateType extends AbstractPrimitiveType {
     toRdfResourceValuesExpression({ variables, }) {
         return code `[${this.reusables.snippets.literalFactory}.date(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
     }
-    fromRdfResourceValuesExpressionChain({ variables, }) {
-        return {
-            ...super.fromRdfResourceValuesExpressionChain({ variables }),
-            languageIn: undefined,
-            preferredLanguages: undefined,
-            valueTo: code `chain(values => values.chainMap(value => ${this.fromRdfResourceValueExpression({
-                variables: { value: code `value` },
-            })}))`,
-        };
-    }
 }
 __decorate([
     Memoize()