@shaclmate/compiler 4.0.59 → 4.0.61

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonTypeLiteral.d.ts

@@ -0,0 +1,5 @@
+import { AbstractType } from "../AbstractType.js";
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+export declare function DiscriminatedUnionType_jsonTypeLiteral<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): AbstractType.JsonType;
+//# sourceMappingURL=DiscriminatedUnionType_jsonTypeLiteral.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonTypeLiteral.js

@@ -0,0 +1,26 @@
+import { AbstractType } from "../AbstractType.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_jsonTypeLiteral() {
+    const discriminant = this.discriminant; // To get type narrowing to work
+    switch (discriminant.kind) {
+        case "Extrinsic":
+            return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }) => code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`), { on: "|" })})`);
+        case "Hybrid":
+            return new AbstractType.JsonType(code `(${joinCode(this.members.map(({ jsonType, primaryDiscriminantValue }, memberI) => {
+                switch (discriminant.memberValues[memberI].kind) {
+                    case "Extrinsic":
+                        return code `{ ${discriminant.name}: ${literalOf(primaryDiscriminantValue)}, value: ${jsonType} }`;
+                    case "Intrinsic":
+                        return code `${jsonType}`;
+                    default:
+                        throw new Error();
+                }
+            }), { on: "|" })})`);
+        case "Intrinsic":
+        case "Typeof":
+            return new AbstractType.JsonType(joinCode(this.members.map(({ jsonType }) => code `${jsonType}`), { on: "|" }));
+        default:
+            throw discriminant;
+    }
+}
+//# sourceMappingURL=DiscriminatedUnionType_jsonTypeLiteral.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_schemaTypeExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_schemaTypeExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_schemaTypeExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_schemaTypeExpression.js

@@ -0,0 +1,11 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_schemaTypeExpression() {
+    return code `${{
+        kind: this.kind,
+        members: code `{ ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `readonly ${literalOf(primaryDiscriminantValue)}: ${{
+            discriminantValues: code `readonly (number | string)[]`,
+            type: type.schemaType,
+        }}`), { on: ";" })} }`,
+    }}`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_schemaTypeExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toJsonFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_toJsonFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_toJsonFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toJsonFunctionExpression.js

@@ -0,0 +1,10 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_toJsonFunctionExpression() {
+    return code `\
+((value: ${this.expression}): ${this.jsonType().expression} => {
+${joinCode(this.members.map(({ typeCheck, typeToJsonExpression, unwrap, wrap }) => code `if (${typeCheck(code `value`)}) { return ${wrap(typeToJsonExpression(unwrap(code `value`)))}; }`))}
+
+  throw new Error("unable to serialize to JSON");
+})`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_toJsonFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_toRdfResourceValuesFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js

@@ -0,0 +1,30 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_toRdfResourceValuesFunctionExpression() {
+    return code `\
+  (((value, _options): (${joinCode([...this.toRdfResourceValueTypes].map((toRdfResourceValueType) => {
+        switch (toRdfResourceValueType) {
+            case "BlankNode":
+                return code `${this.reusables.imports.BlankNode}`;
+            case "Literal":
+                return code `${this.reusables.imports.Literal}`;
+            case "NamedNode":
+                return code `${this.reusables.imports.NamedNode}`;
+            default:
+                toRdfResourceValueType;
+                throw new Error();
+        }
+    }), { on: " | " })})[] => {
+  ${joinCode(this.members.map(({ type, unwrap, typeCheck }) => code `if (${typeCheck(code `value`)}) { return ${type.toRdfResourceValuesExpression({
+        variables: {
+            graph: code `_options.graph`,
+            propertyPath: code `_options.propertyPath`,
+            resource: code `_options.resource`,
+            resourceSet: code `_options.resourceSet`,
+            value: unwrap(code `value`),
+        },
+    })}; }`))}
+  
+    throw new Error("unable to serialize to RDF");
+  }) satisfies ${this.reusables.snippets.ToRdfResourceValuesFunction}<${this.expression}>)`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toStringFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_toStringFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_toStringFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toStringFunctionExpression.js

@@ -0,0 +1,12 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_toStringFunctionExpression() {
+    return code `\
+((value: ${this.expression}): string => {
+${joinCode(this.members.map(({ type, typeCheck, unwrap }) => code `if (${typeCheck(code `value`)}) { return ${type.toStringExpression({
+        variables: { value: unwrap(code `value`) },
+    })}; }`))}
+
+  throw new Error("unable to serialize to string");
+})`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_toStringFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js

@@ -0,0 +1,13 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression() {
+    return code `\
+((({ ignoreRdfType, filter, schema, ...otherParameters }) => {
+  let triples: ${this.reusables.imports.sparqljs}.Triple[] = [];
+
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
+triples = triples.concat(${type.valueSparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }));`))}
+  
+  return triples;
+}) satisfies ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}>)`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.d.ts

@@ -0,0 +1,5 @@
+import type { DiscriminatedUnionType } from "../DiscriminatedUnionType.js";
+import type { Type } from "../Type.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression<MemberTypeT extends Type>(this: DiscriminatedUnionType<MemberTypeT>): Code;
+//# sourceMappingURL=DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.d.ts.map

package/dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js

@@ -0,0 +1,13 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression() {
+    return code `\
+((({ filter, schema, ...otherParameters }) => {
+  const unionPatterns: ${this.reusables.imports.sparqljs}.GroupPattern[] = [];
+
+  ${joinCode(this.members.map(({ type, primaryDiscriminantValue }) => code `\
+unionPatterns.push({ patterns: ${type.valueSparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.[${literalOf(primaryDiscriminantValue)}], ignoreRdfType: false, schema: schema.members[${literalOf(primaryDiscriminantValue)}].type }).concat(), type: "group" });`))}
+  
+  return [{ patterns: unionPatterns, type: "union" }];
+}) satisfies ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}>)`;
+}
+//# sourceMappingURL=DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js

@@ -0,0 +1,13 @@
+import { pascalCase } from "change-case";
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.SPARQL")) {
+        return {};
+    }
+    return singleEntryRecord(`focusSparqlConstructTriples`, code `\
+export function focusSparqlConstructTriples({ filter, focusIdentifier, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; variablePrefix: string }): readonly ${this.reusables.imports.sparqljs}.Triple[] {
+  return [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}];
+}`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js

@@ -0,0 +1,32 @@
+import { pascalCase } from "change-case";
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.SPARQL")) {
+        return {};
+    }
+    return singleEntryRecord(`focusSparqlWherePatterns`, code `\
+export function focusSparqlWherePatterns({ filter, focusIdentifier, preferredLanguages, variablePrefix }: { filter: ${this.filterType} | undefined; focusIdentifier: ${this.reusables.imports.NamedNode} | ${this.reusables.imports.Variable}; ignoreRdfType: boolean; preferredLanguages: readonly string[] | undefined; variablePrefix: string }): readonly ${this.reusables.snippets.SparqlPattern}[] {
+${joinCode([
+        code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
+        code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.identifierType.unsafeCoerce().valueSparqlWherePatternsFunction}({
+      filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.identifierType.unsafeCoerce().schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+        code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
+            patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.type.name.unsafeCoerce()}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
+            type: literalOf("group"),
+        }}`), { on: ", " })}], type: "union" });`,
+        code `return patterns;`,
+    ])}
+}`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js

@@ -0,0 +1,17 @@
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.fromRdf")) {
+        return {};
+    }
+    const name = this.name.unsafeCoerce();
+    return singleEntryRecord(`fromRdfResource`, code `\
+export const fromRdfResource: ${this.reusables.snippets.FromRdfResourceFunction}<${name}> = (resource, options) => 
+  ${this.members.reduce((expression, member) => {
+        const memberTypeExpression = code `(${member.type.name.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${name}>)`;
+        return expression !== null
+            ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+            : memberTypeExpression;
+    }, null)};`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_graphqlTypeVariableStatement(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js

@@ -0,0 +1,19 @@
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_graphqlTypeVariableStatement() {
+    if (!this.configuration.features.has("GraphQL")) {
+        return {};
+    }
+    if (this.synthetic) {
+        return {};
+    }
+    const name = this.name.unsafeCoerce();
+    return singleEntryRecord(`GraphQL`, code `\
+export const GraphQL = new ${this.reusables.imports.GraphQLUnionType}(${{
+        description: this.comment.map(JSON.stringify).extract(),
+        name: name,
+        resolveType: code `(value: ${name}) => value.${this.configuration.syntheticNamePrefix}type`,
+        types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
+    }});`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_identifierTypeDeclarations(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_identifierTypeDeclarations.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.js

@@ -0,0 +1,14 @@
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_identifierTypeDeclarations() {
+    if (!this.configuration.features.has("Object.type")) {
+        return {};
+    }
+    return singleEntryRecord(`Identifier`, code `\
+export type Identifier = ${this.identifierType.unsafeCoerce().expression};
+export namespace Identifier {
+  export const parse = ${this.identifierType.unsafeCoerce().parseFunction};
+  export const stringify = ${this.identifierType.unsafeCoerce().stringifyFunction};
+}`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_identifierTypeDeclarations.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_isTypeFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js

@@ -0,0 +1,16 @@
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_isTypeFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.type")) {
+        return {};
+    }
+    const name = this.name.unsafeCoerce();
+    if (name === `${this.configuration.syntheticNamePrefix}Object`) {
+        return {};
+    }
+    return singleEntryRecord(`is${name}`, code `\
+    export function is${name}(object: ${this.configuration.syntheticNamePrefix}Object): object is ${name} {
+      return ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};
+    }`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_schemaVariableStatement(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_schemaVariableStatement.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.js

@@ -0,0 +1,42 @@
+import { PropertyPath } from "@rdfx/resource";
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_schemaVariableStatement() {
+    if (!this.configuration.features.has("Object.schema")) {
+        return {};
+    }
+    const commonPropertiesByName = {};
+    this.members.forEach((member, memberI) => {
+        for (const memberTypeProperty of member.type.properties) {
+            if (memberTypeProperty.kind !== "Shacl") {
+                continue;
+            }
+            let commonProperty = commonPropertiesByName[memberTypeProperty.name];
+            if (commonProperty) {
+                if (PropertyPath.equals(commonProperty.property.path, memberTypeProperty.path)) {
+                    commonProperty.memberTypesWithProperty[memberI] = true;
+                }
+            }
+            else {
+                commonPropertiesByName[memberTypeProperty.name] = commonProperty = {
+                    memberTypesWithProperty: new Array(this.members.length).fill(false),
+                    property: memberTypeProperty,
+                };
+                commonProperty.memberTypesWithProperty[memberI] = true;
+            }
+        }
+    });
+    const propertiesObject = [];
+    for (const name of Object.keys(commonPropertiesByName).toSorted()) {
+        const { memberTypesWithProperty, property } = commonPropertiesByName[name];
+        if (!memberTypesWithProperty.every((value) => value)) {
+            continue;
+        }
+        property.schema.ifJust((propertySchema) => {
+            propertiesObject.push(code `${property.name}: ${propertySchema}`);
+        });
+    }
+    return singleEntryRecord(`schema`, code `\
+export const schema = { ${joinCode(this.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_schemaVariableStatement.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js

@@ -0,0 +1,15 @@
+import { singleEntryRecord } from "../singleEntryRecord.js";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration() {
+    if (!this.configuration.features.has("Object.toRdf")) {
+        return {};
+    }
+    const name = this.name.unsafeCoerce();
+    return singleEntryRecord(`toRdfResource`, code `\
+export const toRdfResource: ${this.reusables.snippets.ToRdfResourceFunction}<${name}> = (object, options) => {
+${joinCode(this.members
+        .map((member) => code `if (${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)) { return ${member.type.name.unsafeCoerce()}.toRdfResource(object, options); }`)
+        .concat(code `throw new Error("unrecognized type");`))}
+};`);
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js.map

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

@@ -7,18 +7,18 @@ export declare class ObjectType_DiscriminantProperty extends ObjectType_Abstract
     readonly filterProperty: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["filterProperty"];
     readonly graphqlField: ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["graphqlField"];
     readonly hashFunctionParameter: Code;
-    readonly jsonName = "@type";
-    readonly jsonSignature: Maybe<Code>;
     readonly kind = "Discriminant";
     readonly mutable = false;
     readonly recursive = false;
     readonly schema: Maybe<Code>;
     readonly schemaType: Maybe<Code>;
     readonly value: string;
-    constructor({ value, ...superParameters }: {
+    constructor({ configuration, value, ...superParameters }: {
         value: string;
-    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "type">);
+    } & Omit<ConstructorParameters<typeof ObjectType_AbstractProperty>[0], "name" | "type">);
+    get jsonName(): string;
     get jsonSchema(): ObjectType_AbstractProperty<ObjectType_DiscriminantProperty.Type>["jsonSchema"];
+    get jsonSignature(): Maybe<Code>;
     get values(): readonly string[];
     private get constValue();
     constructorInitializer(): Maybe<Code>;

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

@@ -14,27 +14,33 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
     filterProperty = Maybe.empty();
     graphqlField = Maybe.empty();
     hashFunctionParameter = code `readonly ${this.name}?: ${this.type.expression};`;
-    jsonName = "@type";
-    jsonSignature = Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
     kind = "Discriminant";
     mutable = false;
     recursive = false;
     schema = Maybe.empty();
     schemaType = Maybe.empty();
     value;
-    constructor({ value, ...superParameters }) {
+    constructor({ configuration, value, ...superParameters }) {
         super({
             ...superParameters,
+            configuration,
+            name: configuration.objectDiscriminantProperty.name,
             type: new ObjectType_DiscriminantProperty.Type(value),
         });
         this.value = value;
     }
+    get jsonName() {
+        return this.configuration.objectDiscriminantProperty.jsonName;
+    }
     get jsonSchema() {
         return Maybe.of({
             key: this.jsonName,
             schema: code `${this.reusables.imports.z}.literal(${literalOf(this.value)})`,
         });
     }
+    get jsonSignature() {
+        return Maybe.of(code `readonly "${this.jsonName}": ${this.type.expression}`);
+    }
     get values() {
         return [this.value];
     }
@@ -75,9 +81,15 @@ export class ObjectType_DiscriminantProperty extends ObjectType_AbstractProperty
         return Maybe.empty();
     }
 }
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "jsonName", null);
 __decorate([
     Memoize()
 ], ObjectType_DiscriminantProperty.prototype, "jsonSchema", null);
+__decorate([
+    Memoize()
+], ObjectType_DiscriminantProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
 ], ObjectType_DiscriminantProperty.prototype, "values", null);

package/package.json

@@ -1,15 +1,15 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.59",
+    "@shaclmate/shacl-ast": "4.0.61",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
     "@rdfjs/term-set": "~2.0.3",
     "@rdfjs/types": "~2.0.1",
-    "@rdfx/data-factory": "0.0.29",
-    "@rdfx/literal": "0.0.29",
-    "@rdfx/resource": "0.0.29",
-    "@rdfx/string": "0.0.29",
+    "@rdfx/data-factory": "0.0.30",
+    "@rdfx/literal": "0.0.30",
+    "@rdfx/resource": "0.0.30",
+    "@rdfx/string": "0.0.30",
     "@sindresorhus/base62": "~0.1.0",
     "@tpluscode/rdf-ns-builders": "~4.3.0",
     "@types/rdfjs__dataset": "~2.0.7",
@@ -22,12 +22,13 @@
     "purify-ts": "~2.1.4",
     "reserved-identifiers": "~1.0.0",
     "ts-invariant": "~0.10.3",
+    "ts-log": "~3.0.2",
     "ts-poet": "~6.12.0",
     "typescript-memoize": "~1.1.1"
   },
   "devDependencies": {
-    "@types/n3": "~1.26.0",
-    "n3": "~1.26.0"
+    "@rdfx/fs": "0.0.30",
+    "@rdfx/serializers": "0.0.30"
   },
   "files": [
     "dist/Compiler.d.ts",
@@ -238,6 +239,56 @@
     "dist/generators/ts/_AbstractType/AbstractType_JsType.js",
     "dist/generators/ts/_AbstractType/AbstractType_JsonType.d.ts",
     "dist/generators/ts/_AbstractType/AbstractType_JsonType.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_equalsFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_filterTypeExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromJsonFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromJsonFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_fromRdfResourceValuesFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_hashFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_hashFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inferDiscriminant.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inferDiscriminant.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inlineExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_inlineExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonSchemaExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonSchemaExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonTypeLiteral.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_jsonTypeLiteral.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_schemaTypeExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_schemaTypeExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toJsonFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toJsonFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toRdfResourceValuesFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toStringFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_toStringFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlConstructTriplesFunctionExpression.js",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.d.ts",
+    "dist/generators/ts/_DiscriminatedUnionType/DiscriminatedUnionType_valueSparqlWherePatternsFunctionExpression.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_identifierTypeDeclarations.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_isTypeFunctionDeclaration.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaVariableStatement.js",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.d.ts",
+    "dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.js",
     "dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.d.ts",
     "dist/generators/ts/_ObjectType/ObjectType_AbstractProperty.js",
     "dist/generators/ts/_ObjectType/ObjectType_DiscriminantProperty.d.ts",
@@ -670,5 +721,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.59"
+  "version": "4.0.61"
 }