@shaclmate/compiler 4.0.6 → 4.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.6",
+    "@shaclmate/shacl-ast": "4.0.8",
     "@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.8"
 }

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

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

@@ -1,44 +0,0 @@
-import { 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({ 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: ", " })}];
-}`,
-        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_sparqlFunctionDeclarations.js.map