@shaclmate/compiler 4.0.30 → 4.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.30",
+    "@shaclmate/shacl-ast": "4.0.31",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -68,5 +68,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.30"
+  "version": "4.0.31"
 }

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromJsonFunctionDeclaration.js

@@ -1,38 +0,0 @@
-import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-const variables = {
-    jsonObject: code `${syntheticNamePrefix}json`,
-};
-export function NamedObjectType_propertiesFromJsonFunctionDeclaration() {
-    if (!this.features.has("json")) {
-        return Maybe.empty();
-    }
-    const initializers = [];
-    const statements = [];
-    const propertyReturnTypeSignatures = [];
-    const returnType = [];
-    this.parentObjectTypes.forEach((parentObjectType) => {
-        initializers.push(code `...${parentObjectType.name}.propertiesFromJson(${variables.jsonObject})`);
-        returnType.push(code `ReturnType<typeof ${parentObjectType.name}.propertiesFromJson>`);
-    });
-    for (const property of this.properties) {
-        const propertyFromJsonStatements = property.fromJsonStatements({
-            variables,
-        });
-        if (propertyFromJsonStatements.length > 0) {
-            propertyReturnTypeSignatures.push(code `${property.name}: ${property.type.name};`);
-            initializers.push(code `${property.name}`);
-            statements.push(...propertyFromJsonStatements);
-        }
-    }
-    statements.push(code `return { ${joinCode(initializers, { on: ", " })} };`);
-    if (propertyReturnTypeSignatures.length > 0) {
-        returnType.splice(0, 0, code `{ ${joinCode(propertyReturnTypeSignatures, { on: " " })} }`);
-    }
-    return Maybe.of(code `\
-export function propertiesFromJson(${variables.jsonObject}: ${this.jsonType().name}): ${joinCode(returnType, { on: " & " })} {
-${joinCode(statements)}
-}`);
-}
-//# sourceMappingURL=NamedObjectType_propertiesFromJsonFunctionDeclaration.js.map

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.d.ts

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

package/dist/generators/ts/_NamedObjectType/NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js

@@ -1,98 +0,0 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { code, joinCode } from "../ts-poet-wrapper.js";
-const optionsVariable = `_${syntheticNamePrefix}options`;
-const variables = {
-    context: code `${optionsVariable}.context`,
-    graph: code `${optionsVariable}.graph`,
-    ignoreRdfType: code `${optionsVariable}.ignoreRdfType`,
-    objectSet: code `${optionsVariable}.objectSet`,
-    preferredLanguages: code `${optionsVariable}.preferredLanguages`,
-    resource: code `${syntheticNamePrefix}resource`,
-};
-export function NamedObjectType_propertiesFromRdfResourceFunctionDeclaration() {
-    if (!this.features.has("rdf")) {
-        return Maybe.empty();
-    }
-    const chains = [];
-    const initializers = [];
-    const propertySignatures = [];
-    const returnType = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        chains.push({
-            expression: code `${parentObjectType.name}.propertiesFromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
-            variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
-        });
-        initializers.push(code `...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        returnType.push(code `${this.reusables.snippets.UnwrapR}<ReturnType<typeof ${parentObjectType.name}.propertiesFromRdfResource>>`);
-    });
-    this.fromRdfType.ifJust((fromRdfType) => {
-        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
-        const predicate = this.rdfjsTermExpression(rdf.type);
-        // Check the expected type and its known subtypes
-        const cases = new Set();
-        cases.add(fromRdfType.value);
-        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
-            cases.add(descendantFromRdfType.value);
-        }
-        chains.push({
-            expression: code `!${variables.ignoreRdfType} ? ${variables.resource}.value(${predicate}, ${{ graph: variables.graph }})
-    .chain(actualRdfType => actualRdfType.toIri())
-    .chain((actualRdfType) => {
-      // Check the expected type and its known subtypes
-      switch (actualRdfType.value) {
-        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
-          return ${this.reusables.imports.Right}(true as const);
-      }
-
-      // Check arbitrary rdfs:subClassOf's of the expected type
-      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable}, ${{ graph: variables.graph }})) {
-        return ${this.reusables.imports.Right}(true as const);
-      }
-
-      return ${this.reusables.imports.Left}(new Error(\`\${${variables.resource}.identifier} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
-    }) : ${this.reusables.imports.Right}(true as const)`,
-            variable: "_rdfTypeCheck",
-        });
-    });
-    const propertyFromRdfVariables = {
-        context: variables.context,
-        graph: variables.graph,
-        preferredLanguages: variables.preferredLanguages,
-        objectSet: variables.objectSet,
-        resource: variables.resource,
-    };
-    for (const property of this.properties) {
-        property
-            .fromRdfResourceValuesExpression({
-            variables: propertyFromRdfVariables,
-        })
-            .ifJust((propertyFromRdfExpression) => {
-            chains.push({
-                expression: propertyFromRdfExpression,
-                variable: property.name,
-            });
-            initializers.push(code `${property.name}`);
-            propertySignatures.push(code `${property.name}: ${property.type.name};`);
-        });
-    }
-    const statements = [];
-    const resultExpression = code `{ ${joinCode(initializers, { on: "," })} }`;
-    if (chains.length === 0) {
-        statements.push(code `return ${this.reusables.imports.Right}(${resultExpression});`);
-    }
-    else {
-        statements.push(code `return ${chains
-            .reverse()
-            .reduce((acc, { expression, variable }, chainI) => code `(${expression}).${chainI === 0 ? "map" : "chain"}(${variable} => ${acc})`, code `(${resultExpression})`)}`);
-    }
-    if (propertySignatures.length > 0) {
-        returnType.splice(0, 0, code `{ ${joinCode(propertySignatures, { on: " " })} }`);
-    }
-    return Maybe.of(code `\
-export const propertiesFromRdfResource: ${this.reusables.snippets.PropertiesFromRdfResourceFunction}<${joinCode(returnType, { on: " & " })}> = (${syntheticNamePrefix}resource, ${optionsVariable}) => {
-${joinCode(statements)}
-};`);
-}
-//# sourceMappingURL=NamedObjectType_propertiesFromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_snippets/snippets_PropertiesFromRdfResourceFunction.d.ts

@@ -1,3 +0,0 @@
-import type { SnippetFactory } from "../SnippetFactory.js";
-export declare const snippets_PropertiesFromRdfResourceFunction: SnippetFactory;
-//# sourceMappingURL=snippets_PropertiesFromRdfResourceFunction.d.ts.map

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

@@ -1,13 +0,0 @@
-import { code, conditionalOutput } from "../ts-poet-wrapper.js";
-export const snippets_PropertiesFromRdfResourceFunction = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}PropertiesFromRdfResourceFunction`, code `\
-type ${syntheticNamePrefix}PropertiesFromRdfResourceFunction<T> = (
-  resource: ${imports.Resource},
-  options: {
-    context: undefined | unknown;
-    graph: Exclude<${imports.Quad_Graph}, ${imports.Variable}> | undefined;
-    ignoreRdfType: boolean;
-    objectSet: ${syntheticNamePrefix}ObjectSet;
-    preferredLanguages?: readonly string[];
-  }
-) => ${imports.Either}<Error, T>;`);
-//# sourceMappingURL=snippets_PropertiesFromRdfResourceFunction.js.map