@shaclmate/compiler 4.0.31 → 4.0.32

package/dist/generators/ts/Snippets.d.ts

@@ -104,6 +104,7 @@ export declare class Snippets {
     get parseBlankNode(): Snippet;
     get parseIdentifier(): Snippet;
     get parseIri(): Snippet;
+    get sequenceRecord(): Snippet;
     get setSparqlConstructTriples(): Snippet;
     get setSparqlWherePatterns(): Snippet;
     get shaclPropertyFromRdf(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -93,6 +93,7 @@ import { snippets_SparqlPattern } from "./_snippets/snippets_SparqlPattern.js";
 import { snippets_SparqlPattern_isSolutionGenerating } from "./_snippets/snippets_SparqlPattern_isSolutionGenerating.js";
 import { snippets_StringFilter } from "./_snippets/snippets_StringFilter.js";
 import { snippets_StringSchema } from "./_snippets/snippets_StringSchema.js";
+import { snippets_sequenceRecord } from "./_snippets/snippets_sequenceRecord.js";
 import { snippets_setSparqlConstructTriples } from "./_snippets/snippets_setSparqlConstructTriples.js";
 import { snippets_setSparqlWherePatterns } from "./_snippets/snippets_setSparqlWherePatterns.js";
 import { snippets_shaclPropertyFromRdf } from "./_snippets/snippets_shaclPropertyFromRdf.js";
@@ -427,6 +428,9 @@ export class Snippets {
     get parseIri() {
         return this.snippet(snippets_parseIri);
     }
+    get sequenceRecord() {
+        return this.snippet(snippets_sequenceRecord);
+    }
     get setSparqlConstructTriples() {
         return this.snippet(snippets_setSparqlConstructTriples);
     }
@@ -774,6 +778,9 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "parseIri", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "sequenceRecord", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "setSparqlConstructTriples", null);

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

@@ -14,8 +14,8 @@ const variables = {
 const propertyFromRdfResourceValuesExpressionVariable = {
     context: variables.context,
     graph: variables.graph,
-    preferredLanguages: variables.preferredLanguages,
     objectSet: variables.objectSet,
+    preferredLanguages: variables.preferredLanguages,
     resource: variables.resource,
 };
 export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
@@ -23,13 +23,13 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
         return Maybe.empty();
     }
     const chains = [];
-    const initializers = [];
+    const partials = [];
     this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
         chains.push({
             expression: code `${parentObjectType.name}._fromRdfResource(${variables.resource}, { ...${optionsVariable}, ignoreRdfType: true })`,
-            variable: `${syntheticNamePrefix}super${parentObjectTypeI}`,
+            variable: `super${parentObjectTypeI}`,
         });
-        initializers.push(code `...${syntheticNamePrefix}super${parentObjectTypeI}`);
+        partials.push(`super${parentObjectTypeI}`);
     });
     this.fromRdfType.ifJust((fromRdfType) => {
         const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
@@ -57,24 +57,41 @@ export function NamedObjectType_fromRdfResourceFunctionDeclaration() {
 
       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",
+            variable: `_rdfTypeCheck`,
         });
     });
+    const propertyFromRdfResourceValuesExpressions = {};
     for (const property of this.properties) {
         property
             .fromRdfResourceValuesExpression({
             variables: propertyFromRdfResourceValuesExpressionVariable,
         })
-            .ifJust((propertyFromRdfExpression) => {
-            chains.push({
-                expression: propertyFromRdfExpression,
-                variable: property.name,
-            });
-            initializers.push(code `${property.name}`);
+            .ifJust((propertyFromRdfResourceValuesExpression) => {
+            propertyFromRdfResourceValuesExpressions[property.name] =
+                propertyFromRdfResourceValuesExpression;
+        });
+    }
+    if (Object.keys(propertyFromRdfResourceValuesExpressions).length > 0) {
+        chains.push({
+            expression: code `${this.reusables.snippets.sequenceRecord}(${propertyFromRdfResourceValuesExpressions})`,
+            variable: "properties",
         });
+        partials.push("properties");
+    }
+    let partialsJoined;
+    switch (partials.length) {
+        case 0:
+            partialsJoined = code `{}`;
+            break;
+        case 1:
+            partialsJoined = code `${partials[0]}`;
+            break;
+        default:
+            partialsJoined = code `{ ${partials.map((partial) => `...${partial}`).join(", ")} }`;
+            break;
     }
     const statements = [];
-    const resultExpression = code `${this.name}.create({ ${joinCode(initializers, { on: "," })} })`;
+    const resultExpression = code `create(${partialsJoined})`;
     if (chains.length === 0) {
         statements.push(code `return ${this.reusables.imports.Right}(${resultExpression});`);
     }

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

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

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

@@ -0,0 +1,18 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_sequenceRecord = ({ imports, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}sequenceRecord`, code `\
+function ${syntheticNamePrefix}sequenceRecord<T extends Record<string, unknown>>(
+  record: { [K in keyof T]: ${imports.Either}<Error, T[K]> }
+): ${imports.Either}<Error, T> {
+  const result: { [K in keyof T]?: T[K] } = {};
+
+  for (const key of globalThis.Object.keys(record) as Array<keyof T>) {
+    const either = record[key];
+    if (either.isLeft()) {
+      return either as unknown as ${imports.Either}<Error, T>;
+    }
+    result[key] = either.extract() as T[typeof key];
+  }
+
+  return ${imports.Right}(result as T);
+}`);
+//# sourceMappingURL=snippets_sequenceRecord.js.map