@shaclmate/compiler 4.0.39 → 4.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.39",
+    "@shaclmate/shacl-ast": "4.0.41",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
     "@rdfjs/term-map": "~2.0.2",
@@ -16,12 +16,10 @@
     "@types/rdfjs__prefix-map": "~0.1.5",
     "@types/rdfjs__term-map": "~2.0.10",
     "@types/rdfjs__term-set": "~2.0.9",
-    "@types/toposort": "2.0.7",
     "change-case": "~5.4.4",
     "plur": "~5.1.0",
     "purify-ts": "~2.1.4",
     "reserved-identifiers": "~1.0.0",
-    "toposort": "2.0.2",
     "ts-invariant": "~0.10.3",
     "ts-poet": "~6.12.0",
     "typescript-memoize": "~1.1.1"
@@ -41,8 +39,8 @@
     "dist/generators/*.js",
     "dist/generators/ts/*.d.ts",
     "dist/generators/ts/*.js",
-    "dist/generators/ts/_NamedObjectType/*.d.ts",
-    "dist/generators/ts/_NamedObjectType/*.js",
+    "dist/generators/ts/_ObjectType/*.d.ts",
+    "dist/generators/ts/_ObjectType/*.js",
     "dist/generators/ts/_snippets/*.d.ts",
     "dist/generators/ts/_snippets/*.js",
     "dist/input/*.d.ts",
@@ -68,5 +66,5 @@
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.39"
+  "version": "4.0.41"
 }

package/dist/generators/ts/AbstractNamedUnionType.d.ts

@@ -1,30 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractType } from "./AbstractType.js";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractNamedUnionType<MemberTypeT extends Type> extends AbstractUnionType<MemberTypeT> {
-    protected readonly _name: string;
-    constructor({ name, ...superParameters }: {
-        name: string;
-    } & ConstructorParameters<typeof AbstractUnionType<MemberTypeT>>[0]);
-    get declaration(): Maybe<Code>;
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get hashFunction(): Code;
-    get jsonSchemaFunctionDeclaration(): Code;
-    get jsonTypeAliasDeclaration(): Code;
-    get name(): string;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get staticModuleDeclarations(): Record<string, Code>;
-    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
-    jsonSchema({ context, }: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-}
-//# sourceMappingURL=AbstractNamedUnionType.d.ts.map

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -1,190 +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 { Memoize } from "typescript-memoize";
-import { AbstractType } from "./AbstractType.js";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import { code, def, joinCode } from "./ts-poet-wrapper.js";
-export class AbstractNamedUnionType extends AbstractUnionType {
-    _name;
-    constructor({ name, ...superParameters }) {
-        super(superParameters);
-        this._name = name;
-    }
-    get declaration() {
-        const declarations = [];
-        if (this.configuration.features.has("Object.type")) {
-            declarations.push(code `export type ${def(this._name)} = ${this.inlineName};`);
-        }
-        const staticModuleDeclarations = Object.entries(this.staticModuleDeclarations);
-        if (staticModuleDeclarations.length > 0) {
-            declarations.push(code `\
-export namespace ${def(this.name)} {
-${joinCode(staticModuleDeclarations
-                .sort((left, right) => left[0].localeCompare(right[0]))
-                .map((_) => _[1]), { on: "\n\n" })}
-}`);
-        }
-        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
-    }
-    get equalsFunction() {
-        return code `${this.name}.equals`;
-    }
-    get filterFunction() {
-        return code `${this.name}.filter`;
-    }
-    get filterType() {
-        return code `${this.name}.Filter`;
-    }
-    get hashFunction() {
-        return code `${this.name}.hash`;
-    }
-    get jsonSchemaFunctionDeclaration() {
-        const meta = {
-        // id: this.name,
-        };
-        this.comment.ifJust((description) => {
-            meta["description"] = description;
-        });
-        this.label.ifJust((label) => {
-            meta["title"] = label;
-        });
-        return code `export const schema = () => ${this.inlineJsonSchema}.meta(${meta});`;
-    }
-    get jsonTypeAliasDeclaration() {
-        return code `export type Json = ${this.inlineJsonType.name}`;
-    }
-    get name() {
-        return this._name;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return code `${this.name}.valueSparqlConstructTriples`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.name}.valueSparqlWherePatterns`;
-    }
-    get staticModuleDeclarations() {
-        const staticModuleDeclarations = {};
-        if (this.configuration.features.has("Object.equals")) {
-            staticModuleDeclarations[`equals`] =
-                code `export const equals = ${this.inlineEqualsFunction};`;
-        }
-        if (this.configuration.features.has("Object.filter")) {
-            staticModuleDeclarations[`Filter`] =
-                code `export type Filter = ${this.inlineFilterType};`;
-            staticModuleDeclarations[`filter`] =
-                code `export const filter = ${this.inlineFilterFunction};`;
-        }
-        if (this.configuration.features.has("Object.hash")) {
-            staticModuleDeclarations[`hash`] =
-                code `export const hash = ${this.inlineHashFunction};`;
-        }
-        if (this.configuration.features.has("Object.JSON.type")) {
-            staticModuleDeclarations[`Json.type`] =
-                code `${this.jsonTypeAliasDeclaration}`;
-        }
-        if (this.configuration.features.has("Object.JSON.schema")) {
-            staticModuleDeclarations[`Json.namespace`] = code `\
-export namespace Json {
-  ${this.jsonSchemaFunctionDeclaration}
-
-  export function parse(json: unknown): ${this.reusables.imports.Either}<Error, Json> {
-    const jsonSafeParseResult = schema().safeParse(json);
-    if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
-    return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
-  }
-}`;
-        }
-        if (this.configuration.features.has("Object.fromJson")) {
-            staticModuleDeclarations[`fromJson`] =
-                code `export const fromJson = ${this.inlineFromJsonFunction};`;
-        }
-        if (this.configuration.features.has("Object.fromRdf")) {
-            staticModuleDeclarations[`fromRdfResourceValues`] =
-                code `export const fromRdfResourceValues: ${this.reusables.snippets.FromRdfResourceValuesFunction}<${this.name}> = ${this.inlineFromRdfResourceValuesFunction};`;
-        }
-        if (this.configuration.features.has("Object.toJson")) {
-            staticModuleDeclarations[`toJson`] =
-                code `export const toJson = ${this.inlineToJsonFunction};`;
-        }
-        if (this.configuration.features.has("Object.toRdf")) {
-            staticModuleDeclarations[`toRdfResourceValues`] =
-                code `export const toRdfResourceValues = ${this.inlineToRdfResourceValuesFunction};`;
-        }
-        if (this.configuration.features.has("Object.SPARQL")) {
-            staticModuleDeclarations[`valueSparqlConstructTriples`] =
-                code `export const valueSparqlConstructTriples: ${this.reusables.snippets.ValueSparqlConstructTriplesFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlConstructTriplesFunction};`;
-            staticModuleDeclarations[`valueSparqlWherePatterns`] =
-                code `export const valueSparqlWherePatterns: ${this.reusables.snippets.ValueSparqlWherePatternsFunction}<${this.filterType}, ${this.schemaType}> = ${this.inlineValueSparqlWherePatternsFunction};`;
-        }
-        if (this.configuration.features.has("Object.toString")) {
-            const syntheticNamePrefix = this.configuration.syntheticNamePrefix;
-            staticModuleDeclarations[`${syntheticNamePrefix}toString`] =
-                code `export const ${syntheticNamePrefix}toString = ${this.inlineToStringFunction};`;
-        }
-        return staticModuleDeclarations;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.name}.fromJson(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...fromRdfResourceValuesOptionsTemp } = variables;
-        const fromRdfResourceValuesOptions = fromRdfResourceValuesOptionsTemp;
-        if (!this.configuration.features.has("ObjectSet")) {
-            delete fromRdfResourceValuesOptions["objectSet"];
-        }
-        return code `${this.name}.fromRdfResourceValues(${resourceValuesVariable}, ${fromRdfResourceValuesOptions})`;
-    }
-    jsonSchema({ context, }) {
-        const expression = code `${this.name}.Json.schema()`;
-        if (context === "property" && this.recursive) {
-            return code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${this.name}.Json> => ${expression})`;
-        }
-        return expression;
-    }
-    jsonType() {
-        return new AbstractType.JsonType(`${this.name}.Json`);
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.name}.toJson(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.name}.toRdfResourceValues(${valueVariable}, ${otherVariables})`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.name}.${this.configuration.syntheticNamePrefix}toString(${variables.value})`;
-    }
-}
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "declaration", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "name", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], AbstractNamedUnionType.prototype, "jsonType", null);
-//# sourceMappingURL=AbstractNamedUnionType.js.map

package/dist/generators/ts/AnonymousUnionType.d.ts

@@ -1,27 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { AbstractType } from "./AbstractType.js";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class AnonymousUnionType extends AbstractUnionType<Type> {
-    readonly declaration: Maybe<Code>;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly kind = "AnonymousUnion";
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get graphqlType(): AbstractType.GraphqlType;
-    get hashFunction(): Code;
-    get name(): Code;
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
-    fromRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["fromRdfResourceValuesExpression"]>[0]): Code;
-    graphqlResolveExpression(_parameters: Parameters<AbstractType["graphqlResolveExpression"]>[0]): Code;
-    jsonSchema(_parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(): AbstractType.JsonType;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-}
-//# sourceMappingURL=AnonymousUnionType.d.ts.map

package/dist/generators/ts/AnonymousUnionType.js

@@ -1,59 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractUnionType } from "./AbstractUnionType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class AnonymousUnionType extends AbstractUnionType {
-    declaration = Maybe.empty();
-    graphqlArgs = Maybe.empty();
-    kind = "AnonymousUnion";
-    get equalsFunction() {
-        return this.inlineEqualsFunction;
-    }
-    get filterFunction() {
-        return this.inlineFilterFunction;
-    }
-    get filterType() {
-        return this.inlineFilterType;
-    }
-    get graphqlType() {
-        throw new Error("GraphQL doesn't support scalar unions");
-    }
-    get hashFunction() {
-        return this.inlineHashFunction;
-    }
-    get name() {
-        return this.inlineName;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return this.inlineValueSparqlConstructTriplesFunction;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return this.inlineValueSparqlWherePatternsFunction;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.inlineFromJsonFunction}(${variables.value})`;
-    }
-    fromRdfResourceValuesExpression({ variables, }) {
-        const { resourceValues: resourceValuesVariable, ...otherVariables } = variables;
-        return code `${this.inlineFromRdfResourceValuesFunction}(${resourceValuesVariable}, ${otherVariables})`;
-    }
-    graphqlResolveExpression(_parameters) {
-        throw new Error("not implemented");
-    }
-    jsonSchema(_parameters) {
-        return this.inlineJsonSchema;
-    }
-    jsonType() {
-        return this.inlineJsonType;
-    }
-    toJsonExpression({ variables, }) {
-        return code `${this.inlineToJsonFunction}(${variables.value})`;
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        const { value: valueVariable, ...otherVariables } = variables;
-        return code `${this.inlineToRdfResourceValuesFunction}(${valueVariable}, ${otherVariables})`;
-    }
-    toStringExpression({ variables, }) {
-        return code `${this.inlineToStringFunction}(${variables.value})`;
-    }
-}
-//# sourceMappingURL=AnonymousUnionType.js.map