@shaclmate/compiler 4.0.39 → 4.0.41

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_toRdfResourceFunctionDeclaration.js → _ObjectType/ObjectType_toRdfResourceFunctionDeclaration.js}

@@ -1,11 +1,11 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toRdfResourceFunctionDeclaration() {
+export function ObjectType_toRdfResourceFunctionDeclaration() {
     if (!this.configuration.features.has("Object.toRdf")) {
         return Maybe.empty();
     }
-    const statements = this.parentObjectTypes.map((parentObjectType) => code `${parentObjectType.name}._toRdfResource({ ...parameters, ignoreRdfType: true });`);
+    const statements = [];
     if (this.toRdfTypes.length > 0) {
         statements.push(code `if (!${variables.ignoreRdfType}) { ${joinCode(this.toRdfTypes.map((toRdfType) => code `${variables.resource}.add(${this.rdfjsTermExpression(rdf.type)}, ${this.reusables.imports.dataFactory}.namedNode("${toRdfType.value}"), ${variables.graph});`), { on: " " })} }`);
     }
@@ -23,7 +23,7 @@ export function NamedObjectType_toRdfResourceFunctionDeclaration() {
     }
     statements.push(code `return ${variables.resource};`);
     return Maybe.of(code `\
-export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.name}> = (parameters) => {
+export const _toRdfResource: ${this.reusables.snippets._ToRdfResourceFunction}<${this.identifierTypeAlias}, ${this.expression}> = (parameters) => {
 ${joinCode(statements)}
 }
 
@@ -36,4 +36,4 @@ const variables = {
     resource: code `parameters.resource`,
     resourceSet: code `parameters.resourceSet`,
 };
-//# sourceMappingURL=NamedObjectType_toRdfResourceFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_toRdfResourceFunctionDeclaration.js.map

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

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

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_toStringFunctionDeclarations.js → _ObjectType/ObjectType_toStringFunctionDeclarations.js}

@@ -1,15 +1,9 @@
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function NamedObjectType_toStringFunctionDeclarations() {
+export function ObjectType_toStringFunctionDeclarations() {
     if (!this.configuration.features.has("Object.toString")) {
         return [];
     }
-    let propertiesToStringInitializers = [];
-    if (this.parentObjectTypes.length > 0) {
-        for (const parentObjectType of this.parentObjectTypes) {
-            propertiesToStringInitializers.push(code `...${parentObjectType.name}._propertiesToStrings(${this.thisVariable})`);
-        }
-    }
-    propertiesToStringInitializers = propertiesToStringInitializers.concat(this.properties.flatMap((property) => property
+    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(this.properties.flatMap((property) => property
         .toStringInitializer({
         variables: {
             value: property.accessExpression({
@@ -17,20 +11,19 @@ export function NamedObjectType_toStringFunctionDeclarations() {
             }),
         },
     })
-        .toList()));
-    const propertiesToStringsReturnExpression = code `${this.reusables.snippets.compactRecord}({${joinCode(propertiesToStringInitializers, { on: "," })}})`;
-    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.name}(\${JSON.stringify(${propertiesToStrings})})\``;
+        .toList()), { on: "," })}})`;
+    const toStringReturnExpression = (propertiesToStrings) => code `\`${this.alias.unsafeCoerce()}(\${JSON.stringify(${propertiesToStrings})})\``;
     const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
     return [
         // Use overloads to allow the function to be attached to an instance or used freestanding
         code `\
-export function _propertiesToStrings(${this.thisVariable}: ${this.name}): Record<string, string> {
+export function _propertiesToStrings(${this.thisVariable}: ${this.expression}): Record<string, string> {
   return ${propertiesToStringsReturnExpression};
 }`,
         code `\
-export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.name}): string {
+export function ${syntheticNamePrefix}toString(${this.thisVariable}: ${this.expression}): string {
   return ${toStringReturnExpression(code `_propertiesToStrings(${this.thisVariable})`)};
 }`,
     ];
 }
-//# sourceMappingURL=NamedObjectType_toStringFunctionDeclarations.js.map
+//# sourceMappingURL=ObjectType_toStringFunctionDeclarations.js.map

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

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

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js → _ObjectType/ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js}

@@ -1,11 +1,11 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
+export function ObjectType_valueSparqlConstructTriplesFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
 export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, valueVariable, variablePrefix }) =>
-  ${this.name}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
+  ${this.alias.unsafeCoerce()}.focusSparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType, variablePrefix });`);
 }
-//# sourceMappingURL=NamedObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_valueSparqlConstructTriplesFunctionDeclaration.js.map

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

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

package/dist/generators/ts/{_NamedObjectType/NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js → _ObjectType/ObjectType_valueSparqlWherePatternsFunctionDeclaration.js}

@@ -1,13 +1,13 @@
 import { Maybe } from "purify-ts";
 import { code } from "../ts-poet-wrapper.js";
-export function NamedObjectType_valueSparqlWherePatternsFunctionDeclaration() {
+export function ObjectType_valueSparqlWherePatternsFunctionDeclaration() {
     if (!this.configuration.features.has("Object.SPARQL")) {
         return Maybe.empty();
     }
     return Maybe.of(code `\
 export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ({ filter, ignoreRdfType, preferredLanguages, propertyPatterns, valueVariable, variablePrefix }) =>
   (propertyPatterns as readonly ${this.reusables.snippets.SparqlPattern}[]).concat(
-    ${this.name}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
+    ${this.alias.unsafeCoerce()}.focusSparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType, preferredLanguages, variablePrefix })
   );`);
 }
-//# sourceMappingURL=NamedObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map
+//# sourceMappingURL=ObjectType_valueSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/{_NamedObjectType → _ObjectType}/ShaclProperty.js

@@ -31,19 +31,19 @@ export class ShaclProperty extends AbstractProperty {
     get constructorParameter() {
         const conversionFunction = this.type.conversionFunction.extract();
         if (!conversionFunction) {
-            return Maybe.of(code `readonly ${this.name}: ${this.type.name};`);
+            return Maybe.of(code `readonly ${this.name}: ${this.type.expression};`);
         }
         let hasQuestionToken = false;
-        const typeNames = [];
+        const typeExpressions = [];
         for (const type of conversionFunction.sourceTypes) {
-            if (type.typeof === "undefined") {
+            if (type.jsType.typeof === "undefined") {
                 hasQuestionToken = true;
             }
             else {
-                typeNames.push(code `${type.name}`);
+                typeExpressions.push(code `${type.expression}`);
             }
         }
-        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
+        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeExpressions, { on: "|" })};`);
     }
     get declaration() {
         const lhs = [];
@@ -55,7 +55,7 @@ export class ShaclProperty extends AbstractProperty {
             .alt(this.description)
             .alt(this.label)
             .map(tsComment)
-            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`;
+            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.expression};`;
     }
     get filterProperty() {
         return Maybe.of({
@@ -71,7 +71,7 @@ export class ShaclProperty extends AbstractProperty {
             description: this.comment.map(JSON.stringify),
             name: this.name,
             resolve: code `(source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: code `source.${this.name}` } })}`,
-            type: this.type.graphqlType.name,
+            type: this.type.graphqlType.expression,
         });
     }
     get jsonSchema() {
@@ -95,7 +95,7 @@ export class ShaclProperty extends AbstractProperty {
     }
     get jsonSignature() {
         const typeJsonType = this.type.jsonType();
-        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+        return Maybe.of(code `${!this.mutable ? "readonly " : ""}${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredExpression}`);
     }
     get schemaInitializers() {
         const initializers = super.schemaInitializers.concat();
@@ -118,13 +118,13 @@ export class ShaclProperty extends AbstractProperty {
         const validationFunction = this.type.validationFunction.extract();
         let rhs;
         if (conversionFunction && validationFunction) {
-            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type, value))`;
+            rhs = code `${conversionFunction}(${parameterVariable}).chain(value => ${validationFunction}(${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, value))`;
         }
         else if (conversionFunction) {
             rhs = code `${conversionFunction}(${parameterVariable})`;
         }
         else if (validationFunction) {
-            rhs = code `${validationFunction}(${this.namedObjectType.name}.schema.properties.${this.name}.type, ${parameterVariable})`;
+            rhs = code `${validationFunction}(${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.type, ${parameterVariable})`;
         }
         else {
             rhs = code `${this.reusables.imports.Either}.of(${parameterVariable})`;
@@ -148,7 +148,7 @@ export class ShaclProperty extends AbstractProperty {
                 variables: {
                     ...variables,
                     ignoreRdfType: true,
-                    propertyPath: code `${this.namedObjectType.name}.schema.properties.${this.name}.path`,
+                    propertyPath: code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`,
                     resourceValues: code `resourceValues`,
                 },
             })})`,
@@ -209,7 +209,7 @@ export class ShaclProperty extends AbstractProperty {
             default:
                 return [];
         }
-        const propertyPath = code `${this.namedObjectType.name}.schema.properties.${this.name}.path`;
+        const propertyPath = code `${this.objectType.alias.unsafeCoerce()}.schema.properties.${this.name}.path`;
         return [
             code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfResourceValuesExpression({
                 variables: { ...variables, propertyPath },

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

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

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

@@ -0,0 +1,16 @@
+import { code } from "../ts-poet-wrapper.js";
+export function identifierTypeDeclarations() {
+    if (!this.configuration.features.has("Object.type")) {
+        return [];
+    }
+    // Bespoke identifier type and associated functions
+    return [
+        code `export type Identifier = ${this.identifierType.expression};`,
+        code `\
+export namespace Identifier {
+  export const parse = ${this.identifierType.parseFunction};
+  export const stringify = ${this.identifierType.stringifyFunction};
+}`,
+    ];
+}
+//# sourceMappingURL=identifierTypeDeclarations.js.map

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

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

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

@@ -0,0 +1,8 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToArraySet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToArraySet`, code `\
+function ${syntheticNamePrefix}convertToArraySet<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetArrayT> => 
+    (typeof value === "undefined" ? ${imports.Either}.of([]) : ${imports.Either}.sequence(value.map(convertToItem))) as ${imports.Either}<Error, ItemTargetArrayT>;
+}`);
+//# sourceMappingURL=snippets_convertToArraySet.js.map

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

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

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

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToList = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToList`, code `\
+function ${syntheticNamePrefix}convertToList<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: readonly ItemSourceT[]): ${imports.Either}<Error, ItemTargetArrayT> => ${imports.Either}.sequence(value.map(convertToItem)) as ${imports.Either}<Error, ItemTargetArrayT>;
+}`);
+//# sourceMappingURL=snippets_convertToList.js.map

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

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

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

@@ -0,0 +1,15 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_convertToScalarSet = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}convertToScalarSet`, code `\
+function ${syntheticNamePrefix}convertToScalarSet<ItemSourceT, ItemTargetT, Readonly extends boolean>(convertToItem: ${snippets.ConversionFunction}<ItemSourceT, ItemTargetT>, _readonly: Readonly) {
+  type ItemTargetArrayT = Readonly extends true ? ReadonlyArray<ItemTargetT> : Array<ItemTargetT>;
+  return (value: ItemSourceT | readonly ItemSourceT[] | undefined): ${imports.Either}<Error, ItemTargetArrayT> => {
+    if (typeof value === "undefined") {
+      return ${imports.Either}.of<Error, ItemTargetArrayT>([] as unknown as ItemTargetArrayT);
+    }
+    if (Array.isArray(value)) {
+      return ${imports.Either}.sequence(value.map(convertToItem)) as ${imports.Either}<Error, ItemTargetArrayT>;
+    }
+    return convertToItem(value as ItemSourceT).map(value => [value]) as ${imports.Either}<Error, ItemTargetArrayT>;
+  };
+}`);
+//# sourceMappingURL=snippets_convertToScalarSet.js.map