@shaclmate/compiler 4.0.23 → 4.0.25

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

@@ -1,6 +1,5 @@
 import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
-import type { Visibility } from "../../../enums/Visibility.js";
 import type { NamedObjectType } from "../NamedObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
@@ -12,13 +11,9 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      */
     abstract readonly constructorParametersSignature: Maybe<Code>;
     /**
-     * Optional property declaration to include in a class or interface declaration of the object type.
+     * Property declaration to include in a class or interface declaration of the object type.
      */
-    abstract readonly declaration: Maybe<Code>;
-    /**
-     * Function declaration that takes two values of the property and compares them, returning an $EqualsResult.
-     */
-    abstract readonly equalsFunction: Maybe<Code>;
+    abstract readonly declaration: Code;
     /**
      * Optional property in the object type's filter.
      */
@@ -26,10 +21,6 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         readonly name: string;
         readonly type: Code;
     }>;
-    /**
-     * Optional get accessor to include in a class declaration of the object type.
-     */
-    abstract readonly getAccessorDeclaration: Maybe<Code>;
     /**
      * GraphQL.js field definition.
      */
@@ -73,16 +64,11 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      * Property type
   .   */
     readonly type: TypeT;
-    /**
-     * Property visibility: private, protected, public.
-     */
-    readonly visibility: Visibility;
-    constructor({ logger, name, namedObjectType, type, visibility, }: {
+    constructor({ logger, name, namedObjectType, type, }: {
         logger: Logger;
         name: string;
         namedObjectType: NamedObjectType;
         type: TypeT;
-        visibility: Visibility;
     });
     /**
      * TypeScript object describing this type, for runtime use.
@@ -92,6 +78,14 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
         kind: Code;
         type: Code;
     };
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }: {
+        variables: {
+            object: Code;
+        };
+    }): Code;
     /**
      * Statements to assign the parameter of described by constructorParametersSignature to a class or interface member.
      */

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

@@ -19,16 +19,11 @@ export class AbstractProperty {
      * Property type
   .   */
     type;
-    /**
-     * Property visibility: private, protected, public.
-     */
-    visibility;
-    constructor({ logger, name, namedObjectType, type, visibility, }) {
+    constructor({ logger, name, namedObjectType, type, }) {
         this.logger = logger;
         this.name = name;
         this.namedObjectType = namedObjectType;
         this.type = type;
-        this.visibility = visibility;
     }
     /**
      * TypeScript object describing this type, for runtime use.
@@ -44,6 +39,12 @@ export class AbstractProperty {
             type: code `() => (${this.type.schema})`,
         };
     }
+    /**
+     * Expression to access the value of this property on an object instance. May evaluate a thunk.
+     */
+    accessExpression({ variables }) {
+        return code `${variables.object}.${this.name}`;
+    }
 }
 __decorate([
     Memoize()

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

@@ -3,9 +3,7 @@ import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
     readonly constructorParametersSignature: Maybe<Code>;
-    readonly equalsFunction: Maybe<Code>;
     readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
-    readonly getAccessorDeclaration: Maybe<Code>;
     readonly graphqlField: AbstractProperty<DiscriminantProperty.Type>["graphqlField"];
     readonly kind = "DiscriminantProperty";
     readonly mutable = false;
@@ -13,10 +11,9 @@ export declare class DiscriminantProperty extends AbstractProperty<DiscriminantP
     constructor({ type, ...superParameters }: {
         type: DiscriminantProperty.Type;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
-    get declaration(): Maybe<Code>;
+    get declaration(): Code;
     get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
     get jsonSignature(): Maybe<Code>;
-    private get abstract();
     private get initializer();
     private get override();
     constructorStatements(): readonly Code[];

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

@@ -5,38 +5,28 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { imports } from "../imports.js";
 import { removeUndefined } from "../removeUndefined.js";
-import { snippets } from "../snippets.js";
 import { arrayOf, code, literalOf } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export class DiscriminantProperty extends AbstractProperty {
     constructorParametersSignature = Maybe.empty();
-    equalsFunction = Maybe.of(code `${snippets.strictEquals}`);
     filterProperty = Maybe.empty();
-    getAccessorDeclaration = Maybe.empty();
     graphqlField = Maybe.empty();
     kind = "DiscriminantProperty";
     mutable = false;
     recursive = false;
     constructor({ type, ...superParameters }) {
         super({ ...superParameters, type });
-        invariant(this.visibility === "public");
     }
     get declaration() {
-        switch (this.namedObjectType.declarationType) {
-            case "class":
-                return Maybe.of(code `${this.abstract ? "abstract " : ""}${this.override ? "override " : ""}readonly ${this.name}: ${this.type.name}${!this.abstract ? code ` = ${this.initializer};` : ";"}`);
-            case "interface":
-                return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
-            default:
-                this.namedObjectType.declarationType;
-                throw new Error("should never reach this point");
-        }
+        return code `readonly ${this.name}: ${this.type.name};`;
     }
     get jsonSchema() {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of({
             key: this.name,
             schema: this.type.values.length > 1
@@ -45,11 +35,11 @@ export class DiscriminantProperty extends AbstractProperty {
         });
     }
     get jsonSignature() {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of(code `readonly ${this.name}: ${this.type.name}`);
     }
-    get abstract() {
-        return this.namedObjectType.abstract;
-    }
     get initializer() {
         return code `${literalOf(this.namedObjectType.discriminantValue)} as const`;
     }
@@ -57,32 +47,24 @@ export class DiscriminantProperty extends AbstractProperty {
         return this.namedObjectType.parentObjectTypes.length > 0;
     }
     constructorStatements() {
-        switch (this.namedObjectType.declarationType) {
-            case "class":
-                return [];
-            case "interface":
-                if (this.abstract) {
-                    return [];
-                }
-                return [code `const ${this.name} = ${this.initializer};`];
-        }
+        return [code `const ${this.name} = ${this.initializer};`];
     }
     fromJsonStatements() {
-        return !this.abstract &&
-            this.namedObjectType.declarationType === "interface"
-            ? [code `const ${this.name} = ${this.initializer};`]
-            : [];
+        return [code `const ${this.name} = ${this.initializer};`];
     }
     fromRdfResourceValuesExpression() {
-        return !this.abstract &&
-            this.namedObjectType.declarationType === "interface"
-            ? Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`)
-            : Maybe.empty();
+        return Maybe.of(code `${imports.Right}<${literalOf(this.namedObjectType.discriminantValue)}>(${this.initializer})`);
     }
     hashStatements({ variables, }) {
+        if (this.override) {
+            return [];
+        }
         return [code `${variables.hasher}.update(${variables.value});`];
     }
     jsonUiSchemaElement({ variables, }) {
+        if (this.override) {
+            return Maybe.empty();
+        }
         const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
         return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.initializer} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
     }
@@ -93,6 +75,9 @@ export class DiscriminantProperty extends AbstractProperty {
         return Maybe.empty();
     }
     toJsonObjectMemberExpression({ variables, }) {
+        if (this.override) {
+            return Maybe.empty();
+        }
         return Maybe.of(code `${this.name}: ${variables.value}`);
     }
     toRdfRdfResourceValuesStatements() {

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

@@ -1,41 +1,30 @@
 import { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../../enums/IdentifierMintingStrategy.js";
 import type { BlankNodeType } from "../BlankNodeType.js";
 import type { IdentifierType } from "../IdentifierType.js";
 import type { IriType } from "../IriType.js";
 import { type Code } from "../ts-poet-wrapper.js";
 import { AbstractProperty } from "./AbstractProperty.js";
 export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
-    private readonly identifierMintingStrategy;
-    private readonly identifierPrefixPropertyName;
     private readonly typeAlias;
     readonly kind = "IdentifierProperty";
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ identifierMintingStrategy, identifierPrefixPropertyName, typeAlias, ...superParameters }: {
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
-        identifierPrefixPropertyName: string;
+    constructor({ typeAlias, ...superParameters }: {
         type: BlankNodeType | IdentifierType | IriType;
         typeAlias: Code;
     } & ConstructorParameters<typeof AbstractProperty>[0]);
     get constructorParametersSignature(): Maybe<Code>;
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Maybe<Code>;
+    get declaration(): Code;
     get filterProperty(): Maybe<{
         name: string;
         type: Code;
     }>;
-    get getAccessorDeclaration(): Maybe<Code>;
     get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
-    get jsonSignature(): Maybe<Code>;
     get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
-    private get abstract();
-    private get declarationModifiers();
-    private get declarationName();
-    private get override();
+    get jsonSignature(): Maybe<Code>;
+    accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
     constructorStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorStatements"]>[0]): readonly Code[];
     fromJsonStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonStatements"]>[0]): readonly Code[];
-    toStringExpression(parameters: Parameters<AbstractProperty<IdentifierType>["toStringExpression"]>[0]): Maybe<Code>;
     fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesExpression"]>[0]): Maybe<Code>;
     hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
     jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
@@ -46,5 +35,6 @@ export declare class IdentifierProperty extends AbstractProperty<BlankNodeType |
     }>;
     toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
     toRdfRdfResourceValuesStatements(): readonly Code[];
+    toStringExpression(parameters: Parameters<AbstractProperty<IdentifierType>["toStringExpression"]>[0]): Maybe<Code>;
 }
 //# sourceMappingURL=IdentifierProperty.d.ts.map

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

@@ -16,31 +16,17 @@ 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 +36,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 +44,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 +69,36 @@ 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};`,
+            code `let ${this.name}: () => ${this.typeAlias};`,
+        ];
         const typeConversions = this.type.conversions;
-        switch (this.namedObjectType.declarationType) {
-            case "class": {
-                if (this.declaration.isNothing()) {
-                    return [];
-                }
-                lhs = `this.${this.declarationName}`;
-                break;
-            }
-            case "interface":
-                lhs = this.name;
-                statements.push(code `let ${this.name}: ${this.typeAlias};`);
-                break;
-        }
-        const conversionBranches = [];
+        const conversionBranches = [
+            code `if (typeof ${parameterVariable} === "function") { ${this.name} = ${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)}) { ${this.name} = () => ${conversion.conversionExpression(parameterVariable)}; }`);
+        }
+        if (this.type.nodeKinds.has("BlankNode")) {
+            conversionBranches.push(code `if (${parameterVariable} === undefined) { const ${syntheticNamePrefix}eagerIdentifier = ${imports.dataFactory}.blankNode(); ${this.name} = () => ${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 `{ ${this.name} = (${parameterVariable}) satisfies never;\n }`);
         statements.push(joinCode(conversionBranches, { on: " else " }));
         return statements;
     }
@@ -279,9 +107,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 +135,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.name}.${syntheticNamePrefix}schema.properties.${this.name}.type()`,
                 valueVariable: variables.focusIdentifier,
                 variablePrefix: variables.variablePrefix, // Unused
             }})`,
@@ -337,6 +162,9 @@ export class IdentifierProperty extends AbstractProperty {
     toRdfRdfResourceValuesStatements() {
         return [];
     }
+    toStringExpression(parameters) {
+        return Maybe.of(this.type.toStringExpression(parameters));
+    }
 }
 __decorate([
     Memoize()
@@ -344,25 +172,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_createFunctionDeclaration.js

@@ -12,7 +12,7 @@ export function NamedObjectType_createFunctionDeclaration() {
         parametersType.push(code `{ ${joinCode(parametersPropertySignatures)} }`);
     }
     for (const parentObjectType of this.parentObjectTypes) {
-        parametersType.push(code `Parameters<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}create>[0]`);
+        parametersType.push(code `Parameters<typeof ${parentObjectType.name}.${syntheticNamePrefix}create>[0]`);
     }
     if (parametersType.length === 0) {
         parametersType.push(code `object`);
@@ -21,7 +21,7 @@ export function NamedObjectType_createFunctionDeclaration() {
     const omitPropertyNames = [];
     const propertyStatements = [];
     for (const parentObjectType of this.parentObjectTypes) {
-        propertyInitializers.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}create(parameters)`);
+        propertyInitializers.push(`...${parentObjectType.name}.${syntheticNamePrefix}create(parameters)`);
     }
     const parametersHasQuestionToken = this.parentObjectTypes.length === 0 &&
         parametersPropertySignatures.every((propertySignature) => propertySignature.toCodeString([]).indexOf("?:") !== -1);

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

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { NamedObjectType } from "../NamedObjectType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function NamedObjectType_equalsFunctionDeclaration(this: NamedObjectType): Maybe<Code>;
+//# sourceMappingURL=NamedObjectType_equalsFunctionDeclaration.d.ts.map