@shaclmate/compiler 4.0.23 → 4.0.24

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

@@ -16,31 +16,18 @@ import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { arrayOf, code, joinCode } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class IdentifierProperty extends AbstractProperty {
-    identifierMintingStrategy;
-    identifierPrefixPropertyName;
     typeAlias;
     kind = "IdentifierProperty";
     mutable = false;
     recursive = false;
-    constructor({ identifierMintingStrategy, identifierPrefixPropertyName, typeAlias, ...superParameters }) {
+    constructor({ typeAlias, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "public");
-        this.identifierMintingStrategy = identifierMintingStrategy;
-        this.identifierPrefixPropertyName = identifierPrefixPropertyName;
         this.typeAlias = typeAlias;
     }
     get constructorParametersSignature() {
-        if (this.abstract) {
-            const declarationModifiers = this.declarationModifiers.extractNullable();
-            if (declarationModifiers === null || declarationModifiers.abstract) {
-                // If the property is not declared or it's declared abstract, we just pass up parameters to super as-is.
-                return Maybe.empty();
-            }
-        }
-        const hasQuestionToken = this.identifierMintingStrategy.isJust() ||
-            this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-            this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust());
-        const typeNames = [];
+        const hasQuestionToken = this.type.nodeKinds.has("BlankNode");
+        const typeNames = [code `(() => ${this.typeAlias})`];
         for (const conversion of this.type.conversions) {
             if (conversion.sourceTypeof !== "undefined" &&
                 !typeNames.some((typeName) => codeEquals(typeName, conversion.sourceTypeName))) {
@@ -50,10 +37,7 @@ export class IdentifierProperty extends AbstractProperty {
         return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
     }
     get declaration() {
-        return this.declarationModifiers.map(({ abstract, hasQuestionToken, override, readonly, visibility }) => code `${visibility ? `${visibility} ` : ""}${abstract ? "abstract " : ""}${override ? "override " : ""}${readonly ? "readonly " : ""}${this.declarationName}${hasQuestionToken ? "?" : ""}: ${this.typeAlias};`);
-    }
-    get equalsFunction() {
-        return Maybe.of(this.type.equalsFunction);
+        return code `readonly ${this.name}: () => ${this.typeAlias};`;
     }
     get filterProperty() {
         return Maybe.of({
@@ -61,92 +45,16 @@ export class IdentifierProperty extends AbstractProperty {
             type: this.type.filterType,
         });
     }
-    get getAccessorDeclaration() {
-        // If this, an ancestor, or a descendant has an identifier minting strategy then all classes in the hierarchy must
-        // have get accessors.
-        const checkIdentifierTermTypeStatements = (identifierVariable, identifierVariableNodeKinds) => {
-            if (this.type.nodeKinds.size === 2) {
-                return [];
-            }
-            const expectedNodeKind = this.type.kind === "IriType" ? "IRI" : "BlankNode";
-            if (identifierVariableNodeKinds) {
-                if (identifierVariableNodeKinds.size === 1 &&
-                    identifierVariableNodeKinds.has(expectedNodeKind)) {
-                    return [];
-                }
-            }
-            return [
-                code `if (${identifierVariable}.termType !== "${NodeKind.toTermType(expectedNodeKind)}") { throw new Error(\`expected identifier to be ${expectedNodeKind}, not \${${identifierVariable}.termType}\`); }`,
-            ];
-        };
-        if (this.identifierMintingStrategy.isJust()) {
-            // Mint the identifier lazily in the get accessor
-            let memoizeMintedIdentifier;
-            let mintIdentifier;
-            switch (this.identifierMintingStrategy.unsafeCoerce()) {
-                case "blankNode":
-                    memoizeMintedIdentifier = true;
-                    mintIdentifier = code `${imports.dataFactory}.blankNode()`;
-                    break;
-                case "sha256":
-                    // If the object is mutable don't memoize the minted identifier, since the hash will change if the object mutates.
-                    memoizeMintedIdentifier = !this.namedObjectType.mutable;
-                    mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${this.${syntheticNamePrefix}hashShaclProperties(${imports.sha256}.create())}\`)`;
-                    break;
-                case "uuidv4":
-                    memoizeMintedIdentifier = true;
-                    mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${this.${this.identifierPrefixPropertyName}}\${${imports.uuid}.v4()}\`)`;
-                    break;
-            }
-            return Maybe.of(code `\
-      ${this.override ? "override " : ""} get ${this.name}(): ${this.typeAlias} { ${joinCode([
-                code `if (this._${this.name} === undefined) { ${memoizeMintedIdentifier ? code `this._${this.name} = ${mintIdentifier};` : code `return ${mintIdentifier};`} }`,
-                ...checkIdentifierTermTypeStatements(`this._${this.name}`),
-                code `return this._${this.name};`,
-            ])} }`);
-        }
-        // If this object type has an ancestor or a descendant with an identifier minting strategy, declare a get accessor.
-        if (this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-            this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
-            if (this.namedObjectType.parentObjectTypes.length > 0) {
-                // If this object type isn't the root, delegate up.
-                const checkSuperIdentifierTermTypeStatements = checkIdentifierTermTypeStatements("identifier", this.namedObjectType.parentObjectTypes[0].identifierType.nodeKinds);
-                if (checkSuperIdentifierTermTypeStatements.length === 0) {
-                    return Maybe.empty(); // Don't need a get accessor just to return super.identifier.
-                }
-                return Maybe.of(code `override get ${this.name}(): ${this.typeAlias} { ${joinCode([
-                    code `const identifier = super.${this.name};`,
-                    ...checkSuperIdentifierTermTypeStatements,
-                    code `return identifier;`,
-                ])} }`);
-            }
-            // This object type is the root but it has no identifier minting strategy.
-            // Just return the declared property in the get accessor.
-            // Subclasses will override the get accessor.
-            return Maybe.of(code `${this.override ? "override " : ""}get ${this.name}(): ${this.typeAlias} { ${joinCode([
-                code `if (this.${this.declarationName} === undefined) { throw new Error("unable to mint identifier"); }`,
-                code `return this.${this.declarationName};`,
-            ])}`);
-        }
-        // None of the object type hierarchy has an identifier minting strategy, don't need a get accessor
-        return Maybe.empty();
-    }
     get graphqlField() {
         invariant(this.name.startsWith(syntheticNamePrefix));
         return Maybe.of({
             args: Maybe.empty(),
             description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
-            resolve: code `(source) => ${this.typeAlias}.stringify(source.${this.name})`,
+            resolve: code `(source) => ${this.typeAlias}.stringify(${this.accessExpression({ variables: { object: code `source` } })})`,
             type: this.type.graphqlType.name,
         });
     }
-    get jsonSignature() {
-        if (this.type.in_.length > 0) {
-            return Maybe.of(code `readonly "@id": ${this.type.in_.map((iri) => `"${iri.value}"`).join(" | ")}`);
-        }
-        return Maybe.of(code `readonly "@id": string`);
-    }
     get jsonSchema() {
         let schema;
         if (this.type.in_.length > 0 && this.type.kind === "IriType") {
@@ -162,115 +70,46 @@ export class IdentifierProperty extends AbstractProperty {
             schema,
         });
     }
-    // protected override get schemaObject() {
-    //   return {
-    //     ...super.schemaObject,
-    //     identifierMintingStrategy: this.identifierMintingStrategy
-    //       .map((_) => code`${literalOf(_)} as const`)
-    //       .extract(),
-    //   };
-    // }
-    get abstract() {
-        return this.namedObjectType.abstract;
-    }
-    get declarationModifiers() {
-        if (this.namedObjectType.declarationType === "interface") {
-            return Maybe.of({ readonly: true });
-        }
-        if (this.namedObjectType.parentObjectTypes.length > 0) {
-            // An ancestor will declare the identifier property.
-            return Maybe.empty();
-        }
-        if (this.identifierMintingStrategy.isJust() ||
-            this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-            this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())) {
-            return Maybe.of({
-                hasQuestionToken: true,
-                visibility: this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust())
-                    ? "protected"
-                    : "private",
-            });
-        }
-        if (this.abstract) {
-            // Declare the property abstract and public
-            return Maybe.of({
-                abstract: true,
-                override: this.override,
-                readonly: true,
-            });
-        }
-        // Declare the property public
-        return Maybe.of({
-            override: this.override,
-            readonly: true,
-        });
-    }
-    get declarationName() {
-        if (this.namedObjectType.declarationType === "class" &&
-            (this.identifierMintingStrategy.isJust() ||
-                this.namedObjectType.ancestorObjectTypes.some((ancestorObjectType) => ancestorObjectType.identifierProperty.identifierMintingStrategy.isJust()) ||
-                this.namedObjectType.descendantObjectTypes.some((descendantObjectType) => descendantObjectType.identifierProperty.identifierMintingStrategy.isJust()))) {
-            // If this, an ancestor, or a descendant has an identifier minting strategy, declare the identifier property
-            // private or protected and prefix its name with _ in order to avoid a conflict with the get accessor name.
-            return `_${this.name}`;
+    get jsonSignature() {
+        if (this.type.in_.length > 0) {
+            return Maybe.of(code `readonly "@id": ${this.type.in_.map((iri) => `"${iri.value}"`).join(" | ")}`);
         }
-        return this.name;
+        return Maybe.of(code `readonly "@id": string`);
     }
-    get override() {
-        return this.namedObjectType.parentObjectTypes.length > 0;
+    accessExpression({ variables, }) {
+        return code `${variables.object}.${this.name}()`;
     }
     constructorStatements({ variables, }) {
-        const constructorParametersSignature = this.constructorParametersSignature.extractNullable();
-        if (constructorParametersSignature === null) {
-            return [];
-        }
         let lhs;
-        const statements = [];
+        const parameterVariable = code `${this.name}Parameter`;
+        const statements = [
+            // Pull out the parameter so the function can capture it if necessary.
+            code `const ${parameterVariable} = ${variables.parameter};`,
+        ];
         const typeConversions = this.type.conversions;
         switch (this.namedObjectType.declarationType) {
             case "class": {
-                if (this.declaration.isNothing()) {
-                    return [];
-                }
-                lhs = `this.${this.declarationName}`;
+                lhs = `this.${this.name}`;
                 break;
             }
             case "interface":
                 lhs = this.name;
-                statements.push(code `let ${this.name}: ${this.typeAlias};`);
+                statements.push(code `let ${this.name}: () => ${this.typeAlias};`);
                 break;
         }
-        const conversionBranches = [];
+        const conversionBranches = [
+            code `if (typeof ${parameterVariable} === "function") { ${lhs} = ${parameterVariable}; }`,
+        ];
         for (const conversion of typeConversions) {
+            invariant(conversion.sourceTypeof !== "function");
             invariant(conversion.sourceTypeof !== "undefined");
-            conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
+            conversionBranches.push(code `if (${conversion.sourceTypeCheckExpression(parameterVariable)}) { ${lhs} = () => ${conversion.conversionExpression(parameterVariable)}; }`);
+        }
+        if (this.type.nodeKinds.has("BlankNode")) {
+            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${imports.dataFactory}.blankNode(); ${lhs} = () => ${syntheticNamePrefix}eagerIdentifier; }`);
         }
-        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
-            switch (this.namedObjectType.declarationType) {
-                case "class":
-                    // The identifier will be minted lazily in the get accessor
-                    invariant(this.getAccessorDeclaration.isJust());
-                    conversionBranches.push(code `if (${variables.parameter} === undefined) { }`);
-                    break;
-                case "interface": {
-                    let mintIdentifier;
-                    switch (identifierMintingStrategy) {
-                        case "blankNode":
-                            mintIdentifier = code `${imports.dataFactory}.blankNode()`;
-                            break;
-                        case "sha256":
-                            this.logger.warn("minting %s identifiers with %s is unsupported", this.namedObjectType.declarationType, identifierMintingStrategy);
-                            return;
-                        case "uuidv4":
-                            mintIdentifier = code `${imports.dataFactory}.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.namedObjectType.discriminantValue}:"}\${${imports.uuid}.v4()}\`)`;
-                            break;
-                    }
-                    conversionBranches.push(code `if (${variables.parameter} === undefined) { ${lhs} = ${mintIdentifier}; }`);
-                }
-            }
-        });
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-        conversionBranches.push(code `{ ${lhs} = (${variables.parameter}) satisfies never;\n }`);
+        conversionBranches.push(code `{ ${lhs} = (${parameterVariable}) satisfies never;\n }`);
         statements.push(joinCode(conversionBranches, { on: " else " }));
         return statements;
     }
@@ -279,9 +118,6 @@ export class IdentifierProperty extends AbstractProperty {
             code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: variables.jsonObject } })};`,
         ];
     }
-    toStringExpression(parameters) {
-        return Maybe.of(this.type.toStringExpression(parameters));
-    }
     fromRdfResourceValuesExpression({ variables, }) {
         return Maybe.of(code `${this.type.fromRdfResourceValuesExpression({
             variables: {
@@ -310,7 +146,7 @@ export class IdentifierProperty extends AbstractProperty {
                 ignoreRdfType: true, // Unused
                 preferredLanguages: variables.preferredLanguages,
                 propertyPatterns: code `[]`,
-                schema: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.namedObjectType.identifierProperty.name}.type()`,
+                schema: code `${this.namedObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.type()`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,
@@ -337,6 +173,9 @@ export class IdentifierProperty extends AbstractProperty {
     toRdfRdfResourceValuesStatements() {
         return [];
     }
+    toStringExpression(parameters) {
+        return Maybe.of(this.type.toStringExpression(parameters));
+    }
 }
 __decorate([
     Memoize()
@@ -344,25 +183,16 @@ __decorate([
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "declaration", null);
-__decorate([
-    Memoize()
-], IdentifierProperty.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "filterProperty", null);
-__decorate([
-    Memoize()
-], IdentifierProperty.prototype, "getAccessorDeclaration", null);
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "graphqlField", null);
-__decorate([
-    Memoize()
-], IdentifierProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
 ], IdentifierProperty.prototype, "jsonSchema", null);
 __decorate([
     Memoize()
-], IdentifierProperty.prototype, "declarationModifiers", null);
+], IdentifierProperty.prototype, "jsonSignature", null);
 //# sourceMappingURL=IdentifierProperty.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_classDeclaration.js

@@ -48,9 +48,8 @@ ${this.comment
         .map(tsComment)
         .orDefault("")}export ${this.abstract ? "abstract " : ""}class ${def(this.name)}${this.parentObjectTypes.length > 0 ? ` extends ${this.parentObjectTypes[0].name}` : ""} {
 ${joinCode([
-        ...this.properties.flatMap((property) => property.declaration.toList()),
+        ...this.properties.flatMap((property) => property.declaration),
         NamedObjectType_constructorDeclaration.call(this),
-        ...this.properties.flatMap((property) => property.getAccessorDeclaration.toList()),
         ...NamedObjectType_equalsFunctionOrMethodDeclaration.call(this).toList(),
         ...NamedObjectType_hashFunctionOrMethodDeclarations.call(this),
         ...NamedObjectType_toJsonFunctionOrMethodDeclaration.call(this).toList(),

package/dist/generators/ts/_NamedObjectType/NamedObjectType_equalsFunctionOrMethodDeclaration.js

@@ -13,11 +13,11 @@ export function NamedObjectType_equalsFunctionOrMethodDeclaration() {
     let rightVariable;
     switch (this.declarationType) {
         case "class":
-            if (this.ownProperties.length === 0) {
+            if (this.properties.length === 0) {
                 // If there's a parent class and no properties in this class, can skip overriding equals
                 return Maybe.empty();
             }
-            leftVariable = "this";
+            leftVariable = code `this`;
             parameters = code `other: ${this.name}`;
             if (this.parentObjectTypes.length > 0) {
                 chain.push(code `super.${syntheticNamePrefix}equals(other)`);
@@ -26,22 +26,23 @@ export function NamedObjectType_equalsFunctionOrMethodDeclaration() {
             else {
                 preamble = "";
             }
-            rightVariable = "other";
+            rightVariable = code `other`;
             break;
         case "interface":
             // For every parent, find the nearest equals implementation
             for (const parentObjectType of this.parentObjectTypes) {
                 chain.push(code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}equals(left, right)`);
             }
-            leftVariable = "left";
+            leftVariable = code `left`;
             parameters = code `left: ${this.name}, right: ${this.name}`;
             preamble = "export function ";
-            rightVariable = "right";
+            rightVariable = code `right`;
     }
-    for (const property of this.ownProperties) {
-        property.equalsFunction.ifJust((equalsFunction) => {
-            chain.push(code `(${equalsFunction})(${leftVariable}.${property.name}, ${rightVariable}.${property.name}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
-        });
+    for (const property of this.properties) {
+        if (property.kind === "DiscriminantProperty") {
+            continue;
+        }
+        chain.push(code `(${property.type.equalsFunction})(${property.accessExpression({ variables: { object: leftVariable } })}, ${property.accessExpression({ variables: { object: rightVariable } })}).mapLeft(propertyValuesUnequal => ({ left: ${leftVariable}, right: ${rightVariable}, propertyName: "${property.name}", propertyValuesUnequal, type: "property" as const }))`);
     }
     return Maybe.of(code `\
 ${preamble}${syntheticNamePrefix}equals(${parameters}): ${snippets.EqualsResult} {

package/dist/generators/ts/_NamedObjectType/NamedObjectType_filterFunctionDeclaration.js

@@ -5,10 +5,10 @@ export function NamedObjectType_filterFunctionDeclaration() {
     for (const parentObjectType of this.parentObjectTypes) {
         statements.push(code `if (!${parentObjectType.filterFunction}(filter, value)) { return false; }`);
     }
-    if (this.ownProperties.length > 0) {
-        for (const ownProperty of this.ownProperties) {
-            ownProperty.filterProperty.ifJust(({ name }) => {
-                statements.push(code `if (filter.${name} !== undefined && !${ownProperty.type.filterFunction}(filter.${name}, value.${ownProperty.name})) { return false; }`);
+    if (this.properties.length > 0) {
+        for (const property of this.properties) {
+            property.filterProperty.ifJust(({ name }) => {
+                statements.push(code `if (filter.${name} !== undefined && !${property.type.filterFunction}(filter.${name}, ${property.accessExpression({ variables: { object: code `value` } })})) { return false; }`);
             });
         }
     }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlConstructTriplesFunctionDeclaration.js

@@ -31,7 +31,7 @@ if (!parameters?.ignoreRdfType) {
   );
 }`);
     }
-    for (const property of this.ownProperties) {
+    for (const property of this.properties) {
         if (property.recursive) {
             continue;
         }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_focusSparqlWherePatternsFunctionDeclaration.js

@@ -75,7 +75,7 @@ if (!parameters?.ignoreRdfType) {
   );
 }`);
     }
-    for (const property of this.ownProperties) {
+    for (const property of this.properties) {
         if (property.recursive) {
             continue;
         }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromJsonFunctionDeclaration.js

@@ -8,13 +8,9 @@ export function NamedObjectType_fromJsonFunctionDeclaration() {
     if (this.abstract) {
         return Maybe.empty();
     }
-    let returnExpression = code `${syntheticNamePrefix}propertiesFromJson(json)`;
-    if (this.declarationType === "class") {
-        returnExpression = code `new ${this.name}(${returnExpression})`;
-    }
     return Maybe.of(code `\
 export function ${syntheticNamePrefix}fromJson(json: ${this.jsonType().name}): ${this.name} {
-  return ${returnExpression};
+  return ${this.newExpression({ parameters: code `${syntheticNamePrefix}propertiesFromJson(json)` })};
 }`);
 }
 //# sourceMappingURL=NamedObjectType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_fromRdfResourceFunctionDeclaration.js

@@ -9,18 +9,13 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
     if (this.abstract) {
         return Maybe.empty();
     }
-    const statements = [
-        code `let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
-        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
-    ];
-    let propertiesFromRdfExpression = code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages })`;
-    if (this.declarationType === "class") {
-        propertiesFromRdfExpression = code `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
-    }
-    statements.push(code `return ${propertiesFromRdfExpression};`);
     return Maybe.of(code `\
 export const ${syntheticNamePrefix}fromRdfResource: ${snippets.FromRdfResourceFunction}<${this.name}> = (resource, options) => {
-${joinCode(statements)}
+${joinCode([
+        code `let { context, graph, ignoreRdfType = false, objectSet, preferredLanguages } = (options ?? {});`,
+        code `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet(resource.dataset); }`,
+        code `return ${code `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdfResource(resource, { context, graph, ignoreRdfType, objectSet, preferredLanguages }).map(${this.declarationType === "interface" ? code `${syntheticNamePrefix}create` : code `properties => ${this.newExpression({ parameters: code `properties` })}`})`};`,
+    ])}
 };`);
 }
 //# sourceMappingURL=NamedObjectType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_hashFunctionOrMethodDeclarations.js

@@ -6,13 +6,17 @@ export function NamedObjectType_hashFunctionOrMethodDeclarations() {
     if (!this.features.has("hash")) {
         return [];
     }
-    const hashOwnShaclPropertiesStatements = this.ownShaclProperties.flatMap((property) => property.hashStatements({
-        depth: 0,
-        variables: {
-            hasher: hasherVariable,
-            value: code `${this.thisVariable}.${property.name}`,
-        },
-    }));
+    const hashOwnShaclPropertiesStatements = this.properties.flatMap((property) => property.kind === "ShaclProperty"
+        ? property.hashStatements({
+            depth: 0,
+            variables: {
+                hasher: hasherVariable,
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
+        })
+        : []);
     if (this.declarationType === "class" &&
         this.parentObjectTypes.length > 0 &&
         hashOwnShaclPropertiesStatements.length === 0) {
@@ -49,13 +53,13 @@ export function NamedObjectType_hashFunctionOrMethodDeclarations() {
     const parametersCode = joinCode(parameters, { on: "," });
     hashShaclPropertiesStatements.push(...hashOwnShaclPropertiesStatements);
     hashShaclPropertiesStatements.push(code `return ${hasherVariable};`);
-    hashStatements.push(...this.ownProperties
+    hashStatements.push(...this.properties
         .filter((property) => property.kind !== "ShaclProperty")
         .flatMap((property) => property.hashStatements({
         depth: 0,
         variables: {
             hasher: hasherVariable,
-            value: code `${this.thisVariable}.${property.name}`,
+            value: code `${property.accessExpression({ variables: { object: this.thisVariable } })}`,
         },
     })));
     hashStatements.push(code `return ${hasherVariable};`);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_interfaceDeclaration.js

@@ -10,7 +10,7 @@ ${this.comment
             .map((parentObjectType) => parentObjectType.name)
             .join(", ")}`
         : ""} {
-  ${joinCode(this.properties.flatMap((property) => property.declaration.toList()))}
+  ${joinCode(this.properties.map((property) => property.declaration))}
 }`;
 }
 //# sourceMappingURL=NamedObjectType_interfaceDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js

@@ -6,8 +6,8 @@ export function NamedObjectType_jsonTypeAliasDeclaration() {
         return Maybe.empty();
     }
     const members = [];
-    if (this.ownProperties.length > 0) {
-        members.push(code `{ ${joinCode(this.ownProperties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
+    if (this.properties.length > 0) {
+        members.push(code `{ ${joinCode(this.properties.flatMap((property) => property.jsonSignature.toList()), { on: ";" })} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {
         members.push(code `${parentObjectType.jsonType().name}`);

package/dist/generators/ts/_NamedObjectType/NamedObjectType_jsonUiSchemaFunctionDeclaration.js

@@ -8,7 +8,7 @@ export function NamedObjectType_jsonUiSchemaFunctionDeclaration() {
     const variables = { scopePrefix: code `scopePrefix` };
     const elements = this.parentObjectTypes
         .map((parentObjectType) => code `${parentObjectType.staticModuleName}.${syntheticNamePrefix}Json.uiSchema({ scopePrefix })`)
-        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+        .concat(this.properties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
     return Maybe.of(code `\
 export function uiSchema(parameters?: { scopePrefix?: string }): any {
   const scopePrefix = parameters?.scopePrefix ?? "#";

package/dist/generators/ts/_NamedObjectType/NamedObjectType_schemaVariableStatement.js

@@ -4,6 +4,6 @@ export function NamedObjectType_schemaVariableStatement() {
     return code `\
 export const ${syntheticNamePrefix}schema = { properties: { ${joinCode(this.parentObjectTypes
         .map((parentObjectType) => code `...${parentObjectType.staticModuleName}.${syntheticNamePrefix}schema.properties`)
-        .concat(this.ownProperties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
+        .concat(this.properties.map((property) => code `${property.name}: ${property.schema}`)), { on: ", " })} } } as const;`;
 }
 //# sourceMappingURL=NamedObjectType_schemaVariableStatement.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toJsonFunctionOrMethodDeclaration.js

@@ -6,7 +6,7 @@ export function NamedObjectType_toJsonFunctionOrMethodDeclaration() {
         return Maybe.empty();
     }
     if (this.declarationType === "class" &&
-        this.ownProperties.length === 0 &&
+        this.properties.length === 0 &&
         this.parentObjectTypes.length > 0) {
         return Maybe.empty();
     }
@@ -31,10 +31,14 @@ export function NamedObjectType_toJsonFunctionOrMethodDeclaration() {
             preamble = "export function ";
             break;
     }
-    if (this.ownProperties.length > 0) {
-        jsonObjectMembers.push(...this.ownProperties.flatMap((property) => property
+    if (this.properties.length > 0) {
+        jsonObjectMembers.push(...this.properties.flatMap((property) => property
             .toJsonObjectMemberExpression({
-            variables: { value: code `${this.thisVariable}.${property.name}` },
+            variables: {
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
         })
             .toList()));
     }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toRdfResourceFunctionOrMethodDeclaration.js

@@ -37,7 +37,7 @@ export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
         statements.push(code `const ${variables.resource} = ${superToRdfCall};`);
     }
     else {
-        statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${this.identifierProperty.name});`);
+        statements.push(code `const ${variables.resource} = ${variables.resourceSet}.resource(${this.thisVariable}.${syntheticNamePrefix}identifier());`);
     }
     if (this.toRdfTypes.length > 0) {
         statements.push(code `if (!options?.${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${rdfjsTermExpression(rdf.type, { logger: this.logger })}, ${imports.dataFactory}.namedNode("${toRdfType.value}"), options?.${variables.graph});`), { on: " " })} }`);
@@ -48,7 +48,9 @@ export function NamedObjectType_toRdfResourceFunctionOrMethodDeclaration() {
                 graph: code `options?.${variables.graph}`,
                 resource: variables.resource,
                 resourceSet: variables.resourceSet,
-                value: code `${this.thisVariable}.${property.name}`,
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
             },
         }));
     }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_toStringFunctionOrMethodDeclaration.js

@@ -17,13 +17,17 @@ export function NamedObjectType_toStringFunctionOrMethodDeclarations() {
             }
         }
     }
-    for (const ownProperty of this.ownProperties) {
-        ownProperty
+    for (const property of this.properties) {
+        property
             .toStringExpression({
-            variables: { value: code `${this.thisVariable}.${ownProperty.name}` },
+            variables: {
+                value: property.accessExpression({
+                    variables: { object: this.thisVariable },
+                }),
+            },
         })
-            .ifJust((ownPropertyToStringExpression) => {
-            propertiesToStringRecordProperties.push(code `${literalOf(ownProperty.name)}: ${ownPropertyToStringExpression}`);
+            .ifJust((propertyToStringExpression) => {
+            propertiesToStringRecordProperties.push(code `${literalOf(property.name)}: ${propertyToStringExpression}`);
         });
     }
     const propertiesToStringsReturnExpression = code `${snippets.compactRecord}({${joinCode(propertiesToStringRecordProperties, { on: "," })}})`;

package/dist/generators/ts/_NamedObjectType/Property.d.ts

@@ -1,7 +1,6 @@
 import type { Type } from "../Type.js";
 import type { DiscriminantProperty } from "./DiscriminantProperty.js";
-import type { IdentifierPrefixProperty } from "./IdentifierPrefixProperty.js";
 import type { IdentifierProperty } from "./IdentifierProperty.js";
 import type { ShaclProperty } from "./ShaclProperty.js";
-export type Property = IdentifierProperty | IdentifierPrefixProperty | ShaclProperty<Type> | DiscriminantProperty;
+export type Property = IdentifierProperty | ShaclProperty<Type> | DiscriminantProperty;
 //# sourceMappingURL=Property.d.ts.map