@shaclmate/compiler 4.0.49 → 4.0.50

package/dist/generators/ts/ObjectUnionType.js

@@ -1,223 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { PropertyPath } from "@rdfx/resource";
-import { pascalCase } from "change-case";
-import { Memoize } from "typescript-memoize";
-import { ObjectType_objectSetMethodNames } from "./_ObjectType/ObjectType_objectSetMethodNames.js";
-import { ObjectType_sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryFunctionDeclaration.js";
-import { ObjectType_sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/ObjectType_sparqlConstructQueryStringFunctionDeclaration.js";
-import { singleEntryRecord } from "./singleEntryRecord.js";
-import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
-import { UnionType } from "./UnionType.js";
-export class ObjectUnionType extends UnionType {
-    kind = "ObjectUnion";
-    get identifierTypeAlias() {
-        return this.name.map((name) => code `${name}.Identifier`).unsafeCoerce();
-    }
-    get objectSetMethodNames() {
-        return this.name
-            .map((name) => ObjectType_objectSetMethodNames.call({
-            name,
-            configuration: this.configuration,
-        }))
-            .unsafeCoerce();
-    }
-    get schema() {
-        return this.name
-            .map((name) => code `${name}.schema`)
-            .orDefault(super.schema);
-    }
-    get schemaType() {
-        return this.name
-            .map(() => code `typeof ${this.schema}`)
-            .orDefault(super.schemaType);
-    }
-    get staticModuleDeclarations() {
-        const name = this.name.unsafeCoerce();
-        return {
-            ...super.staticModuleDeclarations,
-            ...this.identifierTypeDeclarations,
-            ...this.focusSparqlConstructTriplesFunctionDeclaration,
-            ...this.focusSparqlWherePatternsFunctionDeclaration,
-            ...this.fromRdfResourceFunctionDeclaration,
-            ...this.graphqlTypeVariableStatement,
-            ...this.isTypeFunctionDeclaration,
-            ...this.schemaVariableStatement,
-            ...(this.configuration.features.has("Object.SPARQL")
-                ? {
-                    ...singleEntryRecord("sparqlConstructQuery", ObjectType_sparqlConstructQueryFunctionDeclaration.call({
-                        name,
-                        configuration: this.configuration,
-                        filterType: this.filterType,
-                        reusables: this.reusables,
-                    })),
-                    ...singleEntryRecord("sparqlConstructQueryString", ObjectType_sparqlConstructQueryStringFunctionDeclaration.call({
-                        name,
-                        configuration: this.configuration,
-                        filterType: this.filterType,
-                        reusables: this.reusables,
-                    })),
-                }
-                : {}),
-            ...this.toRdfResourceFunctionDeclaration,
-        };
-    }
-    get 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: ", " })}];
-}`);
-    }
-    get 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;`,
-        ])}
-}`);
-    }
-    get 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)};`);
-    }
-    get 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: ", " })}]`,
-        }});`);
-    }
-    get 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};
-}`);
-    }
-    get 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: " || " })};
-    }`);
-    }
-    get 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(super.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`);
-    }
-    get 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");`))}
-};`);
-    }
-}
-__decorate([
-    Memoize()
-], ObjectUnionType.prototype, "identifierTypeAlias", null);
-__decorate([
-    Memoize()
-], ObjectUnionType.prototype, "objectSetMethodNames", null);
-__decorate([
-    Memoize()
-], ObjectUnionType.prototype, "schema", null);
-__decorate([
-    Memoize()
-], ObjectUnionType.prototype, "schemaType", null);
-//# sourceMappingURL=ObjectUnionType.js.map

package/dist/generators/ts/OptionType.d.ts

@@ -1,39 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractContainerType } from "./AbstractContainerType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class OptionType<ItemTypeT extends OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
-    readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
-    readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
-    readonly jsTypes: readonly [{
-        readonly instanceof: "Maybe";
-        readonly typeof: "object";
-    }];
-    readonly kind = "Option";
-    get conversionFunction(): Maybe<AbstractContainerType.ConversionFunction>;
-    get equalsFunction(): Code;
-    get expression(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get fromRdfResourceValuesFunction(): Code;
-    get graphqlType(): AbstractContainerType.GraphqlType;
-    get hashFunction(): Code;
-    get mutable(): boolean;
-    get schemaType(): Code;
-    get toRdfResourceValueTypes(): AbstractContainerType<ItemTypeT>["toRdfResourceValueTypes"];
-    get validationFunction(): Maybe<Code>;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression(parameters: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractContainerType<ItemTypeT>["jsonType"]>[0]): AbstractContainerType.JsonType;
-    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toStringExpression"]>[0]): Code;
-}
-export declare namespace OptionType {
-    type ItemType = AbstractContainerType.ItemType;
-    const isItemType: typeof AbstractContainerType.isItemType;
-}
-//# sourceMappingURL=OptionType.d.ts.map

package/dist/generators/ts/OptionType.js

@@ -1,157 +0,0 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { AbstractContainerType } from "./AbstractContainerType.js";
-import { codeEquals } from "./codeEquals.js";
-import { code } from "./ts-poet-wrapper.js";
-export class OptionType extends AbstractContainerType {
-    discriminantProperty = Maybe.empty();
-    graphqlArgs = Maybe.empty();
-    jsTypes = [
-        { instanceof: "Maybe", typeof: "object" },
-    ];
-    kind = "Option";
-    get conversionFunction() {
-        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
-        return Maybe.of({
-            code: code `${this.reusables.snippets.convertToMaybe}(${itemConversionFunction.code})`,
-            sourceTypes: itemConversionFunction.sourceTypes.concat({
-                expression: this.expression,
-                jsType: { instanceof: "Maybe", typeof: "object" },
-            }, {
-                expression: code `undefined`,
-                jsType: { typeof: "undefined" },
-            }),
-        });
-    }
-    get equalsFunction() {
-        return code `((left, right) => ${this.reusables.snippets.maybeEquals}(left, right, ${this.itemType.equalsFunction}))`;
-    }
-    get expression() {
-        return code `${this.reusables.imports.Maybe}<${this.itemType.expression}>`;
-    }
-    get filterFunction() {
-        return code `${this.reusables.snippets.filterMaybe}<${this.itemType.expression}, ${this.itemType.filterType}>(${this.itemType.filterFunction})`;
-    }
-    get filterType() {
-        return code `${this.reusables.snippets.MaybeFilter}<${this.itemType.filterType}>`;
-    }
-    get fromRdfResourceValuesFunction() {
-        return code `${this.reusables.snippets.maybeFromRdfResourceValues}<${this.itemType.expression}, ${this.itemType.schemaType}>(${this.itemType.fromRdfResourceValuesFunction})`;
-    }
-    get graphqlType() {
-        invariant(!this.itemType.graphqlType.nullable);
-        return new AbstractContainerType.GraphqlType(this.itemType.graphqlType.expression, this.reusables, {
-            nullable: true,
-        });
-    }
-    get hashFunction() {
-        return code `${this.reusables.snippets.hashMaybe}(${this.itemType.hashFunction})`;
-    }
-    get mutable() {
-        return this.itemType.mutable;
-    }
-    get schemaType() {
-        return code `${this.reusables.snippets.MaybeSchema}<${this.itemType.schemaType}>`;
-    }
-    get toRdfResourceValueTypes() {
-        return this.itemType.toRdfResourceValueTypes;
-    }
-    get validationFunction() {
-        return Maybe.of(code `${this.reusables.snippets.validateMaybe}(${this.itemType.validationFunction.orDefault(this.itemValidationFunctionDefault)})`);
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return code `${this.reusables.snippets.maybeSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.maybeSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
-    }
-    fromJsonExpression({ variables, }) {
-        const expression = code `${this.reusables.imports.Maybe}.fromNullable(${variables.value})`;
-        const itemFromJsonExpression = this.itemType.fromJsonExpression({
-            variables: { value: code `item` },
-        });
-        return code `${expression}.map(item => (${itemFromJsonExpression}).map(${this.reusables.imports.Maybe}.of)).orDefault(${this.reusables.imports.Either}.of(${this.reusables.imports.Maybe}.empty()))`;
-    }
-    graphqlResolveExpression(parameters) {
-        return code `${this.itemType.graphqlResolveExpression(parameters)}.extractNullable()`;
-    }
-    jsonSchema(parameters) {
-        return code `${this.itemType.jsonSchema(parameters)}.optional()`;
-    }
-    jsonType(parameters) {
-        const itemTypeJsonType = this.itemType.jsonType(parameters);
-        invariant(!itemTypeJsonType.optional);
-        return new AbstractContainerType.JsonType(itemTypeJsonType.expression, {
-            optional: true,
-        });
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.itemType.jsonUiSchemaElement(parameters);
-    }
-    toJsonExpression({ variables, }) {
-        return code `${variables.value}.map(item => (${this.itemType.toJsonExpression({ variables: { value: code `item` } })})).extract()`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const itemTypeToRdfExpression = this.itemType.toRdfResourceValuesExpression({
-            variables: { ...variables, value: code `value` },
-        });
-        let toRdfExpression = code `${variables.value}.toList()`;
-        if (!codeEquals(itemTypeToRdfExpression, code `[value]`)) {
-            toRdfExpression = code `${toRdfExpression}.flatMap((value) => ${itemTypeToRdfExpression})`;
-        }
-        return toRdfExpression;
-    }
-    toStringExpression({ variables, }) {
-        return code `${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })})).extract()`;
-    }
-}
-__decorate([
-    Memoize()
-], OptionType.prototype, "conversionFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "expression", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "fromRdfResourceValuesFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "graphqlType", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "validationFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], OptionType.prototype, "jsonType", null);
-(function (OptionType) {
-    OptionType.isItemType = AbstractContainerType.isItemType;
-})(OptionType || (OptionType = {}));
-//# sourceMappingURL=OptionType.js.map

package/dist/generators/ts/RdfjsDatasetObjectSetType.d.ts

@@ -1,6 +0,0 @@
-import { AbstractObjectSetType } from "./AbstractObjectSetType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class RdfjsDatasetObjectSetType extends AbstractObjectSetType {
-    get declaration(): Code;
-}
-//# sourceMappingURL=RdfjsDatasetObjectSetType.d.ts.map