@shaclmate/compiler 4.0.8 → 4.0.10

package/dist/ast/AbstractObjectCompoundType.js

@@ -1,180 +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 TermSet from "@rdfjs/term-set";
-import { Either, Maybe } from "purify-ts";
-import { Resource } from "rdfjs-resource";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { AbstractCompoundType } from "./AbstractCompoundType.js";
-import { BlankNodeType } from "./BlankNodeType.js";
-import { IdentifierType } from "./IdentifierType.js";
-import { IriType } from "./IriType.js";
-/**
- * Abstract base class for a compound of object types, such as an intersection or union.
- */
-export class AbstractObjectCompoundType extends AbstractCompoundType {
-    /**
-     * Should generated code derived from this type be visible outside its module?
-     *
-     * Defaults to true.
-     */
-    export;
-    /**
-     * Name of this type, from shaclmate:name.
-     */
-    name;
-    /**
-     * Identifier of the shape this ObjectType was derived from.
-     */
-    shapeIdentifier;
-    /**
-     * TypeScript features to generate.
-     */
-    #tsFeatures;
-    constructor({ export_, name, shapeIdentifier, tsFeatures, ...superParameters }) {
-        super(superParameters);
-        this.export = export_;
-        this.name = name;
-        this.shapeIdentifier = shapeIdentifier;
-        this.#tsFeatures = tsFeatures;
-    }
-    equals(other) {
-        // Don't recurse
-        return this.shapeIdentifier.equals(other.shapeIdentifier);
-    }
-    get identifierType() {
-        const memberIdentifierTypeNodeKinds = new Set();
-        const memberIdentifierTypesIn = new TermSet();
-        for (const memberType of this.memberTypes) {
-            for (const nodeKind of memberType.identifierType.nodeKinds) {
-                memberIdentifierTypeNodeKinds.add(nodeKind);
-            }
-            for (const in_ of memberType.identifierType.in_) {
-                memberIdentifierTypesIn.add(in_);
-            }
-        }
-        invariant(memberIdentifierTypeNodeKinds.size > 0);
-        if (memberIdentifierTypeNodeKinds.size === 2) {
-            return new IdentifierType({
-                comment: Maybe.empty(),
-                label: Maybe.empty(),
-            });
-        }
-        const memberIdentifierTypeNodeKind = [...memberIdentifierTypeNodeKinds][0];
-        switch (memberIdentifierTypeNodeKind) {
-            case "BlankNode":
-                return new BlankNodeType({
-                    comment: Maybe.empty(),
-                    label: Maybe.empty(),
-                });
-            case "IRI":
-                return new IriType({
-                    comment: Maybe.empty(),
-                    hasValues: [],
-                    in_: [...memberIdentifierTypesIn],
-                    label: Maybe.empty(),
-                });
-            default:
-                memberIdentifierTypeNodeKind;
-                throw new Error("should never reach here");
-        }
-    }
-    get memberObjectTypes() {
-        const memberObjectTypes = [];
-        for (const memberType of this.memberTypes) {
-            switch (memberType.kind) {
-                case "ObjectType":
-                    memberObjectTypes.push(memberType);
-                    break;
-                case "ObjectIntersectionType":
-                case "ObjectUnionType": {
-                    invariant(memberType.kind === this.kind);
-                    memberObjectTypes.push(...memberType.memberObjectTypes);
-                    break;
-                }
-            }
-        }
-        invariant(memberObjectTypes.length >= this.memberTypes.length);
-        // Member object types must have distinct RDF types or no RDF types at all.
-        const fromRdfTypes = new TermSet();
-        let expectUniqueFromRdfTypesCount = 0;
-        for (const memberObjectType of memberObjectTypes) {
-            if (memberObjectType.extern) {
-                continue;
-            }
-            expectUniqueFromRdfTypesCount++;
-            memberObjectType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
-        }
-        if (fromRdfTypes.size > 0 &&
-            fromRdfTypes.size !== expectUniqueFromRdfTypesCount) {
-            throw new Error(`one or more ${this} members ([${memberObjectTypes.map((memberType) => memberType.toString()).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].map((fromRdfType) => Resource.Identifier.toString(fromRdfType)).join(", ")}})`);
-        }
-        return memberObjectTypes;
-    }
-    get tsFeatures() {
-        // Members of the compound type must have the same tsFeatures.
-        // They must also have distinct RDF types or no RDF types at all.
-        const mergedMemberTsFeatures = new Set();
-        for (let memberTypeI = 0; memberTypeI < this.memberObjectTypes.length; memberTypeI++) {
-            const memberType = this.memberObjectTypes[memberTypeI];
-            if (memberTypeI === 0) {
-                for (const tsFeature of memberType.tsFeatures) {
-                    mergedMemberTsFeatures.add(tsFeature);
-                }
-            }
-            if (memberType.tsFeatures.size !== mergedMemberTsFeatures.size) {
-                throw new Error(`${this} has a member ObjectType (${memberType}) with different tsFeatures than the other member ObjectType's`);
-            }
-            for (const tsFeature of memberType.tsFeatures) {
-                if (!mergedMemberTsFeatures.has(tsFeature)) {
-                    throw new Error(`${this} has a member ObjectType (${memberType}) with different tsFeatures than the other member ObjectType's`);
-                }
-            }
-        }
-        return this.#tsFeatures;
-    }
-    addMemberType(memberType) {
-        return Either.encase(() => {
-            switch (memberType.kind) {
-                case "ObjectType":
-                    super.addMemberType(memberType);
-                    break;
-                case "ObjectIntersectionType":
-                    if (this.kind === memberType.kind) {
-                        super.addMemberType(memberType);
-                    }
-                    else {
-                        throw new Error(`${this}: has incompatible compound type composition (has-a ${memberType})`);
-                    }
-                    break;
-                case "ObjectUnionType":
-                    if (this.kind === memberType.kind) {
-                        super.addMemberType(memberType);
-                    }
-                    else {
-                        throw new Error(`${this}: has incompatible compound type composition (has-a ${memberType})`);
-                    }
-                    break;
-                default:
-                    throw new Error(`${this} has one or more non-(ObjectIntersectionType | ObjectType | ObjectUnionType) node shapes in its logical constraint`);
-            }
-        });
-    }
-    toString() {
-        return `${this.kind}(shapeIdentifier=${Resource.Identifier.toString(this.shapeIdentifier)})`;
-    }
-}
-__decorate([
-    Memoize()
-], AbstractObjectCompoundType.prototype, "identifierType", null);
-__decorate([
-    Memoize()
-], AbstractObjectCompoundType.prototype, "memberObjectTypes", null);
-__decorate([
-    Memoize()
-], AbstractObjectCompoundType.prototype, "tsFeatures", null);
-//# sourceMappingURL=AbstractObjectCompoundType.js.map

package/dist/ast/Curie.d.ts

@@ -1,21 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-/**
- * A Compact URI (https://www.w3.org/TR/curie)
- */
-export declare class Curie implements NamedNode {
-    #private;
-    readonly prefix: string;
-    readonly reference: string;
-    readonly termType = "NamedNode";
-    readonly value: string;
-    constructor({ hasUniqueReference, prefix, reference, value, }: {
-        hasUniqueReference?: () => boolean;
-        prefix: string;
-        reference: string;
-        value: string;
-    });
-    equals(other: BlankNode | NamedNode): boolean;
-    get hasUniqueReference(): boolean;
-    toString(): string;
-}
-//# sourceMappingURL=Curie.d.ts.map

package/dist/ast/Curie.js

@@ -1,29 +0,0 @@
-/**
- * A Compact URI (https://www.w3.org/TR/curie)
- */
-export class Curie {
-    prefix;
-    #hasUniqueReference;
-    reference;
-    termType = "NamedNode";
-    value;
-    constructor({ hasUniqueReference, prefix, reference, value, }) {
-        this.#hasUniqueReference = hasUniqueReference ?? (() => false);
-        this.prefix = prefix;
-        this.reference = reference;
-        this.value = value;
-    }
-    equals(other) {
-        if (other.termType === "BlankNode") {
-            return false;
-        }
-        return this.value === other.value; // Allow a Curie to equal a NamedNode
-    }
-    get hasUniqueReference() {
-        return this.#hasUniqueReference();
-    }
-    toString() {
-        return `${this.prefix}:${this.reference}`;
-    }
-}
-//# sourceMappingURL=Curie.js.map

package/dist/ast/PlaceholderType.d.ts

@@ -1,15 +0,0 @@
-import { Maybe } from "purify-ts";
-/**
- * A placeholder used temporarily when a type is being resolved.
- */
-export declare class PlaceholderType {
-    static readonly instance: PlaceholderType;
-    readonly comment: Maybe<string>;
-    readonly label: Maybe<string>;
-    readonly kind = "PlaceholderType";
-    readonly name: Maybe<string>;
-    private constructor();
-    equals(_other: PlaceholderType): boolean;
-    toString(): string;
-}
-//# sourceMappingURL=PlaceholderType.d.ts.map

package/dist/ast/PlaceholderType.js

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-/**
- * A placeholder used temporarily when a type is being resolved.
- */
-export class PlaceholderType {
-    static instance = new PlaceholderType();
-    comment = Maybe.empty();
-    label = Maybe.empty();
-    kind = "PlaceholderType";
-    name = Maybe.empty();
-    constructor() { }
-    equals(_other) {
-        return true;
-    }
-    toString() {
-        return `${this.kind}()`;
-    }
-}
-//# sourceMappingURL=PlaceholderType.js.map

package/dist/generators/codeName.d.ts

@@ -1,6 +0,0 @@
-import * as ast from "../ast/index.js";
-/**
- * Code-safe name from an AST construct such as an ast.ObjectType.
- */
-export declare function codeName(sanitize: (unsanitized: string) => string, syntheticNamePrefix: string): (astConstruct: ast.ObjectType | ast.ObjectUnionType | ast.ObjectType.Property) => string;
-//# sourceMappingURL=codeName.d.ts.map

package/dist/generators/codeName.js

@@ -1,66 +0,0 @@
-import { Resource } from "rdfjs-resource";
-import * as ast from "../ast/index.js";
-/**
- * Code-safe name from an AST construct such as an ast.ObjectType.
- */
-export function codeName(sanitize, syntheticNamePrefix) {
-    return (astConstruct) => {
-        // The order of checks determines the order of preference.
-        // Explicit shaclmate:name or sh:name
-        const name = astConstruct.name.extract();
-        if (name) {
-            if (astConstruct instanceof ast.ObjectType && astConstruct.synthetic) {
-                return `${syntheticNamePrefix}${name}`;
-            }
-            return sanitize(name);
-        }
-        // Explicit rdfs:label
-        const label = astConstruct.label.extract();
-        if (label) {
-            return sanitize(label.replace(" ", "_"));
-        }
-        let propertyPath;
-        if (astConstruct instanceof ast.ObjectType.Property) {
-            // Pick up the common pattern of a property shape identifier being the node shape's identifier -localName,
-            // like ex:NodeShape-property
-            if (astConstruct.objectType.shapeIdentifier.termType === "NamedNode" &&
-                astConstruct.shapeIdentifier.termType === "NamedNode") {
-                const propertyShapeIdentifierPrefix = `${astConstruct.objectType.shapeIdentifier.value}-`;
-                if (astConstruct.shapeIdentifier.value.startsWith(propertyShapeIdentifierPrefix) &&
-                    astConstruct.shapeIdentifier.value.length >
-                        propertyShapeIdentifierPrefix.length) {
-                    return sanitize(astConstruct.shapeIdentifier.value.substring(propertyShapeIdentifierPrefix.length));
-                }
-            }
-            propertyPath = astConstruct.path;
-        }
-        // Unique reference part on a CURIE sh:path
-        if (propertyPath instanceof ast.Curie && propertyPath.hasUniqueReference) {
-            return sanitize(propertyPath.reference);
-        }
-        const shapeIdentifier = astConstruct.shapeIdentifier;
-        // Unique reference part on a CURIE shape identifier
-        if (shapeIdentifier instanceof ast.Curie &&
-            shapeIdentifier.hasUniqueReference) {
-            return sanitize(shapeIdentifier.reference);
-        }
-        // CURIE sh:path
-        if (propertyPath instanceof ast.Curie) {
-            return sanitize(`${propertyPath.prefix}_${propertyPath.reference}`);
-        }
-        // CURIE shape identifier
-        if (shapeIdentifier instanceof ast.Curie) {
-            return sanitize(`${shapeIdentifier.prefix}_${shapeIdentifier.reference}`);
-        }
-        // IRI shape identifier
-        if (shapeIdentifier.termType === "NamedNode") {
-            return sanitize(shapeIdentifier.value);
-        }
-        // IRI sh:path
-        if (propertyPath?.termType === "NamedNode") {
-            return sanitize(propertyPath.value);
-        }
-        throw new Error(`should never reach this point (shapeIdentifier=${Resource.Identifier.toString(shapeIdentifier)})`);
-    };
-}
-//# sourceMappingURL=codeName.js.map

package/dist/generators/ts/AbstractDeclaredType.d.ts

@@ -1,23 +0,0 @@
-import type { TsFeature } from "../../enums/TsFeature.js";
-import { AbstractType } from "./AbstractType.js";
-import type { Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractDeclaredType extends AbstractType {
-    abstract readonly declaration: Code;
-    readonly export: boolean;
-    readonly features: ReadonlySet<TsFeature>;
-    readonly name: string;
-    constructor({ export_, features, name, ...superParameters }: {
-        export_: boolean;
-        features: ReadonlySet<TsFeature>;
-        name: string;
-    } & ConstructorParameters<typeof AbstractType>[0]);
-}
-export declare namespace AbstractDeclaredType {
-    type Conversion = AbstractType.Conversion;
-    type DiscriminantProperty = AbstractType.DiscriminantProperty;
-    const GraphqlType: typeof AbstractType.GraphqlType;
-    type GraphqlType = AbstractType.GraphqlType;
-    const JsonType: typeof AbstractType.JsonType;
-    type JsonType = AbstractType.JsonType;
-}
-//# sourceMappingURL=AbstractDeclaredType.d.ts.map

package/dist/generators/ts/AbstractDeclaredType.js

@@ -1,17 +0,0 @@
-import { AbstractType } from "./AbstractType.js";
-export class AbstractDeclaredType extends AbstractType {
-    export;
-    features;
-    name;
-    constructor({ export_, features, name, ...superParameters }) {
-        super(superParameters);
-        this.export = export_;
-        this.features = features;
-        this.name = name;
-    }
-}
-(function (AbstractDeclaredType) {
-    AbstractDeclaredType.GraphqlType = AbstractType.GraphqlType;
-    AbstractDeclaredType.JsonType = AbstractType.JsonType;
-})(AbstractDeclaredType || (AbstractDeclaredType = {}));
-//# sourceMappingURL=AbstractDeclaredType.js.map

package/dist/generators/ts/ObjectType.d.ts

@@ -1,117 +0,0 @@
-import type { NamedNode } from "@rdfjs/types";
-import { Maybe, NonEmptyList } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
-import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
-import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_ObjectType/IdentifierPrefixProperty.js";
-import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
-import type { Property as _Property } from "./_ObjectType/Property.js";
-import { ShaclProperty as _ShaclProperty } from "./_ObjectType/ShaclProperty.js";
-import { TypeDiscriminantProperty as _TypeDiscriminantProperty } from "./_ObjectType/TypeDiscriminantProperty.js";
-import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IriType } from "./IriType.js";
-import type { Type } from "./Type.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare class ObjectType extends AbstractDeclaredType {
-    private readonly imports;
-    protected readonly toRdfTypes: readonly NamedNode[];
-    readonly abstract: boolean;
-    readonly declarationType: TsObjectDeclarationType;
-    readonly extern: boolean;
-    readonly fromRdfType: Maybe<NamedNode>;
-    readonly graphqlArgs: AbstractDeclaredType["graphqlArgs"];
-    readonly identifierType: BlankNodeType | IdentifierType | IriType;
-    readonly kind = "ObjectType";
-    readonly staticModuleName: string;
-    readonly synthetic: boolean;
-    readonly typeofs: NonEmptyList<"object">;
-    constructor({ abstract, declarationType, extern, fromRdfType, identifierType, imports, lazyAncestorObjectTypes, lazyChildObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, staticModuleName, synthetic, toRdfTypes, ...superParameters }: {
-        abstract: boolean;
-        comment: Maybe<string>;
-        declarationType: TsObjectDeclarationType;
-        extern: boolean;
-        fromRdfType: Maybe<NamedNode>;
-        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
-        identifierType: BlankNodeType | IdentifierType | IriType;
-        imports: readonly string[];
-        label: Maybe<string>;
-        lazyAncestorObjectTypes: () => readonly ObjectType[];
-        lazyChildObjectTypes: () => readonly ObjectType[];
-        lazyDescendantObjectTypes: () => readonly ObjectType[];
-        lazyParentObjectTypes: () => readonly ObjectType[];
-        lazyProperties: (objectType: ObjectType) => readonly ObjectType.Property[];
-        staticModuleName: string;
-        synthetic: boolean;
-        toRdfTypes: readonly NamedNode[];
-    } & ConstructorParameters<typeof AbstractDeclaredType>[0]);
-    get _discriminantProperty(): AbstractDeclaredType.DiscriminantProperty;
-    get ancestorObjectTypes(): readonly ObjectType[];
-    get childObjectTypes(): readonly ObjectType[];
-    get conversions(): readonly AbstractDeclaredType.Conversion[];
-    get declaration(): Code;
-    get descendantFromRdfTypeVariables(): readonly Code[];
-    get descendantFromRdfTypes(): readonly NamedNode[];
-    get descendantObjectTypes(): readonly ObjectType[];
-    get discriminantProperty(): Maybe<AbstractDeclaredType.DiscriminantProperty>;
-    get discriminantValue(): string;
-    get equalsFunction(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get fromRdfTypeVariable(): Maybe<Code>;
-    get graphqlType(): AbstractDeclaredType.GraphqlType;
-    get identifierProperty(): ObjectType.IdentifierProperty;
-    get identifierTypeAlias(): Code;
-    get mutable(): boolean;
-    get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
-    get ownProperties(): readonly ObjectType.Property[];
-    get ownShaclProperties(): readonly ObjectType.ShaclProperty<Type>[];
-    get parentObjectTypes(): readonly ObjectType[];
-    get properties(): readonly ObjectType.Property[];
-    get schema(): Code;
-    get schemaType(): Code;
-    get sparqlConstructTriplesFunction(): Code;
-    get sparqlWherePatternsFunction(): Code;
-    get toRdfjsResourceType(): Code;
-    protected get thisVariable(): Code;
-    fromJsonExpression({ variables, }: Parameters<AbstractDeclaredType["fromJsonExpression"]>[0]): Code;
-    fromRdfExpression({ variables, }: Parameters<AbstractDeclaredType["fromRdfExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: {
-        variables: {
-            value: Code;
-        };
-    }): Code;
-    hashStatements({ variables, }: Parameters<AbstractDeclaredType["hashStatements"]>[0]): readonly Code[];
-    jsonType(): AbstractDeclaredType.JsonType;
-    jsonUiSchemaElement({ variables, }: Parameters<AbstractDeclaredType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    jsonZodSchema({ context, }: Parameters<AbstractDeclaredType["jsonZodSchema"]>[0]): Code;
-    newExpression({ parameters }: {
-        parameters: Code;
-    }): Code;
-    toJsonExpression({ variables, }: Parameters<AbstractDeclaredType["toJsonExpression"]>[0]): Code;
-    toRdfExpression({ variables, }: Parameters<AbstractDeclaredType["toRdfExpression"]>[0]): Code;
-    protected ensureAtMostOneSuperObjectType(): void;
-    private readonly lazyAncestorObjectTypes;
-    private readonly lazyChildObjectTypes;
-    private readonly lazyDescendantObjectTypes;
-    private readonly lazyParentObjectTypes;
-    private readonly lazyProperties;
-}
-export declare namespace ObjectType {
-    const IdentifierPrefixProperty: typeof _IdentifierPrefixProperty;
-    type IdentifierPrefixProperty = _IdentifierPrefixProperty;
-    const IdentifierProperty: typeof _IdentifierProperty;
-    type IdentifierProperty = _IdentifierProperty;
-    type ObjectSetMethodNames = {
-        readonly object: string;
-        readonly objectCount: string;
-        readonly objectIdentifiers: string;
-        readonly objects: string;
-    };
-    type Property = _Property;
-    const ShaclProperty: typeof _ShaclProperty;
-    type ShaclProperty<TypeT extends Type> = _ShaclProperty<TypeT>;
-    const TypeDiscriminantProperty: typeof _TypeDiscriminantProperty;
-    type TypeDiscriminantProperty = _TypeDiscriminantProperty;
-}
-//# sourceMappingURL=ObjectType.d.ts.map