@shaclmate/compiler 4.0.5 → 4.0.7

package/dist/generators/ts/_snippets/snippets_listSparqlWherePatterns.js

@@ -36,6 +36,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
         },
         ...itemSparqlWherePatternsFunction({
           filter: parameters.filter,
+          ignoreRdfType: parameters.ignoreRdfType,
           preferredLanguages: parameters.preferredLanguages,
           propertyPatterns: [],
           schema: parameters.schema.item(),
@@ -91,6 +92,7 @@ function ${syntheticNamePrefix}listSparqlWherePatterns<ItemFilterT, ItemSchemaT>
         },
         ...itemSparqlWherePatternsFunction({
           filter: parameters.filter,
+          ignoreRdfType: parameters.ignoreRdfType,
           preferredLanguages: parameters.preferredLanguages,
           propertyPatterns: [],
           schema: parameters.schema.item(),

package/dist/generators/ts/_snippets/snippets_maybeSparqlConstructTriples.js

@@ -5,6 +5,6 @@ import { snippets_MaybeSchema } from "./snippets_MaybeSchema.js";
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_maybeSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}maybeSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}maybeSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_MaybeFilter}<ItemFilterT>, ${snippets_MaybeSchema}<ItemSchemaT>> {  
-  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ filter: filter ?? undefined, schema: schema.item(), ...otherParameters });
+  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, filter: filter ?? undefined, schema: schema.item() });
 }`);
 //# sourceMappingURL=snippets_maybeSparqlConstructTriples.js.map

package/dist/generators/ts/_snippets/snippets_maybeSparqlWherePatterns.js

@@ -9,18 +9,18 @@ function ${syntheticNamePrefix}maybeSparqlWherePatterns<ItemFilterT, ItemSchemaT
   return ({ filter, schema, ...otherParameters }) => {
     if (filter === undefined) {
       // Treat the item's patterns as optional
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() }));
       return [{ patterns: itemSparqlWherePatterns.concat(), type: "optional" }, ...liftSparqlPatterns];
     }
       
     if (filter === null) {
       // Use FILTER NOT EXISTS around the item's patterns
-      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ schema: schema.item(), ...otherParameters }));
+      const [itemSparqlWherePatterns, liftSparqlPatterns] = ${snippets_liftSparqlPatterns}(itemSparqlWherePatternsFunction({ ...otherParameters, filter: undefined, schema: schema.item() }));
       return [{ expression: { args: itemSparqlWherePatterns.concat(), operator: "notexists", type: "operation" }, lift: true, type: "filter" }, ...liftSparqlPatterns]
     }
 
     // Treat the item as required.
-    return itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters });
+    return itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() });
   }
 }`);
 //# sourceMappingURL=snippets_maybeSparqlWherePatterns.js.map

package/dist/generators/ts/_snippets/snippets_numericSparqlWherePatterns.js

@@ -66,6 +66,6 @@ function ${syntheticNamePrefix}numericSparqlWherePatterns<T extends bigint | num
     }
   }
 
-  return ${snippets_termSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+  return ${snippets_termSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
 }`);
 //# sourceMappingURL=snippets_numericSparqlWherePatterns.js.map

package/dist/generators/ts/_snippets/snippets_setSparqlConstructTriples.js

@@ -5,6 +5,6 @@ import { snippets_CollectionSchema } from "./snippets_CollectionSchema.js";
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_setSparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}setSparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}setSparqlConstructTriples<ItemFilterT, ItemSchemaT>(itemSparqlConstructTriplesFunction: ${snippets_SparqlConstructTriplesFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlConstructTriplesFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
-  return ({ filter, schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ filter: filter ?? undefined, schema: schema.item(), ...otherParameters });
+  return ({ schema, ...otherParameters }) => itemSparqlConstructTriplesFunction({ ...otherParameters, schema: schema.item() });
 }`);
 //# sourceMappingURL=snippets_setSparqlConstructTriples.js.map

package/dist/generators/ts/_snippets/snippets_setSparqlWherePatterns.js

@@ -7,7 +7,7 @@ import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatt
 export const snippets_setSparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}setSparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}setSparqlWherePatterns<ItemFilterT, ItemSchemaT>(itemSparqlWherePatternsFunction: ${snippets_SparqlWherePatternsFunction}<ItemFilterT, ItemSchemaT>): ${snippets_SparqlWherePatternsFunction}<${snippets_CollectionFilter}<ItemFilterT>, ${snippets_CollectionSchema}<ItemSchemaT>> {
   return ({ filter, schema, ...otherParameters }) => {
-    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ filter, schema: schema.item(), ...otherParameters });
+    const itemSparqlWherePatterns = itemSparqlWherePatternsFunction({ ...otherParameters, filter, schema: schema.item() });
 
     const minCount = filter?.${syntheticNamePrefix}minCount ?? schema.minCount ?? 0;
     if (minCount > 0) {

package/dist/generators/ts/_snippets/snippets_shaclPropertySparqlConstructTriples.js

@@ -5,9 +5,9 @@ import { snippets_ShaclPropertySchema } from "./snippets_ShaclPropertySchema.js"
 import { snippets_SparqlConstructTriplesFunction } from "./snippets_SparqlConstructTriplesFunction.js";
 export const snippets_shaclPropertySparqlConstructTriples = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlConstructTriples`, code `\
 function ${syntheticNamePrefix}shaclPropertySparqlConstructTriples<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, propertyName, propertySchema, typeSparqlConstructTriples, variablePrefix }: {
-  filter?: FilterT;
+  filter: FilterT | undefined;
   focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
-  ignoreRdfType?: boolean;
+  ignoreRdfType: boolean;
   propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
   typeSparqlConstructTriples: ${snippets_SparqlConstructTriplesFunction}<FilterT, TypeSchemaT>;

package/dist/generators/ts/_snippets/snippets_shaclPropertySparqlWherePatterns.js

@@ -7,10 +7,10 @@ import { snippets_SparqlWherePatternsFunction } from "./snippets_SparqlWherePatt
 import { snippets_sparqlPropertyPath } from "./snippets_sparqlPropertyPath.js";
 export const snippets_shaclPropertySparqlWherePatterns = conditionalOutput(`${syntheticNamePrefix}shaclPropertySparqlWherePatterns`, code `\
 function ${syntheticNamePrefix}shaclPropertySparqlWherePatterns<FilterT, TypeSchemaT>({ filter, focusIdentifier, ignoreRdfType, preferredLanguages, propertyName, propertySchema, typeSparqlWherePatterns, variablePrefix }: {
-  filter?: FilterT;
+  filter: FilterT | undefined;
   focusIdentifier: ${imports.NamedNode} | ${imports.Variable},
-  ignoreRdfType?: boolean;
-  preferredLanguages?: readonly string[];
+  ignoreRdfType: boolean;
+  preferredLanguages: readonly string[] | undefined;
   propertySchema: ${snippets_ShaclPropertySchema}<TypeSchemaT>;
   propertyName: string;
   typeSparqlWherePatterns: ${snippets_SparqlWherePatternsFunction}<FilterT, TypeSchemaT>;

package/dist/generators/ts/_snippets/snippets_stringSparqlWherePatterns.js

@@ -42,6 +42,6 @@ const ${syntheticNamePrefix}stringSparqlWherePatterns: ${snippets_SparqlWherePat
       }
     }
 
-    return ${snippets_literalSchemaSparqlPatterns}({ filterPatterns, valueVariable, ...otherParameters });
+    return ${snippets_literalSchemaSparqlPatterns}({ ...otherParameters, filterPatterns, valueVariable });
   }`);
 //# sourceMappingURL=snippets_stringSparqlWherePatterns.js.map

package/dist/generators/ts/objectSetInterfaceDeclaration.js

@@ -18,6 +18,7 @@ export namespace ${syntheticNamePrefix}ObjectSet {
     readonly identifiers?: readonly ObjectIdentifierT[];
     readonly limit?: number;
     readonly offset?: number;
+    readonly preferredLanguages?: readonly string[];
   }
 }`;
 }

package/dist/generators/ts/objectSetMethodSignatures.js

@@ -9,7 +9,7 @@ export function objectSetMethodSignatures(parameters) {
     return {
         object: {
             name: methodNames.object,
-            parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}`,
+            parameters: code `${parameterNamePrefix}identifier: ${objectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
             returnType: code `Promise<${imports.Either}<Error, ${objectType.name}>>`,
         },
         objectCount: {

package/dist/generators/ts/rdfjsDatasetObjectSetClassDeclaration.js

@@ -1,3 +1,4 @@
+import { snippets_FromRdfOptions } from "./_snippets/snippets_FromRdfOptions.js";
 import { imports } from "./imports.js";
 import { objectSetMethodSignatures } from "./objectSetMethodSignatures.js";
 import { snippets } from "./snippets.js";
@@ -8,7 +9,7 @@ export function rdfjsDatasetObjectSetClassDeclaration({ objectTypes, objectUnion
     const objectTypeType = code `\
 {
   ${syntheticNamePrefix}filter: (filter: ObjectFilterT, value: ObjectT) => boolean;
-  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet }) => ${imports.Either}<Error, ObjectT>;
+  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options?: ${snippets_FromRdfOptions}) => ${imports.Either}<Error, ObjectT>;
   ${syntheticNamePrefix}fromRdfTypes: readonly ${imports.NamedNode}[]
 }`;
     const parameters = {
@@ -52,12 +53,12 @@ export class ${syntheticNamePrefix}RdfjsDatasetObjectSet implements ${syntheticN
                 // object
                 code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
-  return this.${methodSignatures.object.name}Sync(identifier);
+  return this.${methodSignatures.object.name}Sync(identifier, options);
 }`,
                 // objectSync
                 code `\
 ${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${imports.Either}<Error, ${objectType.name}> {
-  return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier] }).map(objects => objects[0]);
+  return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
                 // objectCount
                 code `\
@@ -125,6 +126,8 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
+  const fromRdfOptions: ${snippets_FromRdfOptions} = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+
   let resources: { object?: ObjectT, resource: ${imports.Resource} }[];
   const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
   let sortResources: boolean;
@@ -166,7 +169,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
       identifierSet.add(quad.subject);
       const resource = resourceSet.resource(quad.subject);
       // Eagerly eliminate the majority of resources that won't match the object type
-      objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this }).ifRight(object => {
+      objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions).ifRight(object => {
         resources.push({ object, resource });
       });
     }
@@ -181,7 +184,7 @@ protected ${syntheticNamePrefix}objectsSync<${typeParameters.ObjectT}, ${typePar
   const objects: ObjectT[] = [];
   for (let { object, resource } of resources) {
     if (!object) {
-      const objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+      const objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
       if (objectEither.isLeft()) {
         return objectEither;
       }
@@ -215,6 +218,8 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
   let offset = query?.offset ?? 0;
   if (offset < 0) { offset = 0; }
 
+  const fromRdfOptions: ${snippets_FromRdfOptions} = { graph, objectSet: this, preferredLanguages: query?.preferredLanguages };
+
   let resources: { object?: ObjectT, objectType?: ${objectTypeType}, resource: ${imports.Resource} }[];
   const resourceSet = this.${syntheticNamePrefix}resourceSet(); // Access once, in case it's instantiated lazily
   let sortResources: boolean;
@@ -259,7 +264,7 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
       // Eagerly eliminate the majority of resources that won't match the object types
       const resource = resourceSet.resource(quad.subject);
       for (const objectType of objectTypes) {
-        if (objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this }).ifRight(object => {
+        if (objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions).ifRight(object => {
           resources.push({ object, objectType, resource });
         }).isRight()) {
           break;
@@ -279,11 +284,11 @@ protected ${syntheticNamePrefix}objectUnionsSync<${typeParameters.ObjectT}, ${ty
     if (!object) {
       let objectEither: ${imports.Either}<Error, ObjectT>;
       if (objectType) {
-        objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+        objectEither = objectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
       } else {
         objectEither = ${imports.Left}(new Error("no object types"));
         for (const tryObjectType of objectTypes) {
-          objectEither = tryObjectType.${syntheticNamePrefix}fromRdf(resource, { graph, objectSet: this });
+          objectEither = tryObjectType.${syntheticNamePrefix}fromRdf(resource, fromRdfOptions);
           if (objectEither.isRight()) {
             objectType = tryObjectType;
             break;

package/dist/generators/ts/sparqlObjectSetClassDeclaration.js

@@ -5,11 +5,11 @@ import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 import { unsupportedObjectSetMethodDeclarations } from "./unsupportedObjectSetMethodDeclarations.js";
 export function sparqlObjectSetClassDeclaration({ objectTypes, objectUnionTypes, }) {
-    const sparqlWherePatternsFunctionType = code `(parameters?: { filter?: ObjectFilterT; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; }) => readonly ${imports.sparqljs}.Pattern[]`;
+    const sparqlWherePatternsFunctionType = code `(parameters: { filter: ObjectFilterT | undefined; focusIdentifier: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string; }) => readonly ${imports.sparqljs}.Pattern[]`;
     const parameters = {
         constructObjectType: code `objectType: {\
-  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet }) => ${imports.Either}<Error, ObjectT>;
-  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters?: { filter?: ObjectFilterT; subject?: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
+  ${syntheticNamePrefix}fromRdf: (resource: ${imports.Resource}, options: { graph?: Exclude<${imports.Quad_Graph}, ${imports.Variable}>; objectSet: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; }) => ${imports.Either}<Error, ObjectT>;
+  ${syntheticNamePrefix}sparqlConstructQueryString: (parameters: { filter?: ObjectFilterT; subject: ${imports.NamedNode} | ${imports.Variable}; } & Omit<${imports.sparqljs}.ConstructQuery, "prefixes" | "queryType" | "type"> & ${imports.sparqljs}.GeneratorOptions) => string;
   ${syntheticNamePrefix}sparqlWherePatterns: ${sparqlWherePatternsFunctionType};
 }`,
         query: code `query?: ${syntheticNamePrefix}SparqlObjectSet.Query<ObjectFilterT, ObjectIdentifierT>`,
@@ -45,7 +45,7 @@ ${joinCode([...objectTypes, ...objectUnionTypes].flatMap((objectType) => {
         return [
             code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
-  return (await this.${methodSignatures.objects.name}({ identifiers: [identifier] })).map(objects => objects[0]);
+  return (await this.${methodSignatures.objects.name}({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages })).map(objects => objects[0]);
 }`,
             code `\
 async ${methodSignatures.objectCount.name}(${methodSignatures.objectCount.parameters}): ${methodSignatures.objectCount.returnType} {
@@ -162,7 +162,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       const dataset = ${imports.datasetFactory}.dataset(quads.concat());
       const objects: ObjectT[] = [];
       for (const identifier of identifiers) {
-        objects.push(await liftEither(objectType.${syntheticNamePrefix}fromRdf(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this })));
+        objects.push(await liftEither(objectType.${syntheticNamePrefix}fromRdf(new ${imports.Resource}(dataset, identifier as ${imports.NamedNode}), { objectSet: this, preferredLanguages: query?.preferredLanguages })));
       }
       return objects;
     });
@@ -211,7 +211,7 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
       patterns = patterns.concat(query.where(this.${syntheticNamePrefix}objectVariable));
     }
 
-    patterns = patterns.concat(objectType.${syntheticNamePrefix}sparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable }));
+    patterns = patterns.concat(objectType.${syntheticNamePrefix}sparqlWherePatterns({ filter: query?.filter, focusIdentifier: this.${syntheticNamePrefix}objectVariable, ignoreRdfType: false, preferredLanguages: query?.preferredLanguages, variablePrefix: this.${syntheticNamePrefix}objectVariable.value }));
 
     patterns = ${snippets.normalizeSparqlWherePatterns}(patterns).concat();
 

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.5",
+    "@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.5"
+  "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,143 +0,0 @@
-import { rdf, rdfs } from "@tpluscode/rdf-ns-builders";
-import { camelCase } from "change-case";
-import { imports } from "../imports.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { snippets } from "../snippets.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode, literalOf } 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 `focusIdentifier`,
-        variablePrefix: code `(parameters?.variablePrefix ?? (focusIdentifier.termType === "Variable" ? focusIdentifier.value : ${literalOf(camelCase(this.name))}))`,
-    };
-    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(${{ 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, 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: 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: focusIdentifier }),`
-            : code `${snippets.sparqlInstancesOfPattern}({ rdfType: ${fromRdfTypeVariables[0]}, subject: focusIdentifier }),`}
-    {
-      triples: [
-        {
-          subject: 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}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean;  variablePrefix?: string }): readonly ${imports.sparqljs}.Triple[] {
-${sparqlConstructTriplesStatements.length > 0
-            ? joinCode([
-                code `const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!(${literalOf(camelCase(this.name))});`,
-                code `${triplesVariableDeclarationKeyword} triples: ${imports.sparqljs}.Triple[] = [];`,
-                ...sparqlConstructTriplesStatements,
-                code `return triples;`,
-            ])
-            : "return [];"}
-}`,
-        code `\
-export function ${syntheticNamePrefix}sparqlWherePatterns(${sparqlWherePatternsStatements.length === 0 ? "_" : ""}parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; variablePrefix?: string }): readonly ${snippets.SparqlPattern}[] {
-${sparqlWherePatternsStatements.length > 0
-            ? joinCode([
-                code `${patternsVariableDeclarationKeyword} patterns: ${snippets.SparqlPattern}[] = [];`,
-                code `const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!(${literalOf(camelCase(this.name))});`,
-                ...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

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

@@ -1,45 +0,0 @@
-import { camelCase, pascalCase } from "change-case";
-import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "../_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "../_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-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_sparqlFunctionDeclarations() {
-    if (!this.features.has("sparql")) {
-        return [];
-    }
-    return [
-        ObjectType_sparqlConstructQueryFunctionDeclaration.bind(this)(),
-        ObjectType_sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
-        code `\
-export function ${syntheticNamePrefix}sparqlConstructTriples(parameters?: { filter?: ${this.filterType}; 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: parameters?.filter?.on?.${memberType.name}, focusIdentifier: parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`), { on: ", " })}];
-}`,
-        code `\
-export function ${syntheticNamePrefix}sparqlWherePatterns(parameters?: { filter?: ${this.filterType}; focusIdentifier?: ${imports.NamedNode} | ${imports.Variable}; ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; variablePrefix?: string }): readonly ${snippets.SparqlPattern}[] {
-${joinCode([
-            code `let patterns: ${snippets.SparqlPattern}[] = [];`,
-            code `\
-    const focusIdentifier = parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!("${camelCase(this.name)}");
-    if (focusIdentifier.termType === "Variable") {
-      patterns = patterns.concat(${this.identifierType.sparqlWherePatternsFunction}({
-          filter: parameters?.filter?.${syntheticNamePrefix}identifier,
-          ignoreRdfType: false,
-          preferredLanguages: parameters?.preferredLanguages,
-          propertyPatterns: [],
-          schema: ${this.identifierType.schema},
-          valueVariable: focusIdentifier,
-          variablePrefix: focusIdentifier.termType === "Variable" ? focusIdentifier.value : ${literalOf(camelCase(this.name))},
-      }));
-    }`,
-            code `patterns.push({ patterns: [${joinCode(this.concreteMemberTypes.map((memberType) => code `${{
-                patterns: code `${memberType.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter: parameters?.filter?.on?.${memberType.name}, focusIdentifier: parameters?.focusIdentifier ?? ${imports.dataFactory}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
-                type: literalOf("group"),
-            }}`), { on: ", " })}], type: "union" });`,
-            code `return patterns;`,
-        ])}
-}`,
-    ];
-}
-//# sourceMappingURL=ObjectUnionType_sparqlFunctionDeclarations.js.map