@shaclmate/compiler 4.0.6 → 4.0.7

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

@@ -0,0 +1,106 @@
+import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+const variables = {
+    filter: code `parameters.filter`,
+    preferredLanguages: code `parameters.preferredLanguages`,
+    focusIdentifier: code `parameters.focusIdentifier`,
+    variablePrefix: code `parameters.variablePrefix`,
+};
+export function ObjectType_sparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
+    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
+    let patternsVariableDeclarationKeyword = "const";
+    const statements = [];
+    for (const parentObjectType of this.parentObjectTypes) {
+        statements.push(code `\
+patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
+        patternsVariableDeclarationKeyword = "let";
+    }
+    if (this.fromRdfType.isJust()) {
+        const fromRdfTypeVariables = this.fromRdfTypeVariable
+            .toList()
+            .concat(this.descendantFromRdfTypeVariables);
+        statements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
+if (!parameters?.ignoreRdfType) {
+  patterns.push(
+    ${fromRdfTypeVariables.length > 1
+            ? code `\
+    {
+      type: "values" as const,
+      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
+        const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
+        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${imports.NamedNode};
+        return valuePatternRow;
+      }),
+    },
+    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
+            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
+    {
+      triples: [
+        {
+          subject: ${variables.focusIdentifier},
+          predicate: ${rdfjsTermExpression(rdf.type)},
+          object: rdfTypeVariable
+        }
+      ],
+      type: "bgp" as const
+    },
+    {
+      patterns: [
+        {
+          triples: [
+            {
+              subject: rdfTypeVariable,
+              predicate: {
+                items: [${rdfjsTermExpression(rdfs.subClassOf)}],
+                pathType: "+" as const,
+                type: "path" as const
+              },
+              object: ${rdfClassVariable}
+            }
+          ],
+          type: "bgp" as const
+        }
+      ],
+      type: "optional" as const
+    }
+  );
+}`);
+    }
+    for (const property of this.ownProperties) {
+        if (property.recursive) {
+            continue;
+        }
+        property
+            .sparqlWherePatternsExpression({ variables })
+            .ifJust(({ condition, patterns }) => {
+            const concatStatement = code `patterns = patterns.concat(${patterns});`;
+            if (condition) {
+                statements.push(code `if (${condition}) { ${concatStatement} }`);
+            }
+            else {
+                statements.push(concatStatement);
+            }
+            patternsVariableDeclarationKeyword = "let";
+        });
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlWherePatterns(${statements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${statements.length > 0
+        ? joinCode([
+            code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
+            ...statements,
+            code `return patterns;`,
+        ])
+        : "return [];"}
+}`);
+}
+//# sourceMappingURL=ObjectType_sparqlWherePatternsFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromJsonFunctionDeclaration.js

@@ -0,0 +1,19 @@
+import { Maybe } from "purify-ts";
+import { code } from "ts-poet";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_fromJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}<${imports.z}.ZodError, ${this.name}> {
+  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
+        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as ${imports.Either}<${imports.z}.ZodError, ${this.name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_fromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_fromRdfFunctionDeclarations.js

@@ -0,0 +1,20 @@
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_fromRdfFunctionDeclaration() {
+    if (!this.features.has("rdf")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
+  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
+        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_fromRdfFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonZodSchemaFunctionDeclaration.js

@@ -0,0 +1,14 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "ts-poet";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_jsonZodSchemaFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}jsonZodSchema() {
+  return ${imports.z}.discriminatedUnion("${this._discriminantProperty.name}", [${joinCode(this.concreteMemberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type" })), { on: ", " })}]);
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_jsonZodSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js

@@ -0,0 +1,15 @@
+import { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_sparqlConstructTriplesFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
+  return [${joinCode(this.concreteMemberTypes.map((memberType) => code `...${memberType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`), { on: ", " })}];
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_sparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js

@@ -0,0 +1,35 @@
+import { pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { imports } from "../imports.js";
+import { snippets } from "../snippets.js";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectUnionType_sparqlWherePatternsFunctionDeclaration() {
+    if (!this.features.has("sparql")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
+${joinCode([
+        code `let patterns: ${snippets.SparqlPattern}[] = [];`,
+        code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.identifierType.sparqlWherePatternsFunction}({
+      filter: filter?.${syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.identifierType.schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+        code `patterns.push({ patterns: [${joinCode(this.concreteMemberTypes.map((memberType) => code `${{
+            patterns: code `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter: filter?.on?.${memberType.name}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(memberType.name)}\` }).concat()`,
+            type: literalOf("group"),
+        }}`), { on: ", " })}], type: "union" });`,
+        code `return patterns;`,
+    ])}
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_sparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toJsonFunctionDeclaration.js

@@ -0,0 +1,26 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "ts-poet";
+import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+export function ObjectUnionType_toJsonFunctionDeclaration() {
+    if (!this.features.has("json")) {
+        return Maybe.empty();
+    }
+    return Maybe.of(code `\
+export function ${syntheticNamePrefix}toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
+${joinCode(this.concreteMemberTypes
+        .map((memberType) => {
+        let returnExpression;
+        switch (memberType.declarationType) {
+            case "class":
+                returnExpression = code `${this.thisVariable}.${syntheticNamePrefix}toJson()`;
+                break;
+            case "interface":
+                returnExpression = code `${memberType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`;
+                break;
+        }
+        return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
+    })
+        .concat(code `throw new Error("unrecognized type");`))}
+}`);
+}
+//# sourceMappingURL=ObjectUnionType_toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_toRdfFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectUnionType/{ObjectUnionType_rdfFunctionDeclarations.js → ObjectUnionType_toRdfFunctionDeclarations.js}

@@ -1,29 +1,12 @@
+import { Maybe } from "purify-ts";
 import { codeEquals } from "../codeEquals.js";
 import { imports } from "../imports.js";
-import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-function ObjectUnionType_fromRdfFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}fromRdf(resource: ${imports.Resource}, options?: ${snippets.FromRdfOptions}): ${imports.Either}<Error, ${this.name}> {
-  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
-        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...options, ignoreRdfType: false }) as ${imports.Either}<Error, ${this.name}>)`;
-        return expression !== null
-            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
-            : memberTypeExpression;
-    }, null)};
-}`;
-}
-export function rdfFunctionDeclarations() {
+export function ObjectUnionType_toRdfFunctionDeclaration() {
     if (!this.features.has("rdf")) {
-        return [];
+        return Maybe.empty();
     }
-    return [
-        ObjectUnionType_fromRdfFunctionDeclaration.bind(this)(),
-        ObjectUnionType_toRdfFunctionDeclaration.bind(this)(),
-    ];
-}
-function ObjectUnionType_toRdfFunctionDeclaration() {
     const parametersVariable = "_parameters";
     const returnType = () => {
         let returnType;
@@ -39,7 +22,7 @@ function ObjectUnionType_toRdfFunctionDeclaration() {
         // The types agree
         return returnType;
     };
-    return code `\
+    return Maybe.of(code `\
 export function ${syntheticNamePrefix}toRdf(${this.thisVariable}: ${this.name}, ${parametersVariable}?: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>, resourceSet?: ${imports.ResourceSet} }): ${returnType()} {
 ${joinCode(this.concreteMemberTypes
         .map((memberType) => {
@@ -55,6 +38,6 @@ ${joinCode(this.concreteMemberTypes
         return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
     })
         .concat(code `throw new Error("unrecognized type");`))}
-}`;
+}`);
 }
-//# sourceMappingURL=ObjectUnionType_rdfFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectUnionType_toRdfFunctionDeclarations.js.map

package/dist/index.d.ts

@@ -3,6 +3,7 @@ export * from "./Compiler.js";
 export type { Generator } from "./generators/Generator.js";
 export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
 export { TsGenerator } from "./generators/ts/TsGenerator.js";
+export { ZodGenerator } from "./generators/ts/ZodGenerator.js";
 export * from "./input/ShapesGraph.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -2,6 +2,7 @@ export * as ast from "./ast/index.js";
 export * from "./Compiler.js";
 export { AstJsonGenerator } from "./generators/json/AstJsonGenerator.js";
 export { TsGenerator } from "./generators/ts/TsGenerator.js";
+export { ZodGenerator } from "./generators/ts/ZodGenerator.js";
 export * from "./input/ShapesGraph.js";
 export * from "./ShapesGraphToAstTransformer.js";
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.6",
+    "@shaclmate/shacl-ast": "4.0.7",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -80,5 +80,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.6"
+  "version": "4.0.7"
 }

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

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

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

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

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

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

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

@@ -1,140 +0,0 @@
-import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./ObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-export function ObjectType_sparqlFunctionDeclarations() {
-    if (!this.features.has("sparql")) {
-        return [];
-    }
-    const variables = {
-        filter: code `parameters.filter`,
-        preferredLanguages: code `parameters.preferredLanguages`,
-        focusIdentifier: code `parameters.focusIdentifier`,
-        variablePrefix: code `parameters.variablePrefix`,
-    };
-    const rdfClassVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfClass\`)`;
-    const rdfTypeVariable = code `${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}RdfType\`)`;
-    let patternsVariableDeclarationKeyword = "const";
-    let triplesVariableDeclarationKeyword = "const";
-    const sparqlConstructTriplesStatements = [];
-    const sparqlWherePatternsStatements = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        sparqlConstructTriplesStatements.push(code `triples = triples.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, variablePrefix: variables.variablePrefix }}));`);
-        triplesVariableDeclarationKeyword = "let";
-        sparqlWherePatternsStatements.push(code `\
-patterns = patterns.concat(${parentObjectType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns(${{ filter: variables.filter, focusIdentifier: variables.focusIdentifier, ignoreRdfType: true, preferredLanguages: variables.preferredLanguages, variablePrefix: variables.variablePrefix }}));`);
-        patternsVariableDeclarationKeyword = "let";
-    }
-    if (this.fromRdfType.isJust()) {
-        const fromRdfTypeVariables = this.fromRdfTypeVariable
-            .toList()
-            .concat(this.descendantFromRdfTypeVariables);
-        sparqlConstructTriplesStatements.push(code `\
-if (!parameters?.ignoreRdfType) {
-  triples.push(
-    { subject: ${variables.focusIdentifier}, predicate: ${rdfjsTermExpression(rdf.type)}, object: ${rdfTypeVariable} },
-    { subject: ${rdfTypeVariable}, predicate: ${rdfjsTermExpression(rdfs.subClassOf)}, object: ${rdfClassVariable} }
-  );
-}`);
-        sparqlWherePatternsStatements.push(code `const rdfTypeVariable = ${rdfTypeVariable};`, code `\
-if (!parameters?.ignoreRdfType) {
-  patterns.push(
-    ${fromRdfTypeVariables.length > 1
-            ? code `\
-    {
-      type: "values" as const,
-      values: [${joinCode(fromRdfTypeVariables, { on: "," })}].map((identifier) => {
-        const valuePatternRow: ${imports.sparqljs}.ValuePatternRow = {};
-        valuePatternRow[\`?\${${variables.variablePrefix}}FromRdfType\`] = identifier as ${imports.NamedNode};
-        return valuePatternRow;
-      }),
-    },
-    ${snippets.sparqlInstancesOfPattern}({ rdfType: ${imports.dataFactory}.variable!(\`\${${variables.variablePrefix}}FromRdfType\`), subject: ${variables.focusIdentifier} }),`
-            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: ${variables.focusIdentifier} }),`}
-    {
-      triples: [
-        {
-          subject: ${variables.focusIdentifier},
-          predicate: ${rdfjsTermExpression(rdf.type)},
-          object: rdfTypeVariable
-        }
-      ],
-      type: "bgp" as const
-    },
-    {
-      patterns: [
-        {
-          triples: [
-            {
-              subject: rdfTypeVariable,
-              predicate: {
-                items: [${rdfjsTermExpression(rdfs.subClassOf)}],
-                pathType: "+" as const,
-                type: "path" as const
-              },
-              object: ${rdfClassVariable}
-            }
-          ],
-          type: "bgp" as const
-        }
-      ],
-      type: "optional" as const
-    }
-  );
-}`);
-    }
-    for (const property of this.ownProperties) {
-        if (property.recursive) {
-            continue;
-        }
-        property
-            .sparqlConstructTriplesExpression({
-            variables,
-        })
-            .ifJust((propertyTriples) => {
-            sparqlConstructTriplesStatements.push(code `triples = triples.concat(${propertyTriples});`);
-            triplesVariableDeclarationKeyword = "let";
-        });
-        property
-            .sparqlWherePatternsExpression({ variables })
-            .ifJust(({ condition, patterns }) => {
-            const concatStatement = code `patterns = patterns.concat(${patterns});`;
-            if (condition) {
-                sparqlWherePatternsStatements.push(code `if (${condition}) { ${concatStatement} }`);
-            }
-            else {
-                sparqlWherePatternsStatements.push(concatStatement);
-            }
-            patternsVariableDeclarationKeyword = "let";
-        });
-    }
-    return [
-        ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)(),
-        ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
-        code `\
-export function ${syntheticNamePrefix}sparqlConstructTriples(${sparqlConstructTriplesStatements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean;  variablePrefix: string }): readonly ${imports.sparqljs}.Triple[] {
-${sparqlConstructTriplesStatements.length > 0
-            ? joinCode([
-                code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
-                ...sparqlConstructTriplesStatements,
-                code `return triples;`,
-            ])
-            : "return [];"}
-}`,
-        code `\
-export function ${syntheticNamePrefix}sparqlWherePatterns(${sparqlWherePatternsStatements.length === 0 ? "_" : ""}parameters: { filter: ${this.filterType} | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${snippets.SparqlPattern}[] {
-${sparqlWherePatternsStatements.length > 0
-            ? joinCode([
-                code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
-                ...sparqlWherePatternsStatements,
-                code `return patterns;`,
-            ])
-            : "return [];"}
-}`,
-    ];
-}
-//# sourceMappingURL=ObjectType_sparqlFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_jsonFunctionDeclarations.js

@@ -1,50 +0,0 @@
-import { code, joinCode } from "ts-poet";
-import { imports } from "../imports.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-function ObjectUnionType_fromJsonFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}fromJson(json: unknown): ${imports.Either}<${imports.z}.ZodError, ${this.name}> {
-  return ${this.concreteMemberTypes.reduce((expression, memberType) => {
-        const memberTypeExpression = code `(${memberType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as ${imports.Either}<${imports.z}.ZodError, ${this.name}>)`;
-        return expression !== null
-            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
-            : memberTypeExpression;
-    }, null)};
-}`;
-}
-export function jsonFunctionDeclarations() {
-    if (!this.features.has("json")) {
-        return [];
-    }
-    return [
-        ObjectUnionType_fromJsonFunctionDeclaration.bind(this)(),
-        jsonZodSchemaFunctionDeclaration.bind(this)(),
-        toJsonFunctionDeclaration.bind(this)(),
-    ];
-}
-function jsonZodSchemaFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}jsonZodSchema() {
-  return ${imports.z}.discriminatedUnion("${this._discriminantProperty.name}", [${joinCode(this.concreteMemberTypes.map((memberType) => memberType.jsonZodSchema({ context: "type" })), { on: ", " })}]);
-}`;
-}
-function toJsonFunctionDeclaration() {
-    return code `\
-export function ${syntheticNamePrefix}toJson(${this.thisVariable}: ${this.name}): ${this.jsonType().name} {
-${joinCode(this.concreteMemberTypes
-        .map((memberType) => {
-        let returnExpression;
-        switch (memberType.declarationType) {
-            case "class":
-                returnExpression = code `${this.thisVariable}.${syntheticNamePrefix}toJson()`;
-                break;
-            case "interface":
-                returnExpression = code `${memberType.staticModuleName}.${syntheticNamePrefix}toJson(${this.thisVariable})`;
-                break;
-        }
-        return code `if (${memberType.staticModuleName}.is${memberType.name}(${this.thisVariable})) { return ${returnExpression}; }`;
-    })
-        .concat(code `throw new Error("unrecognized type");`))}
-}`;
-}
-//# sourceMappingURL=ObjectUnionType_jsonFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_rdfFunctionDeclarations.d.ts

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

package/dist/generators/ts/_ObjectUnionType/ObjectUnionType_sparqlFunctionDeclarations.d.ts

@@ -1,4 +0,0 @@
-import type { ObjectUnionType } from "../ObjectUnionType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectUnionType_sparqlFunctionDeclarations(this: ObjectUnionType): readonly Code[];
-//# sourceMappingURL=ObjectUnionType_sparqlFunctionDeclarations.d.ts.map