@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/ts/ZodGenerator.d.ts

@@ -1,11 +0,0 @@
-import type { Logger } from "ts-log";
-import type * as ast from "../../ast/index.js";
-import type { Generator } from "../Generator.js";
-export declare class ZodGenerator implements Generator {
-    private readonly logger;
-    constructor({ logger }: {
-        logger: Logger;
-    });
-    generate(ast_: ast.Ast): string;
-}
-//# sourceMappingURL=ZodGenerator.d.ts.map

package/dist/generators/ts/ZodGenerator.js

@@ -1,60 +0,0 @@
-import { ObjectType_jsonSchemaExpression } from "./_ObjectType/ObjectType_jsonSchemaExpression.js";
-import { ObjectType_jsonTypeExpression } from "./_ObjectType/ObjectType_jsonTypeExpression.js";
-import { Reusables } from "./Reusables.js";
-import { TsGenerator } from "./TsGenerator.js";
-import { TypeFactory } from "./TypeFactory.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
-export class ZodGenerator {
-    logger;
-    constructor({ logger }) {
-        this.logger = logger;
-    }
-    generate(ast_) {
-        const configuration = TsGenerator.Configuration.finalize(ast_, TsGenerator.Configuration.default_);
-        const reusables = new Reusables({ configuration, logger: this.logger });
-        const typeFactory = new TypeFactory({
-            configuration,
-            logger: this.logger,
-            reusables,
-        });
-        const declarations = [];
-        for (const astNamedType of ast_.namedTypes) {
-            switch (astNamedType.kind) {
-                case "Struct": {
-                    const tsNamedObjectType = typeFactory.createObjectType(astNamedType);
-                    declarations.push(code `\
-export namespace ${tsNamedObjectType.name.unsafeCoerce()} {
-  export type Json = ${ObjectType_jsonTypeExpression.call(tsNamedObjectType)};
-
-  export namespace Json {
-    export function schema() {
-      return ${ObjectType_jsonSchemaExpression.call(tsNamedObjectType)};
-    }
-  }
-}`);
-                    break;
-                }
-                case "Union": {
-                    const tsNamedUnionType = typeFactory.createUnionType(astNamedType);
-                    declarations.push(code `\
-export namespace ${tsNamedUnionType.name.unsafeCoerce()} {
-  ${tsNamedUnionType.jsonTypeAliasDeclaration}
-  export namespace Json {
-    ${tsNamedUnionType.jsonSchemaFunctionDeclaration}
-  }
-}`);
-                    break;
-                }
-                default: {
-                    const type = typeFactory.createType(astNamedType);
-                    type.declaration.ifJust((declaration) => {
-                        declarations.push(declaration);
-                    });
-                }
-            }
-        }
-        declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
-        return joinCode(declarations, { on: "\n\n" }).toString({});
-    }
-}
-//# sourceMappingURL=ZodGenerator.js.map

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

@@ -1,220 +0,0 @@
-import type { Maybe } from "purify-ts";
-import type { Logger } from "ts-log";
-import type { Reusables } from "../Reusables.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import type { TsGenerator } from "../TsGenerator.js";
-import type { Type } from "../Type.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare abstract class AbstractProperty<TypeT extends Pick<Type, "expression" | "filterFunction" | "mutable" | "schema">> {
-    protected readonly configuration: TsGenerator.Configuration;
-    protected readonly logger: Logger;
-    protected readonly objectType: {
-        readonly name: Maybe<string>;
-    };
-    protected readonly reusables: Reusables;
-    /**
-     * Optional parameter to include in the parameters object of constructor function.
-     */
-    abstract readonly constructorParameter: Maybe<{
-        readonly hasQuestionToken: boolean;
-        readonly signature: Code;
-    }>;
-    /**
-     * Property declaration to include in the type declaration of the ObjectType.
-     */
-    abstract readonly declaration: Code;
-    /**
-     * Optional property in the ObjectType's filter.
-     */
-    abstract readonly filterProperty: Maybe<{
-        readonly name: string;
-        readonly type: Code;
-    }>;
-    /**
-     * GraphQL.js field definition.
-     */
-    abstract readonly graphqlField: Maybe<{
-        args: Maybe<Record<string, {
-            type: Code;
-        }>>;
-        description: Maybe<string>;
-        name: string;
-        resolve: Code;
-        type: Code;
-    }>;
-    /**
-     * Parameter to include in the expression of the ObjectType passed to its hash function.
-     *
-     * Only specified if different from declaration.
-     */
-    abstract readonly hashFunctionParameter: Code;
-    /**
-     * zod object key: schema.
-     */
-    abstract readonly jsonSchema: Maybe<{
-        readonly key: string;
-        readonly schema: Code;
-    }>;
-    /**
-     * Signature of the property when serialized to JSON.
-     */
-    abstract readonly jsonSignature: Maybe<Code>;
-    /**
-     * Property type discriminant e.g., "Shacl".
-     */
-    abstract readonly kind: string;
-    /**
-     * Is the property reassignable?
-     */
-    abstract readonly mutable: boolean;
-    /**
-     * TypeScript identifier-safe name of the property.
-     */
-    readonly name: string;
-    /**
-     * Is the property's type the ObjectType or does its type indirectly reference the ObjectType?
-     */
-    abstract readonly recursive: boolean;
-    /**
-     * TypeScript object describing this type, for runtime use.
-     */
-    abstract readonly schema: Maybe<Code>;
-    /**
-     * TypeScript type describing .schema.
-     */
-    abstract readonly schemaType: Maybe<Code>;
-    /**
-     * Property type
-  .   */
-    readonly type: TypeT;
-    constructor({ configuration, logger, name, objectType, reusables, type, }: {
-        configuration: TsGenerator.Configuration;
-        logger: Logger;
-        name: string;
-        objectType: {
-            readonly name: Maybe<string>;
-        };
-        reusables: Reusables;
-        type: TypeT;
-    });
-    /**
-     * Expression to access the value of this property on an object instance. May evaluate a thunk.
-     */
-    accessExpression({ variables }: {
-        variables: {
-            object: Code;
-        };
-    }): Code;
-    /**
-     * Initializer (name: value) from a constructor parameter.
-     */
-    abstract constructorInitializer(parameters: {
-        variables: {
-            parameters: Code;
-        };
-    }): Maybe<Code>;
-    /**
-     * Initializer (name: value) from a JSON object.
-     */
-    abstract fromJsonInitializer(parameters: {
-        variables: {
-            jsonObject: Code;
-        };
-    }): Maybe<Code>;
-    /**
-     * Initializer (name: value) from a rdfjsResource.Resource to a Either<Error, this property type>.
-     */
-    abstract fromRdfResourceValuesInitializer(parameters: {
-        variables: {
-            context: Code;
-            focusResource: Code;
-            graph: Code;
-            objectSet: Code;
-            preferredLanguages: Code;
-        };
-    }): Maybe<Code>;
-    /**
-     * Statements to hash this property using a hasher instance.
-     */
-    abstract hashStatements(parameters: {
-        variables: {
-            hasher: Code;
-            value: Code;
-        };
-    }): readonly Code[];
-    /**
-     * Element object (usually a control https://jsonforms.io/docs/uischema/controls) for a JSON Forms UI schema.
-     */
-    abstract jsonUiSchemaElement(parameters: {
-        variables: {
-            scopePrefix: Code;
-        };
-    }): Maybe<Code>;
-    /**
-     * SPARQL.js CONSTRUCT template triples for this property.
-     *
-     * Parameters:
-     *   variables: runtime variables
-     *     - filter: an instance of the object's filterType or undefined
-     *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
-     *     - variablePrefix: prefix to use for new SPARQL variables
-     *
-     * Returns a (runtime) array of sparqljs.Triple.
-     */
-    abstract sparqlConstructTriplesExpression(parameters: {
-        variables: {
-            filter: Code;
-            focusIdentifier: Code;
-            variablePrefix: Code;
-        };
-    }): Maybe<Code>;
-    /**
-     * SPARQL where patterns for this property.
-     *
-     * Parameters:
-     *   variables: (at runtime)
-     *     - filter: an instance of the object's filterType or undefined
-     *     - focusIdentifier: identifier (rdfjs.NamedNode or rdfjs.Variable) of the object that is the focus of the patterns
-     *     - preferredLanguages: array of preferred language code (strings)
-     *     - variablePrefix: prefix to use for new SPARQL variables
-     *
-     * Returns:
-     *   - condition: optional runtime condition to evaluate in an if statement before including the patterns
-     *   - patterns: runtime array of SparqlPattern's.
-     */
-    abstract sparqlWherePatternsExpression(parameters: {
-        variables: {
-            filter: Code;
-            focusIdentifier: Code;
-            preferredLanguages: Code;
-            variablePrefix: Code;
-        };
-    }): Maybe<{
-        condition?: Code;
-        patterns: Code;
-    }>;
-    /**
-     * Initializer (name: value) to JSON.
-     */
-    abstract toJsonInitializer(parameters: {
-        variables: {
-            value: Code;
-        };
-    }): Maybe<Code>;
-    /**
-     * Statements to serialize this property to an RDF resource.
-     */
-    abstract toRdfRdfResourceValuesStatements(parameters: {
-        variables: Omit<Parameters<Type["toRdfResourceValuesExpression"]>[0]["variables"], "propertyPath">;
-    }): readonly Code[];
-    /**
-     * Initializer (name: value) to serialize this property to a human-readable string (toString).
-     */
-    abstract toStringInitializer(parameters: {
-        variables: {
-            value: Code;
-        };
-    }): Maybe<Code>;
-    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
-}
-//# sourceMappingURL=AbstractProperty.d.ts.map

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

@@ -1,37 +0,0 @@
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { code } from "../ts-poet-wrapper.js";
-export class AbstractProperty {
-    configuration;
-    logger;
-    objectType;
-    reusables;
-    /**
-     * TypeScript identifier-safe name of the property.
-     */
-    name;
-    /**
-     * Property type
-  .   */
-    type;
-    constructor({ configuration, logger, name, objectType, reusables, type, }) {
-        this.configuration = configuration;
-        this.logger = logger;
-        this.name = name;
-        this.objectType = objectType;
-        this.reusables = reusables;
-        this.type = type;
-        this.rdfjsTermExpression = rdfjsTermExpression.bind({
-            imports: this.reusables.imports,
-            logger: this.logger,
-            snippets: this.reusables.snippets,
-        });
-    }
-    /**
-     * Expression to access the value of this property on an object instance. May evaluate a thunk.
-     */
-    accessExpression({ variables }) {
-        return code `${variables.object}.${this.name}`;
-    }
-    rdfjsTermExpression;
-}
-//# sourceMappingURL=AbstractProperty.js.map

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

@@ -1,45 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type Code } from "../ts-poet-wrapper.js";
-import { AbstractProperty } from "./AbstractProperty.js";
-export declare class DiscriminantProperty extends AbstractProperty<DiscriminantProperty.Type> {
-    readonly constructorParameter: AbstractProperty<DiscriminantProperty.Type>["constructorParameter"];
-    readonly declaration: Code;
-    readonly filterProperty: AbstractProperty<DiscriminantProperty.Type>["filterProperty"];
-    readonly graphqlField: AbstractProperty<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 }: {
-        value: string;
-    } & Omit<ConstructorParameters<typeof AbstractProperty>[0], "type">);
-    get jsonSchema(): AbstractProperty<DiscriminantProperty.Type>["jsonSchema"];
-    get values(): readonly string[];
-    private get constValue();
-    constructorInitializer(): Maybe<Code>;
-    fromJsonInitializer(): Maybe<Code>;
-    fromRdfResourceValuesInitializer(): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<DiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
-    toJsonInitializer({ variables, }: Parameters<AbstractProperty<DiscriminantProperty.Type>["toJsonInitializer"]>[0]): Maybe<Code>;
-    toRdfRdfResourceValuesStatements(): readonly Code[];
-    toStringInitializer(): Maybe<Code>;
-}
-export declare namespace DiscriminantProperty {
-    class Type {
-        readonly value: string;
-        readonly filterFunction: Code;
-        readonly mutable = false;
-        constructor(value: string);
-        get expression(): Code;
-        get schema(): Code;
-    }
-}
-//# sourceMappingURL=DiscriminantProperty.d.ts.map

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

@@ -1,104 +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 { code, literalOf } from "../ts-poet-wrapper.js";
-import { AbstractProperty } from "./AbstractProperty.js";
-export class DiscriminantProperty extends AbstractProperty {
-    constructorParameter = Maybe.empty();
-    declaration = code `readonly ${this.name}: ${this.type.expression};`;
-    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 }) {
-        super({ ...superParameters, type: new DiscriminantProperty.Type(value) });
-        this.value = value;
-    }
-    get jsonSchema() {
-        return Maybe.of({
-            key: this.jsonName,
-            schema: code `${this.reusables.imports.z}.literal(${literalOf(this.value)})`,
-        });
-    }
-    get values() {
-        return [this.value];
-    }
-    get constValue() {
-        return code `${literalOf(this.value)} as const`;
-    }
-    constructorInitializer() {
-        return Maybe.empty();
-    }
-    fromJsonInitializer() {
-        return Maybe.empty();
-    }
-    fromRdfResourceValuesInitializer() {
-        return Maybe.empty();
-    }
-    hashStatements({ variables, }) {
-        return [
-            code `if (${variables.value}) { ${variables.hasher}.update(${variables.value}); }`,
-        ];
-    }
-    jsonUiSchemaElement({ variables, }) {
-        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.jsonName}\``;
-        return Maybe.of(code `{ rule: { condition: { schema: { const: ${this.constValue} }, scope: ${scope} }, effect: "HIDE" }, scope: ${scope}, type: "Control" }`);
-    }
-    sparqlConstructTriplesExpression() {
-        return Maybe.empty();
-    }
-    sparqlWherePatternsExpression() {
-        return Maybe.empty();
-    }
-    toJsonInitializer({ variables, }) {
-        return Maybe.of(code `"${this.jsonName}": ${variables.value}`);
-    }
-    toRdfRdfResourceValuesStatements() {
-        return [];
-    }
-    toStringInitializer() {
-        return Maybe.empty();
-    }
-}
-__decorate([
-    Memoize()
-], DiscriminantProperty.prototype, "jsonSchema", null);
-__decorate([
-    Memoize()
-], DiscriminantProperty.prototype, "values", null);
-(function (DiscriminantProperty) {
-    class Type {
-        value;
-        filterFunction = code `nonextant`;
-        mutable = false;
-        constructor(value) {
-            this.value = value;
-        }
-        get expression() {
-            return code `${literalOf(this.value)}`;
-        }
-        get schema() {
-            throw new Error("should never be called");
-        }
-    }
-    __decorate([
-        Memoize()
-    ], Type.prototype, "expression", null);
-    __decorate([
-        Memoize()
-    ], Type.prototype, "schema", null);
-    DiscriminantProperty.Type = Type;
-})(DiscriminantProperty || (DiscriminantProperty = {}));
-//# sourceMappingURL=DiscriminantProperty.js.map

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

@@ -1,43 +0,0 @@
-import { Maybe } from "purify-ts";
-import type { BlankNodeType } from "../BlankNodeType.js";
-import type { IdentifierType } from "../IdentifierType.js";
-import type { IriType } from "../IriType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-import { AbstractProperty } from "./AbstractProperty.js";
-export declare class IdentifierProperty extends AbstractProperty<BlankNodeType | IdentifierType | IriType> {
-    readonly kind = "Identifier";
-    readonly mutable = false;
-    readonly recursive = false;
-    get constructorParameter(): Maybe<{
-        hasQuestionToken: boolean;
-        signature: Code;
-    }>;
-    get declaration(): Code;
-    get filterProperty(): Maybe<{
-        name: string;
-        type: Code;
-    }>;
-    get graphqlField(): AbstractProperty<IdentifierType>["graphqlField"];
-    get hashFunctionParameter(): Code;
-    get jsonSchema(): AbstractProperty<IdentifierType>["jsonSchema"];
-    get jsonSignature(): Maybe<Code>;
-    get schema(): Maybe<Code>;
-    get schemaType(): Maybe<Code>;
-    private get typeExpression();
-    private get typeSchemaVariable();
-    accessExpression({ variables, }: Parameters<AbstractProperty<BlankNodeType | IdentifierType | IriType>["accessExpression"]>[0]): Code;
-    constructorInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["constructorInitializer"]>[0]): Maybe<Code>;
-    fromJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromJsonInitializer"]>[0]): Maybe<Code>;
-    fromRdfResourceValuesInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["fromRdfResourceValuesInitializer"]>[0]): Maybe<Code>;
-    hashStatements({ variables, }: Parameters<AbstractProperty<IdentifierType>["hashStatements"]>[0]): readonly Code[];
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<IdentifierType>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    sparqlConstructTriplesExpression(): Maybe<Code>;
-    sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<IdentifierType>["sparqlWherePatternsExpression"]>[0]): Maybe<{
-        condition: Code;
-        patterns: Code;
-    }>;
-    toJsonInitializer({ variables, }: Parameters<AbstractProperty<IdentifierType>["toJsonInitializer"]>[0]): Maybe<Code>;
-    toRdfRdfResourceValuesStatements(): readonly Code[];
-    toStringInitializer(parameters: Parameters<AbstractProperty<IdentifierType>["toStringInitializer"]>[0]): Maybe<Code>;
-}
-//# sourceMappingURL=IdentifierProperty.d.ts.map