@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.js

@@ -1,285 +0,0 @@
-import dataFactory from "@rdfx/data-factory";
-import { Curie } from "@shaclmate/shacl-ast";
-import { sh } from "@tpluscode/rdf-ns-builders";
-import { Either, Left, Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import * as ast from "../ast/index.js";
-import { Eithers } from "../Eithers.js";
-import { ShapeStack } from "./ShapeStack.js";
-import { transformShapeToAstType } from "./transformShapeToAstType.js";
-function fieldName(propertyShape, structType) {
-    // Explicit shaclmate:name or sh:name
-    const name = propertyShape.shaclmateName.alt(propertyShape.name).extract();
-    if (name) {
-        return name;
-    }
-    // Explicit rdfs:label
-    const label = propertyShape.label.extract();
-    if (label) {
-        return label;
-    }
-    // Pick up the common pattern of a property shape identifier being the node shape's identifier -localName,
-    // like ex:NodeShape-property
-    const propertyShapeIdentifier = propertyShape.$identifier();
-    if (propertyShapeIdentifier.termType === "NamedNode" &&
-        structType.shapeIdentifier.termType === "NamedNode") {
-        const propertyShapeIdentifierPrefix = `${structType.shapeIdentifier.value}-`;
-        if (propertyShapeIdentifier.value.startsWith(propertyShapeIdentifierPrefix) &&
-            propertyShapeIdentifier.value.length >
-                propertyShapeIdentifierPrefix.length) {
-            return propertyShapeIdentifier.value.substring(propertyShapeIdentifierPrefix.length);
-        }
-    }
-    // sh:path CURIE reference
-    if (propertyShape.path instanceof Curie) {
-        return propertyShape.path.reference;
-    }
-    // Shape identifier CURIE reference
-    if (propertyShapeIdentifier instanceof Curie) {
-        return propertyShapeIdentifier.reference;
-    }
-    // Shape identifier IRI
-    if (propertyShapeIdentifier.termType === "NamedNode") {
-        return propertyShapeIdentifier.value;
-    }
-    // sh:path IRI
-    if (propertyShape.path.termType === "NamedNode") {
-        return propertyShape.path.value;
-    }
-    throw new Error(`${propertyShape}: unable to infer name`);
-}
-function synthesizePartialAstStructType({ identifierType, }) {
-    let syntheticName;
-    switch (identifierType.kind) {
-        case "BlankNode":
-            throw new Error("should never happen");
-        case "Identifier":
-            syntheticName = "DefaultPartial";
-            break;
-        case "Iri":
-            syntheticName = "NamedDefaultPartial";
-            break;
-    }
-    let partialAstStructType = this.syntheticAstStructTypesByName.get(syntheticName);
-    if (partialAstStructType) {
-        return partialAstStructType;
-    }
-    partialAstStructType = new ast.StructType({
-        comment: Maybe.empty(),
-        extern: false,
-        fromRdfType: Maybe.empty(),
-        identifierType,
-        label: Maybe.empty(),
-        name: Maybe.of(syntheticName),
-        shapeIdentifier: dataFactory.namedNode(`urn:shaclmate:synthetic:${syntheticName}`),
-        synthetic: true,
-        toRdfTypes: [],
-        tsImports: [],
-    });
-    this.syntheticAstStructTypesByName.set(syntheticName, partialAstStructType);
-    return partialAstStructType;
-}
-function transformPropertyShapeToAstType(propertyShape, shapeStack) {
-    // if (
-    //   propertyShape.path.kind === "PredicatePath" &&
-    //   propertyShape.path.iri.value.endsWith("termProperty")
-    // ) {
-    // }
-    return transformShapeToAstType
-        .call(this, propertyShape, shapeStack)
-        .chain((propertyShapeAstType) => {
-        let maxCount = propertyShape.maxCount.orDefault(BigInt(Number.MAX_SAFE_INTEGER));
-        let minCount = propertyShape.minCount.orDefault(0n);
-        if (minCount < 0n) {
-            minCount = 0n;
-        }
-        if (propertyShape.hasValues.length > minCount) {
-            minCount = BigInt(propertyShape.hasValues.length);
-        }
-        if (maxCount < minCount) {
-            maxCount = minCount;
-        }
-        if (propertyShapeAstType.kind === "DefaultValue") {
-            if (minCount > 0n) {
-                return Left(new Error(`${propertyShape}: has sh:minCount > 0 and sh:defaultValue`));
-            }
-            if (maxCount > 1) {
-                return Left(new Error(`${propertyShape}: sets with sh:defaultValue are currently unsupported`));
-            }
-            return Either.of(propertyShapeAstType);
-        }
-        if (minCount === 1n && maxCount === 1n) {
-            return Either.of(propertyShapeAstType);
-        }
-        if (minCount === 0n && maxCount === 1n) {
-            if (!ast.OptionType.isItemType(propertyShapeAstType)) {
-                return Left(new Error(`${propertyShape}: ${propertyShapeAstType} is not an OptionType item type`));
-            }
-            return Either.of(new ast.OptionType({
-                itemType: propertyShapeAstType,
-            }));
-        }
-        if (!ast.SetType.isItemType(propertyShapeAstType)) {
-            return Left(new Error(`${propertyShape}: ${propertyShapeAstType} is not a SetType item type`));
-        }
-        return Either.of(new ast.SetType({
-            itemType: propertyShapeAstType,
-            minCount,
-            mutable: propertyShape.mutable.orDefault(false),
-        }));
-    });
-}
-/**
- * Try to transform a property shape to an ast.StructType.Field.
- *
- * Returns:
- *  - Right<Just<ast.StructType.Field>> if the transformation succeeds
- *  - Right<Nothing> if the property shape should be ignored
- *  - Left<Error> if the transformation fails
- */
-export function transformPropertyShapeToAstStructTypeField({ propertyShape, structType, }) {
-    if (propertyShape.ignore) {
-        return Either.of(Maybe.empty());
-    }
-    switch (propertyShape.severity.orDefault(sh.Violation).value) {
-        case "http://www.w3.org/ns/shacl#Info":
-        case "http://www.w3.org/ns/shacl#Warning":
-            return Either.of(Maybe.empty());
-    }
-    const shapeStack = new ShapeStack(); // Start a new ShapeStack per property shape
-    return Eithers.chain2(propertyShape.resolve.isJust()
-        ? this.shapesGraph
-            .nodeShape(propertyShape.resolve.extract())
-            .map(Maybe.of)
-        : Either.of(Maybe.empty()), transformPropertyShapeToAstType.call(this, propertyShape, shapeStack)).chain(([propertyShapeResolve, astType]) => {
-        let astResolveItemType;
-        if (propertyShapeResolve.isJust()) {
-            const astResolveTypeEither = transformShapeToAstType
-                .call(this, propertyShapeResolve.unsafeCoerce(), shapeStack)
-                .chain((astResolveType) => {
-                switch (astResolveType.kind) {
-                    case "Struct":
-                        return Either.of(astResolveType);
-                    case "Union":
-                        if (
-                        // This check relies on .members being populated, which may not happen in cycles
-                        astResolveType.members.length > 0 &&
-                            !astResolveType.isStructUnionType()) {
-                            return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind} with non-StructType members`));
-                        }
-                        return Either.of(astResolveType);
-                    default:
-                        return Left(new Error(`${propertyShape} resolve cannot refer to a ${astResolveType.kind}`));
-                }
-            });
-            if (astResolveTypeEither.isLeft()) {
-                return astResolveTypeEither;
-            }
-            astResolveItemType = astResolveTypeEither.unsafeCoerce();
-        }
-        if (astResolveItemType) {
-            let astItemType;
-            switch (astType.kind) {
-                case "DefaultValue":
-                case "Option":
-                case "Set":
-                    astItemType = astType.itemType;
-                    break;
-                case "LazyOption":
-                case "LazySet":
-                // biome-ignore lint/suspicious/noFallthroughSwitchClause: break is unreachable
-                case "Lazy":
-                    invariant(false, `lazy types should not appear here: ${astType.kind}`);
-                default:
-                    astItemType = astType;
-                    break;
-            }
-            let astPartialItemType;
-            switch (astItemType.kind) {
-                case "BlankNode":
-                case "Identifier":
-                case "Iri":
-                    astPartialItemType = synthesizePartialAstStructType.call(this, {
-                        identifierType: astItemType,
-                    });
-                    break;
-                case "Struct":
-                    astPartialItemType = astItemType;
-                    break;
-                case "Union":
-                    if (!astItemType.isStructUnionType()) {
-                        return Left(new Error(`${propertyShape} partial type cannot be a ${astItemType.kind} with non-StructType members`));
-                    }
-                    astPartialItemType = astItemType;
-                    break;
-                default:
-                    return Left(new Error(`${propertyShape} has a resolve with an incompatible partial type ${astItemType.kind}`));
-            }
-            const astAbstractTypeProperties = {
-                comment: Maybe.empty(),
-                label: Maybe.empty(),
-                name: Maybe.empty(),
-                shapeIdentifier: propertyShape.$identifier(),
-            };
-            switch (astType.kind) {
-                case "BlankNode":
-                case "Identifier":
-                case "Iri":
-                case "Struct":
-                case "Union":
-                    astType = new ast.LazyType({
-                        ...astAbstractTypeProperties,
-                        partialType: astPartialItemType,
-                        resolveType: astResolveItemType,
-                    });
-                    break;
-                case "Option":
-                    astType = new ast.LazyOptionType({
-                        ...astAbstractTypeProperties,
-                        partialType: new ast.OptionType({
-                            itemType: astPartialItemType,
-                        }),
-                        resolveType: new ast.OptionType({
-                            itemType: astResolveItemType,
-                        }),
-                    });
-                    break;
-                case "Set":
-                    astType = new ast.LazySetType({
-                        ...astAbstractTypeProperties,
-                        partialType: new ast.SetType({
-                            itemType: astPartialItemType,
-                            minCount: 0n,
-                            mutable: false,
-                        }),
-                        resolveType: new ast.SetType({
-                            itemType: astResolveItemType,
-                            minCount: 0n,
-                            mutable: false,
-                        }),
-                    });
-                    break;
-                default:
-                    invariant(false, `unexpected lazy AST type ${astType.kind}`);
-            }
-        }
-        if (propertyShape.path.termType === "InversePath" &&
-            astType.nodeKinds.has("Literal")) {
-            return Left(new Error(`${propertyShape}: property shapes with inverse paths can only have blank node or IRI node kinds`));
-        }
-        return Either.of(Maybe.of(new ast.StructType.Field({
-            comment: propertyShape.comment,
-            description: propertyShape.description,
-            display: propertyShape.display,
-            label: propertyShape.label,
-            mutable: propertyShape.mutable.orDefault(false),
-            name: fieldName.call(this, propertyShape, structType),
-            order: propertyShape.order.orDefault(0),
-            path: propertyShape.path,
-            shapeIdentifier: propertyShape.$identifier(),
-            structType,
-            type: astType,
-        })));
-    });
-}
-//# sourceMappingURL=transformPropertyShapeToAstStructTypeField.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.d.ts

@@ -1,10 +0,0 @@
-import { Either, Maybe } from "purify-ts";
-import * as ast from "../ast/index.js";
-import type * as input from "../input/index.js";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type { ShapeStack } from "./ShapeStack.js";
-/**
- * Try to convert a shape to a compound type (intersection or union) using some heuristics.
- */
-export declare function transformShapeToAstCompoundType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
-//# sourceMappingURL=transformShapeToAstCompoundType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -1,92 +0,0 @@
-import { Either, Left, Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import * as ast from "../ast/index.js";
-import { Eithers } from "../Eithers.js";
-import { shapeAstTypeName } from "./shapeAstTypeName.js";
-import { transformShapeToAstType } from "./transformShapeToAstType.js";
-/**
- * Try to convert a shape to a compound type (intersection or union) using some heuristics.
- */
-export function transformShapeToAstCompoundType(shape, shapeStack) {
-    shapeStack.push(shape);
-    try {
-        return Eithers.chain2(Either.sequence(shape.and
-            .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier))), Either.sequence(shape.xone
-            .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([andConstraintShapes, xoneConstraintShapes]) => {
-            let compoundTypeKind;
-            // Distinguish constraints that take arbitrary shapes from those that only take node shapes
-            // With the latter we'll do special transformations.
-            let memberShapes;
-            if (andConstraintShapes.length > 0) {
-                memberShapes = andConstraintShapes;
-                compoundTypeKind = "Intersection";
-            }
-            else if (xoneConstraintShapes.length > 0) {
-                memberShapes = xoneConstraintShapes;
-                compoundTypeKind = "Union";
-            }
-            else {
-                return Either.of(Maybe.empty());
-            }
-            invariant(memberShapes.length > 0);
-            const memberDiscriminantValues = new Set();
-            const compoundType = new (compoundTypeKind === "Intersection"
-                ? ast.IntersectionType
-                : ast.UnionType)({
-                comment: shape.comment,
-                label: shape.label,
-                name: shapeAstTypeName(shape),
-                shapeIdentifier: shape.$identifier(),
-                synthetic: false,
-            });
-            if (memberShapes.length === 1) {
-                return transformShapeToAstType
-                    .call(this, memberShapes[0], shapeStack)
-                    .map(Maybe.of);
-            }
-            // Put a placeholder in the cache to deal with cyclic references
-            this.cachedAstTypesByShapeIdentifier.set(shape.$identifier(), compoundType);
-            return Either.sequence(memberShapes.map((memberShape) => transformShapeToAstType.call(this, memberShape, shapeStack)))
-                .chain((memberShapeTypes) => {
-                for (let memberI = 0; memberI < memberShapes.length; memberI++) {
-                    const memberShape = memberShapes[memberI];
-                    const memberType = memberShapeTypes[memberI];
-                    if (!ast.IntersectionType.isMemberType(memberType)) {
-                        return Left(new Error(`${shape} has an invalid member type kind "${memberType.kind}"`));
-                    }
-                    if (memberI > 0 &&
-                        compoundType.members.some((existingMember) => ast.Type.equals(memberType, existingMember.type))) {
-                        return Left(new Error(`${shape} has duplicate ${compoundTypeKind} member type: ${memberType}`));
-                    }
-                    let memberDiscriminantValue;
-                    if (compoundTypeKind === "Union") {
-                        if (memberShape.$type === "NodeShape") {
-                            memberDiscriminantValue =
-                                memberShape.discriminantValue.extract();
-                        }
-                        if (memberDiscriminantValue) {
-                            if (memberDiscriminantValues.has(memberDiscriminantValue)) {
-                                return Left(new Error(`${shape} member ${memberShape} has a duplicate discriminant value: ${memberDiscriminantValue}`));
-                            }
-                            memberDiscriminantValues.add(memberDiscriminantValue);
-                        }
-                    }
-                    compoundType.addMember({
-                        discriminantValue: Maybe.fromNullable(memberDiscriminantValue),
-                        type: memberType,
-                    });
-                }
-                return Either.of(Maybe.of(compoundType));
-            })
-                .ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(shape.$identifier());
-            });
-        });
-    }
-    finally {
-        shapeStack.pop(shape);
-    }
-}
-//# sourceMappingURL=transformShapeToAstCompoundType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.d.ts

@@ -1,11 +0,0 @@
-import { Either, Maybe } from "purify-ts";
-import * as ast from "../ast/index.js";
-import type * as input from "../input/index.js";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type { ShapeStack } from "./ShapeStack.js";
-/**
- * Is an ast.StructType actually the shape of an RDF list?
- * If so, return the type of its rdf:first.
- */
-export declare function transformShapeToAstListType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.ListType>>;
-//# sourceMappingURL=transformShapeToAstListType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstListType.js

@@ -1,149 +0,0 @@
-import dataFactory from "@rdfx/data-factory";
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Either, Left, Maybe } from "purify-ts";
-import * as ast from "../ast/index.js";
-import { Eithers } from "../Eithers.js";
-import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
-import { shapeNodeKinds } from "./shapeNodeKinds.js";
-import { transformPropertyShapeToAstStructTypeField } from "./transformPropertyShapeToAstStructTypeField.js";
-const listPropertiesStructType = new ast.StructType({
-    extern: false,
-    comment: Maybe.empty(),
-    label: Maybe.empty(),
-    identifierType: new ast.IdentifierType({
-        comment: Maybe.empty(),
-        label: Maybe.empty(),
-        name: Maybe.empty(),
-        shapeIdentifier: dataFactory.blankNode(),
-    }),
-    fromRdfType: Maybe.empty(),
-    name: Maybe.empty(),
-    toRdfTypes: [],
-    shapeIdentifier: dataFactory.blankNode(),
-    synthetic: true,
-    tsImports: [],
-});
-const astListTypePlaceholderItemType = new ast.BlankNodeType({
-    comment: Maybe.empty(),
-    label: Maybe.empty(),
-    name: Maybe.empty(),
-    shapeIdentifier: dataFactory.blankNode(),
-});
-const empty = Either.of(Maybe.empty());
-/**
- * Is an ast.StructType actually the shape of an RDF list?
- * If so, return the type of its rdf:first.
- */
-export function transformShapeToAstListType(shape, shapeStack) {
-    shapeStack.push(shape);
-    try {
-        if (shape.$type !== "NodeShape") {
-            return empty;
-        }
-        const nodeShape = shape;
-        return Eithers.chain2(shapeNodeKinds.call(this, nodeShape, { defaultNodeShapeNodeKinds }), Either.sequence(nodeShape.xone
-            .orDefault([])
-            .map((shapeIdentifier) => this.shapesGraph.shape(shapeIdentifier)))).chain(([nodeKinds, xone]) => {
-            // Put a placeholder in the cache to deal with cyclic references
-            // Remove the placeholder if the transformation fails.
-            const listType = new ast.ListType({
-                comment: nodeShape.comment,
-                identifierNodeKind: nodeKinds.has("BlankNode") ? "BlankNode" : "IRI",
-                itemType: astListTypePlaceholderItemType,
-                label: nodeShape.label,
-                mutable: nodeShape.mutable.orDefault(false),
-                // name: shapeAstTypeName(nodeShape),
-                // List types don't need names currently
-                name: Maybe.empty(),
-                shapeIdentifier: nodeShape.$identifier(),
-                toRdfTypes: nodeShape.toRdfTypes,
-            });
-            this.cachedAstTypesByShapeIdentifier.set(nodeShape.$identifier(), listType);
-            return (() => {
-                let emptyListShape;
-                let nonEmptyListShape;
-                for (const shape of xone) {
-                    if (shape.hasValues.length === 1 &&
-                        shape.hasValues[0].equals(rdf.nil)) {
-                        emptyListShape = shape;
-                    }
-                    else if (shape.$type === "NodeShape" &&
-                        shape.properties.length >= 2) {
-                        nonEmptyListShape = shape;
-                    }
-                }
-                if (!emptyListShape || !nonEmptyListShape) {
-                    return empty;
-                }
-                return Either.sequence(nonEmptyListShape.properties.map((propertyShapeIdentifier) => this.shapesGraph.propertyShape(propertyShapeIdentifier))).chain((nonEmptyListShapePropertyShapes) => {
-                    let firstPropertyShape;
-                    let restPropertyShape;
-                    for (const propertyShape of nonEmptyListShapePropertyShapes) {
-                        if (propertyShape.path.termType !== "NamedNode") {
-                            continue;
-                        }
-                        if (propertyShape.path.equals(rdf.first)) {
-                            firstPropertyShape = propertyShape;
-                        }
-                        else if (propertyShape.path.equals(rdf.rest)) {
-                            restPropertyShape = propertyShape;
-                        }
-                    }
-                    if (!firstPropertyShape) {
-                        return empty;
-                    }
-                    if (firstPropertyShape.maxCount.extract() !== 1n ||
-                        firstPropertyShape.minCount.extract() !== 1n) {
-                        return Left(new Error(`${nodeShape} non-empty list shape rdf:first property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
-                    }
-                    if (!restPropertyShape) {
-                        return empty;
-                    }
-                    if (restPropertyShape.maxCount.extract() !== 1n ||
-                        restPropertyShape.minCount.extract() !== 1n) {
-                        return Left(new Error(`${nodeShape} non-empty list shape rdf:rest property shape does not have sh:maxCount=1 and/or sh:minCount=1`));
-                    }
-                    return transformPropertyShapeToAstStructTypeField
-                        .call(this, {
-                        // Just need a dummy ast.StructType here to get the properties transformed.
-                        propertyShape: firstPropertyShape,
-                        structType: listPropertiesStructType,
-                    })
-                        .chain((firstFieldMaybe) => {
-                        const firstField = firstFieldMaybe.extract();
-                        if (!firstField) {
-                            return Left(new Error(`${nodeShape}: rdf:first field is ignored`));
-                        }
-                        if (!ast.ListType.isItemType(firstField.type)) {
-                            return Left(new Error(`${nodeShape}: ${firstField.type.kind} is not a valid list item type`));
-                        }
-                        listType.itemType = firstField.type;
-                        return transformPropertyShapeToAstStructTypeField
-                            .call(this, {
-                            // Just need a dummy ast.StructType here to get the properties transformed.
-                            propertyShape: restPropertyShape,
-                            structType: listPropertiesStructType,
-                        })
-                            .chain((restFieldMaybe) => {
-                            const restField = restFieldMaybe.extract();
-                            if (!restField) {
-                                return Left(new Error(`${nodeShape}: rdf:rest field is ignored`));
-                            }
-                            if (restField.type.kind !== "List" ||
-                                !restField.type.shapeIdentifier.equals(nodeShape.$identifier())) {
-                                return Left(new Error(`${nodeShape} rdf:rest property is not recursive into the node shape`));
-                            }
-                            return Either.of(Maybe.of(listType));
-                        });
-                    });
-                });
-            })().ifLeft(() => {
-                this.cachedAstTypesByShapeIdentifier.delete(nodeShape.$identifier());
-            });
-        });
-    }
-    finally {
-        shapeStack.pop(shape);
-    }
-}
-//# sourceMappingURL=transformShapeToAstListType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstStructType.d.ts

@@ -1,7 +0,0 @@
-import { Either, Maybe } from "purify-ts";
-import * as ast from "../ast/index.js";
-import type * as input from "../input/index.js";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type { ShapeStack } from "./ShapeStack.js";
-export declare function transformShapeToAstStructType(this: ShapesGraphToAstTransformer, shape: input.Shape, shapeStack: ShapeStack): Either<Error, Maybe<ast.Type>>;
-//# sourceMappingURL=transformShapeToAstStructType.d.ts.map