@shaclmate/compiler 2.0.22 → 2.0.23

package/dist/generators/ts/_ObjectType/graphqlTypeVariableStatement.d.ts

@@ -0,0 +1,5 @@
+import { type VariableStatementStructure } from "ts-morph";
+import { Maybe } from "purify-ts";
+import type { ObjectType } from "../ObjectType.js";
+export declare function graphqlTypeVariableStatement(this: ObjectType): Maybe<VariableStatementStructure>;
+//# sourceMappingURL=graphqlTypeVariableStatement.d.ts.map

package/dist/generators/ts/_ObjectType/graphqlTypeVariableStatement.js

@@ -0,0 +1,37 @@
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { Maybe } from "purify-ts";
+import { objectInitializer } from "../objectInitializer.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function graphqlTypeVariableStatement() {
+    if (!this.features.has("graphql")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    if (this.synthetic) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        declarationKind: VariableDeclarationKind.Const,
+        kind: StructureKind.VariableStatement,
+        declarations: [
+            {
+                name: `${syntheticNamePrefix}GraphQL`,
+                initializer: `new graphql.GraphQLObjectType<${this.name}, { objectSet: ${syntheticNamePrefix}ObjectSet }>(${objectInitializer({
+                    description: this.comment.map(JSON.stringify).extract(),
+                    fields: `() => (${objectInitializer(this.properties.reduce((fields, property) => {
+                        property.graphqlField.ifJust((field) => {
+                            const { name: fieldName, ...fieldProps } = field;
+                            fields[fieldName] = objectInitializer(fieldProps);
+                        });
+                        return fields;
+                    }, {}))})`,
+                    name: `"${this.name}"`,
+                })})`,
+            },
+        ],
+        isExported: true,
+    });
+}
+//# sourceMappingURL=graphqlTypeVariableStatement.js.map

package/dist/generators/ts/_ObjectType/hashFunctionOrMethodDeclarations.js

@@ -1,5 +1,6 @@
 import { Scope, } from "ts-morph";
 import { ObjectType } from "../ObjectType.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 const hasherVariable = "_hasher";
 export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
 export function hashFunctionOrMethodDeclarations() {
@@ -35,13 +36,13 @@ export function hashFunctionOrMethodDeclarations() {
     if (this.parentObjectTypes.length > 0) {
         switch (this.declarationType) {
             case "class": {
-                hashShaclPropertiesStatements.push(`super.hashShaclProperties(${hasherVariable});`);
+                hashShaclPropertiesStatements.push(`super.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`);
                 hasOverrideKeyword = true;
                 break;
             }
             case "interface": {
                 for (const parentObjectType of this.parentObjectTypes) {
-                    hashShaclPropertiesStatements.push(`${parentObjectType.name}.${parentObjectType.hashShaclPropertiesFunctionName}(${this.thisVariable}, ${hasherVariable});`);
+                    hashShaclPropertiesStatements.push(`${parentObjectType.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`);
                 }
                 break;
             }
@@ -58,7 +59,7 @@ export function hashFunctionOrMethodDeclarations() {
     return [
         {
             hasOverrideKeyword,
-            name: this.declarationType === "class" ? "hash" : this.hashFunctionName,
+            name: `${syntheticNamePrefix}hash`,
             parameters,
             returnType,
             statements: [
@@ -72,17 +73,15 @@ export function hashFunctionOrMethodDeclarations() {
                     },
                 })),
                 this.declarationType === "class"
-                    ? `this.hashShaclProperties(${hasherVariable});`
-                    : `${this.name}.${this.hashShaclPropertiesFunctionName}(${this.thisVariable}, ${hasherVariable});`,
+                    ? `this.${syntheticNamePrefix}hashShaclProperties(${hasherVariable});`
+                    : `${this.staticModuleName}.${syntheticNamePrefix}hashShaclProperties(${this.thisVariable}, ${hasherVariable});`,
                 `return ${hasherVariable};`,
             ],
             typeParameters,
         },
         {
             hasOverrideKeyword,
-            name: this.declarationType === "class"
-                ? "hashShaclProperties"
-                : this.hashShaclPropertiesFunctionName,
+            name: `${syntheticNamePrefix}hashShaclProperties`,
             parameters,
             returnType,
             scope: this.declarationType === "class" ? Scope.Protected : undefined,

package/dist/generators/ts/_ObjectType/identifierTypeDeclarations.d.ts

@@ -0,0 +1,7 @@
+import { type VariableStatementStructure } from "ts-morph";
+import { type FunctionDeclarationStructure, type ModuleDeclarationStructure, type TypeAliasDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+type IdentifierTypeDeclarations = readonly (FunctionDeclarationStructure | ModuleDeclarationStructure | TypeAliasDeclarationStructure | VariableStatementStructure)[];
+export declare function identifierTypeDeclarations(this: ObjectType): IdentifierTypeDeclarations;
+export {};
+//# sourceMappingURL=identifierTypeDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/identifierTypeDeclarations.js

@@ -0,0 +1,54 @@
+import { VariableDeclarationKind, } from "ts-morph";
+import { StructureKind, } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function identifierTypeDeclarations() {
+    if (this.extern) {
+        return [];
+    }
+    const ancestorObjectTypeWithSameIdentifierType = this.ancestorObjectTypes.find((ancestorObjectType) => ancestorObjectType.identifierType.name === this.identifierType.name);
+    if (ancestorObjectTypeWithSameIdentifierType) {
+        return reExportAncestorIdentifierTypeDeclarations(ancestorObjectTypeWithSameIdentifierType);
+    }
+    // Bespoke identifier type and associated functions
+    return [
+        {
+            isExported: true,
+            kind: StructureKind.TypeAlias,
+            name: `${syntheticNamePrefix}Identifier`,
+            type: this.identifierType.name,
+        },
+        {
+            isExported: true,
+            kind: StructureKind.Module,
+            name: `${syntheticNamePrefix}Identifier`,
+            statements: [
+                this.identifierType.fromStringFunctionDeclaration,
+                this.identifierType.toStringFunctionDeclaration,
+            ],
+        },
+    ];
+}
+function reExportAncestorIdentifierTypeDeclarations(ancestorObjectType) {
+    // This object type's identifier type has the same identifier type as an ancestor object type,
+    // so just reuse the latter.
+    return [
+        {
+            isExported: true,
+            kind: StructureKind.TypeAlias,
+            name: `${syntheticNamePrefix}Identifier`,
+            type: ancestorObjectType.identifierTypeAlias,
+        },
+        {
+            isExported: true,
+            kind: StructureKind.VariableStatement,
+            declarationKind: VariableDeclarationKind.Const,
+            declarations: [
+                {
+                    initializer: ancestorObjectType.identifierTypeAlias,
+                    name: `${syntheticNamePrefix}Identifier`,
+                },
+            ],
+        },
+    ];
+}
+//# sourceMappingURL=identifierTypeDeclarations.js.map

package/dist/generators/ts/_ObjectType/index.d.ts

@@ -1,20 +1,22 @@
 export * from "./classDeclaration.js";
 export * from "./createFunctionDeclaration.js";
+export * from "./EagerShaclProperty.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromJsonFunctionDeclarations.js";
-export * from "./fromRdfFunctionDeclarations.js";
 export * from "./fromRdfTypeVariableStatement.js";
+export * from "./graphqlTypeVariableStatement.js";
 export * from "./hashFunctionDeclarations.js";
+export * from "./identifierTypeDeclarations.js";
 export * from "./IdentifierPrefixProperty.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
-export * from "./jsonSchemaFunctionDeclaration.js";
-export * from "./jsonUiSchemaFunctionDeclaration.js";
-export * from "./jsonZodSchemaFunctionDeclaration.js";
+export * from "./jsonFunctionDeclarations.js";
+export * from "./jsonTypeAliasDeclaration.js";
+export * from "./LazyShaclProperty.js";
+export * from "./objectSetMethodNames.js";
+export * from "./propertiesVariableStatement.js";
 export * from "./Property.js";
+export * from "./rdfFunctionDeclarations.js";
 export * from "./ShaclProperty.js";
 export * from "./sparqlFunctionDeclarations.js";
-export * from "./toJsonFunctionDeclaration.js";
-export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/generators/ts/_ObjectType/index.js

@@ -1,20 +1,22 @@
 export * from "./classDeclaration.js";
 export * from "./createFunctionDeclaration.js";
+export * from "./EagerShaclProperty.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromJsonFunctionDeclarations.js";
-export * from "./fromRdfFunctionDeclarations.js";
 export * from "./fromRdfTypeVariableStatement.js";
+export * from "./graphqlTypeVariableStatement.js";
 export * from "./hashFunctionDeclarations.js";
+export * from "./identifierTypeDeclarations.js";
 export * from "./IdentifierPrefixProperty.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
-export * from "./jsonSchemaFunctionDeclaration.js";
-export * from "./jsonUiSchemaFunctionDeclaration.js";
-export * from "./jsonZodSchemaFunctionDeclaration.js";
+export * from "./jsonFunctionDeclarations.js";
+export * from "./jsonTypeAliasDeclaration.js";
+export * from "./LazyShaclProperty.js";
+export * from "./objectSetMethodNames.js";
+export * from "./propertiesVariableStatement.js";
 export * from "./Property.js";
+export * from "./rdfFunctionDeclarations.js";
 export * from "./ShaclProperty.js";
 export * from "./sparqlFunctionDeclarations.js";
-export * from "./toJsonFunctionDeclaration.js";
-export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.js.map

package/dist/generators/ts/_ObjectType/interfaceDeclaration.js

@@ -8,7 +8,7 @@ export function interfaceDeclaration() {
     if (this.extern) {
         return Maybe.empty();
     }
-    const properties = this.properties.flatMap((property) => property.interfacePropertySignature.toList());
+    const properties = this.properties.flatMap((property) => property.propertySignature.toList());
     return Maybe.of({
         extends: this.parentObjectTypes.map((parentObjectType) => parentObjectType.name),
         isExported: true,

package/dist/generators/ts/_ObjectType/jsonFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function jsonFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
+//# sourceMappingURL=jsonFunctionDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/jsonFunctionDeclarations.js

@@ -0,0 +1,189 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
+function fromJsonFunctionDeclarations() {
+    const deserializePropertiesReturnType = [];
+    const initializers = [];
+    const propertyReturnTypeSignatures = [];
+    const propertiesFromJsonStatements = [];
+    propertiesFromJsonStatements.push(`const ${syntheticNamePrefix}jsonSafeParseResult = ${syntheticNamePrefix}jsonZodSchema().safeParse(_json);`, `if (!${syntheticNamePrefix}jsonSafeParseResult.success) { return purify.Left(${syntheticNamePrefix}jsonSafeParseResult.error); }`, `const ${variables.jsonObject} = ${syntheticNamePrefix}jsonSafeParseResult.data;`);
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        propertiesFromJsonStatements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject});`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
+        initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
+        deserializePropertiesReturnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson>>`);
+    });
+    for (const property of this.properties) {
+        const propertyFromJsonStatements = property.fromJsonStatements({
+            variables,
+        });
+        if (propertyFromJsonStatements.length > 0) {
+            propertiesFromJsonStatements.push(...propertyFromJsonStatements);
+            initializers.push(property.name);
+            propertyReturnTypeSignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    propertiesFromJsonStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertyReturnTypeSignatures.length > 0) {
+        deserializePropertiesReturnType.splice(0, 0, `{ ${propertyReturnTypeSignatures.join(" ")} }`);
+    }
+    const functionDeclarations = [];
+    functionDeclarations.push({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}propertiesFromJson`,
+        parameters: [
+            {
+                name: "_json",
+                type: "unknown",
+            },
+        ],
+        returnType: `purify.Either<zod.ZodError, ${deserializePropertiesReturnType.join(" & ")}>`,
+        statements: propertiesFromJsonStatements,
+    });
+    let fromJsonStatements;
+    if (this.abstract) {
+        if (this.childObjectTypes.length > 0) {
+            // Similar to an object union type, alt-chain the fromJson of the different concrete subclasses together
+            fromJsonStatements = [
+                `return ${this.childObjectTypes.reduce((expression, childObjectType) => {
+                    const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
+                    return expression.length > 0
+                        ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
+                        : childObjectTypeExpression;
+                }, "")};`,
+            ];
+        }
+        else {
+            fromJsonStatements = [];
+        }
+    }
+    else {
+        let propertiesFromJsonExpression = `${syntheticNamePrefix}propertiesFromJson(json)`;
+        if (this.declarationType === "class") {
+            propertiesFromJsonExpression = `${propertiesFromJsonExpression}.map(properties => new ${this.name}(properties))`;
+        }
+        if (this.childObjectTypes.length > 0) {
+            fromJsonStatements = [
+                `return ${this.childObjectTypes.reduce((expression, childObjectType) => {
+                    const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
+                    return expression.length > 0
+                        ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
+                        : childObjectTypeExpression;
+                }, "")}.altLazy(() => ${propertiesFromJsonExpression});`,
+            ];
+        }
+        else {
+            fromJsonStatements = [`return ${propertiesFromJsonExpression};`];
+        }
+    }
+    if (fromJsonStatements.length > 0) {
+        functionDeclarations.push({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: `${syntheticNamePrefix}fromJson`,
+            parameters: [
+                {
+                    name: "json",
+                    type: "unknown",
+                },
+            ],
+            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
+            statements: fromJsonStatements,
+        });
+    }
+    return functionDeclarations;
+}
+function jsonSchemaFunctionDeclaration() {
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}jsonSchema`,
+        statements: [
+            `return zodToJsonSchema(${syntheticNamePrefix}jsonZodSchema());`,
+        ],
+    };
+}
+function jsonUiSchemaFunctionDeclaration() {
+    const variables = { scopePrefix: "scopePrefix" };
+    const elements = this.parentObjectTypes
+        .map((parentObjectType) => `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
+        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}jsonUiSchema`,
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: "{ scopePrefix?: string }",
+            },
+        ],
+        returnType: "any",
+        statements: [
+            'const scopePrefix = parameters?.scopePrefix ?? "#";',
+            `return { "elements": [ ${elements.join(", ")} ], label: "${this.label.orDefault(this.name)}", type: "Group" }`,
+        ],
+    };
+}
+function jsonZodSchemaFunctionDeclaration() {
+    const variables = { zod: "zod" };
+    const mergeZodObjectSchemas = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        mergeZodObjectSchemas.push(`${parentObjectType.jsonZodSchema({ context: "type", variables })}`);
+    }
+    if (this.properties.length > 0) {
+        mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
+            .flatMap((property) => property.jsonZodSchema({ variables }).toList())
+            .map(({ key, schema }) => `"${key}": ${schema}`)
+            .join(",")} })`);
+    }
+    return {
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}jsonZodSchema`,
+        statements: [
+            `return ${mergeZodObjectSchemas.length > 0
+                ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
+                    if (merged.length === 0) {
+                        return zodObjectSchema;
+                    }
+                    return `${merged}.merge(${zodObjectSchema})`;
+                }, "")
+                : `${variables.zod}.object()`} satisfies zod.ZodType<${syntheticNamePrefix}Json>;`,
+        ],
+    };
+}
+function toJsonFunctionDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    return toJsonFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((toJsonFunctionOrMethodDeclaration) => ({
+        ...toJsonFunctionOrMethodDeclaration,
+        isExported: true,
+        kind: StructureKind.Function,
+        name: `${syntheticNamePrefix}toJson`,
+    }));
+}
+export function jsonFunctionDeclarations() {
+    if (!this.features.has("json")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    return [
+        ...fromJsonFunctionDeclarations.bind(this)(),
+        jsonSchemaFunctionDeclaration.bind(this)(),
+        jsonUiSchemaFunctionDeclaration.bind(this)(),
+        ...toJsonFunctionDeclaration.bind(this)().toList(),
+        jsonZodSchemaFunctionDeclaration.bind(this)(),
+    ];
+}
+const variables = {
+    jsonObject: `${syntheticNamePrefix}jsonObject`,
+};
+//# sourceMappingURL=jsonFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/jsonTypeAliasDeclaration.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type TypeAliasDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function jsonTypeAliasDeclaration(this: ObjectType): Maybe<TypeAliasDeclarationStructure>;
+//# sourceMappingURL=jsonTypeAliasDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/jsonTypeAliasDeclaration.js

@@ -0,0 +1,28 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function jsonTypeAliasDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const members = [];
+    if (this.ownProperties.length > 0) {
+        members.push(`{ ${this.ownProperties
+            .flatMap((property) => property.jsonPropertySignature.toList())
+            .map((propertySignature) => `readonly "${propertySignature.name}"${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
+            .join("; ")} }`);
+    }
+    for (const parentObjectType of this.parentObjectTypes) {
+        members.push(parentObjectType.jsonName.toString());
+    }
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.TypeAlias,
+        name: `${syntheticNamePrefix}Json`,
+        type: members.length > 0 ? members.join(" & ") : "object",
+    });
+}
+//# sourceMappingURL=jsonTypeAliasDeclaration.js.map

package/dist/generators/ts/_ObjectType/objectSetMethodNames.d.ts

@@ -0,0 +1,9 @@
+export declare function objectSetMethodNames(this: {
+    readonly name: string;
+}): {
+    object: string;
+    objectIdentifiers: string;
+    objects: string;
+    objectsCount: string;
+};
+//# sourceMappingURL=objectSetMethodNames.d.ts.map

package/dist/generators/ts/_ObjectType/objectSetMethodNames.js

@@ -0,0 +1,18 @@
+import { camelCase, trainCase } from "change-case";
+import plur from "plur";
+export function objectSetMethodNames() {
+    const prefixSingular = camelCase(this.name);
+    const thisNameParts = trainCase(this.name).split("-");
+    let prefixPlural = camelCase(`${thisNameParts.slice(0, thisNameParts.length - 1).join("")}${plur(thisNameParts[thisNameParts.length - 1])}`);
+    if (prefixPlural === prefixSingular) {
+        // Happens with singular-s nouns like "series"
+        prefixPlural = `${prefixPlural}s`;
+    }
+    return {
+        object: prefixSingular,
+        objectIdentifiers: `${prefixSingular}Identifiers`,
+        objects: prefixPlural,
+        objectsCount: `${prefixPlural}Count`,
+    };
+}
+//# sourceMappingURL=objectSetMethodNames.js.map

package/dist/generators/ts/_ObjectType/propertiesVariableStatement.d.ts

@@ -0,0 +1,5 @@
+import { Maybe } from "purify-ts";
+import { type VariableStatementStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function propertiesVariableStatement(this: ObjectType): Maybe<VariableStatementStructure>;
+//# sourceMappingURL=propertiesVariableStatement.d.ts.map

package/dist/generators/ts/_ObjectType/propertiesVariableStatement.js

@@ -0,0 +1,37 @@
+import { Maybe } from "purify-ts";
+import { StructureKind, VariableDeclarationKind, } from "ts-morph";
+import { objectInitializer } from "../objectInitializer.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { ShaclProperty } from "./ShaclProperty.js";
+export function propertiesVariableStatement() {
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const propertiesObject = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        propertiesObject.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}properties`);
+    }
+    for (const property of this.properties) {
+        if (!(property instanceof ShaclProperty)) {
+            continue;
+        }
+        const propertyObject = {};
+        if (this.features.has("rdf")) {
+            propertyObject["identifier"] = rdfjsTermExpression(property.path);
+        }
+        propertiesObject.push(`${property.name}: ${objectInitializer(propertyObject)}`);
+    }
+    return Maybe.of({
+        declarationKind: VariableDeclarationKind.Const,
+        kind: StructureKind.VariableStatement,
+        declarations: [
+            {
+                name: `${syntheticNamePrefix}properties`,
+                initializer: `{${propertiesObject.join(", ")}}`,
+            },
+        ],
+        isExported: true,
+    });
+}
+//# sourceMappingURL=propertiesVariableStatement.js.map

package/dist/generators/ts/_ObjectType/rdfFunctionDeclarations.d.ts

@@ -0,0 +1,4 @@
+import { type FunctionDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare function rdfFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
+//# sourceMappingURL=rdfFunctionDeclarations.d.ts.map