@shaclmate/compiler 2.0.13 → 2.0.14

package/generators/ts/_ObjectType/fromJsonFunctionDeclarations.js

@@ -0,0 +1,78 @@
+import { StructureKind } from "ts-morph";
+const variables = {
+    jsonObject: "_jsonObject",
+};
+export function fromJsonFunctionDeclarations() {
+    if (!this.features.has("fromJson")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    const initializers = [];
+    const propertyReturnTypeSignatures = [];
+    const propertiesFromJsonFunctionReturnType = [];
+    const propertiesFromJsonFunctionStatements = [];
+    propertiesFromJsonFunctionStatements.push(`const _jsonSafeParseResult = ${this.jsonZodSchemaFunctionName}().safeParse(_json);`, "if (!_jsonSafeParseResult.success) { return purify.Left(_jsonSafeParseResult.error); }", `const ${variables.jsonObject} = _jsonSafeParseResult.data;`);
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
+        initializers.push(`..._super${parentObjectTypeI}`);
+        propertiesFromJsonFunctionReturnType.push(`purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>>`);
+    });
+    for (const property of this.properties) {
+        const propertyFromJsonStatements = property.fromJsonStatements({
+            variables,
+        });
+        if (propertyFromJsonStatements.length > 0) {
+            propertiesFromJsonFunctionStatements.push(...propertyFromJsonStatements);
+            initializers.push(property.name);
+            propertyReturnTypeSignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    propertiesFromJsonFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertyReturnTypeSignatures.length > 0) {
+        propertiesFromJsonFunctionReturnType.splice(0, 0, `{ ${propertyReturnTypeSignatures.join(" ")} }`);
+    }
+    const fromJsonFunctionDeclarations = [];
+    fromJsonFunctionDeclarations.push({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "propertiesFromJson",
+        parameters: [
+            {
+                name: "_json",
+                type: "unknown",
+            },
+        ],
+        returnType: `purify.Either<zod.ZodError, ${propertiesFromJsonFunctionReturnType.join(" & ")}>`,
+        statements: propertiesFromJsonFunctionStatements,
+    });
+    if (!this.abstract) {
+        let fromJsonStatements;
+        switch (this.declarationType) {
+            case "class":
+                fromJsonStatements = [
+                    `return ${this.name}.propertiesFromJson(json).map(properties => new ${this.name}(properties));`,
+                ];
+                break;
+            case "interface":
+                fromJsonStatements = [`return ${this.name}.propertiesFromJson(json);`];
+                break;
+        }
+        fromJsonFunctionDeclarations.push({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromJson",
+            parameters: [
+                {
+                    name: "json",
+                    type: "unknown",
+                },
+            ],
+            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
+            statements: fromJsonStatements,
+        });
+    }
+    return fromJsonFunctionDeclarations;
+}
+//# sourceMappingURL=fromJsonFunctionDeclarations.js.map

package/generators/ts/_ObjectType/fromRdfFunctionDeclarations.d.ts

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

package/generators/ts/_ObjectType/fromRdfFunctionDeclarations.js

@@ -0,0 +1,91 @@
+import { StructureKind } from "ts-morph";
+import { objectInitializer } from "../objectInitializer.js";
+const variables = {
+    context: "_context",
+    ignoreRdfType: "_ignoreRdfType",
+    languageIn: "_languageIn",
+    resource: "_resource",
+};
+export function fromRdfFunctionDeclarations() {
+    if (!this.features.has("fromRdf")) {
+        return [];
+    }
+    if (this.extern) {
+        return [];
+    }
+    const initializers = [];
+    const propertySignatures = [];
+    const propertiesFromRdfFunctionReturnType = [];
+    const propertiesFromRdfFunctionStatements = [];
+    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
+        propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}.propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
+        initializers.push(`..._super${parentObjectTypeI}`);
+        propertiesFromRdfFunctionReturnType.push(`purifyHelpers.Eithers.UnwrapR<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdf>>`);
+    });
+    this.fromRdfType.ifJust((rdfType) => {
+        propertiesFromRdfFunctionStatements.push(`if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${this.rdfjsTermExpression(rdfType)})) { return purify.Left(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\``, predicate: this.rdfjsTermExpression(rdfType) })})); }`);
+    });
+    const propertyFromRdfVariables = {
+        context: variables.context,
+        languageIn: variables.languageIn,
+        resource: variables.resource,
+    };
+    for (const property of this.properties) {
+        const propertyFromRdfStatements = property.fromRdfStatements({
+            variables: propertyFromRdfVariables,
+        });
+        if (propertyFromRdfStatements.length > 0) {
+            propertiesFromRdfFunctionStatements.push(...propertyFromRdfStatements);
+            initializers.push(property.name);
+            propertySignatures.push(`${property.name}: ${property.type.name};`);
+        }
+    }
+    propertiesFromRdfFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
+    if (propertySignatures.length > 0) {
+        propertiesFromRdfFunctionReturnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
+    }
+    const fromRdfFunctionDeclarations = [];
+    fromRdfFunctionDeclarations.push({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "propertiesFromRdf",
+        parameters: [
+            {
+                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
+                type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; resource: ${this.rdfjsResourceType().name}; }`,
+            },
+        ],
+        returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${propertiesFromRdfFunctionReturnType.join(" & ")}>`,
+        statements: propertiesFromRdfFunctionStatements,
+    });
+    if (!this.abstract) {
+        let fromRdfStatements;
+        switch (this.declarationType) {
+            case "class":
+                fromRdfStatements = [
+                    `return ${this.name}.propertiesFromRdf(parameters).map(properties => new ${this.name}(properties));`,
+                ];
+                break;
+            case "interface":
+                fromRdfStatements = [
+                    `return ${this.name}.propertiesFromRdf(parameters);`,
+                ];
+                break;
+        }
+        fromRdfFunctionDeclarations.push({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromRdf",
+            parameters: [
+                {
+                    name: "parameters",
+                    type: `Parameters<typeof ${this.name}.propertiesFromRdf>[0]`,
+                },
+            ],
+            returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
+            statements: fromRdfStatements,
+        });
+    }
+    return fromRdfFunctionDeclarations;
+}
+//# sourceMappingURL=fromRdfFunctionDeclarations.js.map

package/generators/ts/_ObjectType/hashFunctionDeclaration.d.ts

@@ -1,5 +1,5 @@
+import { Maybe } from "purify-ts";
 import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType";
-export declare const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
-export declare function hashFunctionDeclaration(this: ObjectType): FunctionDeclarationStructure;
+import type { ObjectType } from "../ObjectType.js";
+export declare function hashFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
 //# sourceMappingURL=hashFunctionDeclaration.d.ts.map

package/generators/ts/_ObjectType/hashFunctionDeclaration.js

@@ -1,64 +1,20 @@
-import { camelCase } from "change-case";
+import { Maybe } from "purify-ts";
 import { StructureKind } from "ts-morph";
-const hasherVariable = "hasher";
-export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+import { hashFunctionOrMethodDeclaration } from "./hashFunctionOrMethodDeclaration.js";
 export function hashFunctionDeclaration() {
-    const thisVariable = camelCase(this.name);
-    const omitPropertyNamesSet = new Set();
-    omitPropertyNamesSet.add(this.configuration.objectTypeIdentifierPropertyName);
-    omitPropertyNamesSet.add(this.configuration.objectTypeDiscriminatorPropertyName);
-    if (this.configuration.objectTypeDeclarationType === "class") {
-        omitPropertyNamesSet.add("equals");
-        omitPropertyNamesSet.add("hash");
-        omitPropertyNamesSet.add("toRdf");
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
     }
-    const statements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        statements.push(`${parentObjectType.name}.${parentObjectType.hashFunctionName}(${thisVariable}, ${hasherVariable})`);
+    if (this.extern) {
+        return Maybe.empty();
     }
-    for (const property of this.properties) {
-        const propertyValueVariable = `${thisVariable}.${property.name}`;
-        const propertyHashStatements = property.hashStatements({
-            variables: {
-                hasher: hasherVariable,
-                value: propertyValueVariable,
-            },
-        });
-        if (propertyHashStatements.length === 0) {
-            omitPropertyNamesSet.add(property.name);
-            continue;
-        }
-        if (property.name === this.configuration.objectTypeIdentifierPropertyName) {
-            // Don't hash the identifier since we may be using hash to calculate the identifier, leading to infinite recursion
-            continue;
-        }
-        statements.push(...propertyHashStatements);
-    }
-    const omitPropertyNames = [...omitPropertyNamesSet];
-    omitPropertyNames.sort();
-    statements.push(`return ${hasherVariable};`);
-    return {
+    return hashFunctionOrMethodDeclaration
+        .bind(this)()
+        .map((hashFunctionOrMethodDeclaration) => ({
+        ...hashFunctionOrMethodDeclaration,
         isExported: true,
         kind: StructureKind.Function,
         name: this.hashFunctionName,
-        parameters: [
-            {
-                name: thisVariable,
-                type: `Omit<${this.name}, ${omitPropertyNames.map((propertyName) => `"${propertyName}"`).join(" | ")}>`,
-            },
-            {
-                name: hasherVariable,
-                type: "HasherT",
-            },
-        ],
-        returnType: "HasherT",
-        statements,
-        typeParameters: [
-            {
-                name: "HasherT",
-                constraint: hasherTypeConstraint,
-            },
-        ],
-    };
+    }));
 }
 //# sourceMappingURL=hashFunctionDeclaration.js.map

package/generators/ts/_ObjectType/hashFunctionOrMethodDeclaration.d.ts

@@ -0,0 +1,11 @@
+import { Maybe } from "purify-ts";
+import type { OptionalKind, ParameterDeclarationStructure, TypeParameterDeclarationStructure } from "ts-morph";
+import type { ObjectType } from "../ObjectType.js";
+export declare const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export declare function hashFunctionOrMethodDeclaration(this: ObjectType): Maybe<{
+    parameters: OptionalKind<ParameterDeclarationStructure>[];
+    returnType: string;
+    statements: string[];
+    typeParameters: OptionalKind<TypeParameterDeclarationStructure>[];
+}>;
+//# sourceMappingURL=hashFunctionOrMethodDeclaration.d.ts.map

package/generators/ts/_ObjectType/hashFunctionOrMethodDeclaration.js

@@ -0,0 +1,64 @@
+import { Maybe } from "purify-ts";
+const hasherVariable = "_hasher";
+export const hasherTypeConstraint = "{ update: (message: string | number[] | ArrayBuffer | Uint8Array) => void; }";
+export function hashFunctionOrMethodDeclaration() {
+    if (!this.features.has("hash")) {
+        return Maybe.empty();
+    }
+    const propertyHashStatements = this.properties.flatMap((property) => property.hashStatements({
+        depth: 0,
+        variables: {
+            hasher: hasherVariable,
+            value: `${this.thisVariable}.${property.name}`,
+        },
+    }));
+    if (this.declarationType === "class" &&
+        this.parentObjectTypes.length > 0 &&
+        propertyHashStatements.length === 0) {
+        // If there's a parent class and no hash statements in this class, can skip overriding hash
+        return Maybe.empty();
+    }
+    const parameters = [];
+    if (this.declarationType === "interface") {
+        parameters.push({
+            name: this.thisVariable,
+            type: this.name,
+        });
+    }
+    parameters.push({
+        name: hasherVariable,
+        type: "HasherT",
+    });
+    const statements = [];
+    let hasOverrideKeyword = false;
+    if (this.parentObjectTypes.length > 0) {
+        switch (this.declarationType) {
+            case "class": {
+                statements.push(`super.hash(${hasherVariable});`);
+                hasOverrideKeyword = true;
+                break;
+            }
+            case "interface": {
+                for (const parentObjectType of this.parentObjectTypes) {
+                    statements.push(`${parentObjectType.name}.${parentObjectType.hashFunctionName}(${this.thisVariable}, ${hasherVariable});`);
+                }
+                break;
+            }
+        }
+    }
+    statements.push(...propertyHashStatements);
+    statements.push(`return ${hasherVariable};`);
+    return Maybe.of({
+        hasOverrideKeyword,
+        parameters,
+        returnType: "HasherT",
+        statements,
+        typeParameters: [
+            {
+                name: "HasherT",
+                constraint: hasherTypeConstraint,
+            },
+        ],
+    });
+}
+//# sourceMappingURL=hashFunctionOrMethodDeclaration.js.map

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

@@ -1,12 +1,18 @@
 export * from "./classDeclaration.js";
+export * from "./createFunctionDeclaration.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromRdfFunctionDeclaration.js";
+export * from "./fromJsonFunctionDeclarations.js";
+export * from "./fromRdfFunctionDeclarations.js";
 export * from "./hashFunctionDeclaration.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
+export * from "./jsonSchemaFunctionDeclaration.js";
+export * from "./jsonUiSchemaFunctionDeclaration.js";
+export * from "./jsonZodSchemaFunctionDeclaration.js";
 export * from "./Property.js";
 export * from "./ShaclProperty.js";
-export * from "./sparqlGraphPatternsClassDeclaration.js";
+export * from "./sparqlFunctionDeclarations.js";
+export * from "./toJsonFunctionDeclaration.js";
 export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.d.ts.map

package/generators/ts/_ObjectType/index.js

@@ -1,12 +1,18 @@
 export * from "./classDeclaration.js";
+export * from "./createFunctionDeclaration.js";
 export * from "./equalsFunctionDeclaration.js";
-export * from "./fromRdfFunctionDeclaration.js";
+export * from "./fromJsonFunctionDeclarations.js";
+export * from "./fromRdfFunctionDeclarations.js";
 export * from "./hashFunctionDeclaration.js";
 export * from "./IdentifierProperty.js";
 export * from "./interfaceDeclaration.js";
+export * from "./jsonSchemaFunctionDeclaration.js";
+export * from "./jsonUiSchemaFunctionDeclaration.js";
+export * from "./jsonZodSchemaFunctionDeclaration.js";
 export * from "./Property.js";
 export * from "./ShaclProperty.js";
-export * from "./sparqlGraphPatternsClassDeclaration.js";
+export * from "./sparqlFunctionDeclarations.js";
+export * from "./toJsonFunctionDeclaration.js";
 export * from "./toRdfFunctionDeclaration.js";
 export * from "./TypeDiscriminatorProperty.js";
 //# sourceMappingURL=index.js.map

package/generators/ts/_ObjectType/interfaceDeclaration.d.ts

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

package/generators/ts/_ObjectType/interfaceDeclaration.js

@@ -1,12 +1,21 @@
+import { Maybe } from "purify-ts";
 import { StructureKind, } from "ts-morph";
+import { tsComment } from "../tsComment.js";
 export function interfaceDeclaration() {
+    if (this.declarationType !== "interface") {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
     const properties = this.properties.map((property) => property.interfacePropertySignature);
-    return {
+    return Maybe.of({
         extends: this.parentObjectTypes.map((parentObjectType) => parentObjectType.name),
         isExported: true,
         kind: StructureKind.Interface,
+        leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
         name: this.name,
         properties,
-    };
+    });
 }
 //# sourceMappingURL=interfaceDeclaration.js.map

package/generators/ts/_ObjectType/jsonSchemaFunctionDeclaration.d.ts

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

package/generators/ts/_ObjectType/jsonSchemaFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+export function jsonSchemaFunctionDeclaration() {
+    if (!this.features.has("jsonSchema")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: "jsonSchema",
+        statements: [
+            `return zodToJsonSchema(${this.jsonZodSchemaFunctionName}());`,
+        ],
+    });
+}
+//# sourceMappingURL=jsonSchemaFunctionDeclaration.js.map

package/generators/ts/_ObjectType/jsonUiSchemaFunctionDeclaration.d.ts

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

package/generators/ts/_ObjectType/jsonUiSchemaFunctionDeclaration.js

@@ -0,0 +1,31 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+export function jsonUiSchemaFunctionDeclaration() {
+    if (!this.features.has("jsonUiSchema")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const variables = { scopePrefix: "scopePrefix" };
+    const elements = this.parentObjectTypes
+        .map((parentObjectType) => `${parentObjectType.name}.${parentObjectType.jsonUiSchemaFunctionName}({ scopePrefix })`)
+        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: this.jsonUiSchemaFunctionName,
+        parameters: [
+            {
+                hasQuestionToken: true,
+                name: "parameters",
+                type: "{ scopePrefix?: string }",
+            },
+        ],
+        statements: [
+            'const scopePrefix = parameters?.scopePrefix ?? "#";',
+            `return { "elements": [ ${elements.join(", ")} ], label: "${this.label.orDefault(this.name)}", type: "Group" }`,
+        ],
+    });
+}
+//# sourceMappingURL=jsonUiSchemaFunctionDeclaration.js.map

package/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.d.ts

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

package/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.js

@@ -0,0 +1,37 @@
+import { Maybe } from "purify-ts";
+import { StructureKind } from "ts-morph";
+export function jsonZodSchemaFunctionDeclaration() {
+    if (!this.features.has("fromJson") && !this.features.has("jsonSchema")) {
+        return Maybe.empty();
+    }
+    if (this.extern) {
+        return Maybe.empty();
+    }
+    const variables = { zod: "zod" };
+    const mergeZodObjectSchemas = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        mergeZodObjectSchemas.push(`${parentObjectType.jsonZodSchema({ variables })}`);
+    }
+    if (this.properties.length > 0) {
+        mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
+            .map((property) => property.jsonZodSchema({ variables }))
+            .map(({ key, schema }) => `"${key}": ${schema}`)
+            .join(",")} })`);
+    }
+    return Maybe.of({
+        isExported: true,
+        kind: StructureKind.Function,
+        name: this.jsonZodSchemaFunctionName,
+        statements: [
+            `return ${mergeZodObjectSchemas.length > 0
+                ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
+                    if (merged.length === 0) {
+                        return zodObjectSchema;
+                    }
+                    return `${merged}.merge(${zodObjectSchema})`;
+                }, "")
+                : `${variables.zod}.object()`};`,
+        ],
+    });
+}
+//# sourceMappingURL=jsonZodSchemaFunctionDeclaration.js.map

package/generators/ts/_ObjectType/rdfjsTermExpression.d.ts

@@ -0,0 +1,6 @@
+import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
+export declare function rdfjsTermExpression({ dataFactoryVariable, rdfjsTerm, }: {
+    dataFactoryVariable: string;
+    rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">;
+}): string;
+//# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/generators/ts/{rdfjsTermExpression.js → _ObjectType/rdfjsTermExpression.js}

@@ -1,5 +1,5 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
-export function rdfjsTermExpression(rdfjsTerm, { dataFactoryVariable }) {
+export function rdfjsTermExpression({ dataFactoryVariable, rdfjsTerm, }) {
     switch (rdfjsTerm.termType) {
         case "BlankNode":
             return `${dataFactoryVariable}.blankNode("${rdfjsTerm.value}")`;
@@ -10,6 +10,8 @@ export function rdfjsTermExpression(rdfjsTerm, { dataFactoryVariable }) {
             return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", ${dataFactoryVariable}.namedNode("${rdfjsTerm.datatype.value}"))`;
         case "NamedNode":
             return `${dataFactoryVariable}.namedNode("${rdfjsTerm.value}")`;
+        case "Variable":
+            return `${dataFactoryVariable}.variable!("${rdfjsTerm.value}")`;
     }
 }
 //# sourceMappingURL=rdfjsTermExpression.js.map

package/generators/ts/_ObjectType/sparqlFunctionDeclarations.d.ts

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