@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/input/index.d.ts

@@ -1,6 +1,6 @@
+export { PropertyGroup } from "@shaclmate/shacl-ast";
 export * from "./NodeShape.js";
 export * from "./Ontology.js";
-export { PropertyGroup } from "@shaclmate/shacl-ast";
 export * from "./PropertyShape.js";
 export * from "./Shape.js";
 export * from "./ShapesGraph.js";

package/dist/input/index.js

@@ -1,6 +1,6 @@
+export { PropertyGroup } from "@shaclmate/shacl-ast";
 export * from "./NodeShape.js";
 export * from "./Ontology.js";
-export { PropertyGroup } from "@shaclmate/shacl-ast";
 export * from "./PropertyShape.js";
 export * from "./Shape.js";
 export * from "./ShapesGraph.js";

package/dist/input/tsFeatures.d.ts

@@ -5,7 +5,7 @@ type TsFeatureIri = rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatu
 export declare function tsFeatures(generated: {
     readonly tsFeatureExcludes: readonly TsFeatureIri[];
     readonly tsFeatureIncludes: readonly TsFeatureIri[];
-}): Maybe<Set<TsFeature>>;
+}): Maybe<ReadonlySet<TsFeature>>;
 export declare const tsFeaturesDefault: readonly TsFeature[];
 export {};
 //# sourceMappingURL=tsFeatures.d.ts.map

package/package.json

@@ -1,43 +1,40 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "3.0.4",
-    "@rdfjs/prefix-map": "^0.1.2",
-    "@rdfjs/term-map": "^2.0.2",
-    "@rdfjs/term-set": "^2.0.3",
-    "@rdfjs/types": "^1.1.0",
-    "@sindresorhus/base62": "^0.1.0",
-    "@tpluscode/rdf-ns-builders": "^4.3.0",
-    "@types/n3": "^1.26.0",
-    "@types/rdfjs__prefix-map": "^0.1.5",
-    "@types/rdfjs__term-map": "^2.0.10",
-    "@types/rdfjs__term-set": "^2.0.9",
+    "@shaclmate/shacl-ast": "4.0.0",
+    "@rdfjs/data-model": "~2.1.1",
+    "@rdfjs/dataset": "~2.0.2",
+    "@rdfjs/prefix-map": "~0.1.2",
+    "@rdfjs/term-map": "~2.0.2",
+    "@rdfjs/term-set": "~2.0.3",
+    "@rdfjs/types": "~2.0.1",
+    "@sindresorhus/base62": "~0.1.0",
+    "@tpluscode/rdf-ns-builders": "~4.3.0",
+    "@types/rdfjs__data-model": "~2.0.9",
+    "@types/rdfjs__dataset": "~2.0.7",
+    "@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",
-    "n3": "^1.26.0",
-    "pino": "^9.1.0",
-    "plur": "^5.1.0",
-    "purify-ts": "^2.1.0",
-    "rdf-literal": "^1.3.2",
-    "rdfjs-resource": "1.0.24",
-    "reserved-identifiers": "^1.0.0",
+    "change-case": "~5.4.4",
+    "pino": "~9.1.0",
+    "plur": "~5.1.0",
+    "purify-ts": "~2.1.4",
+    "rdfjs-resource": "3.0.6",
+    "reserved-identifiers": "~1.0.0",
     "toposort": "2.0.2",
-    "ts-invariant": "^0.10.3",
-    "ts-morph": "^26.0.0",
-    "typescript-memoize": "^1.1.1"
+    "ts-invariant": "~0.10.3",
+    "ts-poet": "~6.12.0",
+    "typescript-memoize": "~1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/kitchen-sink-example": "3.0.4",
-    "@kos-kit/sparql-client": "2.0.116",
-    "oxigraph": "0.4.11",
-    "@biomejs/biome": "1.9.4",
-    "@tsconfig/node18": "^18.2.4",
-    "@tsconfig/strictest": "^2.0.5",
-    "@types/node": "^22",
-    "depcheck": "^1.4.7",
-    "rimraf": "^6.0.1",
-    "typescript": "5.8.2",
-    "vitest": "^3.2.4",
-    "@vitest/coverage-v8": "^3.2.4"
+    "@tsconfig/node18": "~18.2.4",
+    "@tsconfig/strictest": "~2.0.8",
+    "@types/n3": "~1.26.0",
+    "@types/node": "~18",
+    "depcheck": "~1.4.7",
+    "n3": "~1.26.0",
+    "rimraf": "~6.0.1",
+    "typescript": "5.9.3"
   },
   "files": [
     "dist/*.d.ts",
@@ -56,6 +53,10 @@
     "dist/generators/ts/*.js",
     "dist/generators/ts/_ObjectType/*.d.ts",
     "dist/generators/ts/_ObjectType/*.js",
+    "dist/generators/ts/_ObjectUnionType/*.d.ts",
+    "dist/generators/ts/_ObjectUnionType/*.js",
+    "dist/generators/ts/_snippets/*.d.ts",
+    "dist/generators/ts/_snippets/*.js",
     "dist/input/*.d.ts",
     "dist/input/*.js"
   ],
@@ -69,21 +70,14 @@
   },
   "scripts": {
     "build": "tsc -b",
-    "build:noEmit": "tsc --noEmit",
-    "check": "biome check",
-    "check:write": "biome check --write",
-    "check:write:unsafe": "biome check --write --unsafe",
     "clean": "rimraf dist",
     "depcheck": "depcheck .",
     "dev": "tsc -w --preserveWatchOutput",
-    "dev:noEmit": "tsc --noEmit -w --preserveWatchOutput",
-    "link-dependencies": "npm link rdfjs-resource",
-    "test": "biome check && vitest run",
-    "test:coverage": "biome check && vitest run --coverage",
-    "test:watch": "biome check && vitest watch",
-    "unlink": "npm unlink -g @shaclmate/compiler"
+    "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "typecheck": "tsc --noEmit",
+    "typecheck:watch": "tsc --noEmit -w --preserveWatchOutput"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "3.0.4"
+  "version": "4.0.0"
 }

package/dist/_ShapesGraphToAstTransformer/InheritableShapeConstraints.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=InheritableShapeConstraints.d.ts.map

package/dist/_ShapesGraphToAstTransformer/InheritableShapeConstraints.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=InheritableShapeConstraints.js.map

package/dist/_ShapesGraphToAstTransformer/flattenAstObjectCompositeTypeMemberTypes.d.ts

@@ -1,13 +0,0 @@
-import { Either } from "purify-ts";
-import type * as ast from "../ast/index.js";
-import type { TsFeature } from "../enums/TsFeature.js";
-import type * as input from "../input/index.js";
-export declare function flattenAstObjectCompositeTypeMemberTypes({ objectCompositeTypeKind, memberTypes, shape, }: {
-    objectCompositeTypeKind: "ObjectIntersectionType" | "ObjectUnionType";
-    memberTypes: readonly (ast.ObjectType | ast.ObjectIntersectionType | ast.ObjectUnionType)[];
-    shape: input.Shape;
-}): Either<Error, {
-    memberTypes: readonly ast.ObjectType[];
-    tsFeatures: Set<TsFeature>;
-}>;
-//# sourceMappingURL=flattenAstObjectCompositeTypeMemberTypes.d.ts.map

package/dist/_ShapesGraphToAstTransformer/flattenAstObjectCompositeTypeMemberTypes.js

@@ -1,51 +0,0 @@
-import TermSet from "@rdfjs/term-set";
-import { Either, Left } from "purify-ts";
-import { Resource } from "rdfjs-resource";
-export function flattenAstObjectCompositeTypeMemberTypes({ objectCompositeTypeKind, memberTypes, shape, }) {
-    const flattenedMemberTypes = [];
-    for (const memberType of memberTypes) {
-        switch (memberType.kind) {
-            case "ObjectType":
-                flattenedMemberTypes.push(memberType);
-                break;
-            case "ObjectIntersectionType":
-            case "ObjectUnionType":
-                if (memberType.kind === objectCompositeTypeKind) {
-                    flattenedMemberTypes.push(...memberType.memberTypes);
-                    break;
-                }
-                return Left(new Error(`${objectCompositeTypeKind} with a nested ${memberType.kind}`));
-        }
-    }
-    // Members of the composite type must have the same tsFeatures.
-    // They must also have distinct RDF types or no RDF types at all.
-    const nonExternMemberTypes = flattenedMemberTypes.filter((memberType) => !memberType.extern);
-    const fromRdfTypes = new TermSet();
-    const tsFeatures = new Set();
-    for (let memberTypeI = 0; memberTypeI < nonExternMemberTypes.length; memberTypeI++) {
-        const memberType = nonExternMemberTypes[memberTypeI];
-        if (memberTypeI === 0) {
-            for (const tsFeature of memberType.tsFeatures) {
-                tsFeatures.add(tsFeature);
-            }
-        }
-        memberType.fromRdfType.ifJust((fromRdfType) => fromRdfTypes.add(fromRdfType));
-        if (memberType.tsFeatures.size !== tsFeatures.size) {
-            return Left(new Error(`${shape} has a member ObjectType (${Resource.Identifier.toString(memberType.name.identifier)}) with different tsFeatures than the other member ObjectType's`));
-        }
-        for (const tsFeature of memberType.tsFeatures) {
-            if (!tsFeatures.has(tsFeature)) {
-                return Left(new Error(`${shape} has a member ObjectType (${Resource.Identifier.toString(memberType.name.identifier)}) with different tsFeatures than the other member ObjectType's`));
-            }
-        }
-    }
-    if (fromRdfTypes.size > 0 &&
-        fromRdfTypes.size !== nonExternMemberTypes.length) {
-        return Left(new Error(`one or more ${shape} members ([${nonExternMemberTypes.map((memberType) => Resource.Identifier.toString(memberType.name.identifier)).join(", ")}]) lack distinguishing fromRdfType's ({${[...fromRdfTypes].map((fromRdfType) => Resource.Identifier.toString(fromRdfType)).join(", ")}})`));
-    }
-    return Either.of({
-        memberTypes: flattenedMemberTypes,
-        tsFeatures,
-    });
-}
-//# sourceMappingURL=flattenAstObjectCompositeTypeMemberTypes.js.map

package/dist/_ShapesGraphToAstTransformer/pickLiteral.d.ts

@@ -1,4 +0,0 @@
-import type { Literal } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-export declare function pickLiteral(literals: readonly Literal[]): Maybe<Literal>;
-//# sourceMappingURL=pickLiteral.d.ts.map

package/dist/_ShapesGraphToAstTransformer/pickLiteral.js

@@ -1,18 +0,0 @@
-import { Maybe } from "purify-ts";
-export function pickLiteral(literals) {
-    if (literals.length === 0) {
-        return Maybe.empty();
-    }
-    for (const literal of literals) {
-        if (literal.language === "en") {
-            return Maybe.of(literal);
-        }
-    }
-    for (const literal of literals) {
-        if (literal.language.length === 0) {
-            return Maybe.of(literal);
-        }
-    }
-    return Maybe.of(literals[0]);
-}
-//# sourceMappingURL=pickLiteral.js.map

package/dist/_ShapesGraphToAstTransformer/propertyShapeNodeKinds.d.ts

@@ -1,4 +0,0 @@
-import type { NodeKind } from "@shaclmate/shacl-ast";
-import * as input from "../input/index.js";
-export declare function propertyShapeNodeKinds(shape: input.Shape): Set<NodeKind>;
-//# sourceMappingURL=propertyShapeNodeKinds.d.ts.map

package/dist/_ShapesGraphToAstTransformer/propertyShapeNodeKinds.js

@@ -1,26 +0,0 @@
-import * as input from "../input/index.js";
-export function propertyShapeNodeKinds(shape) {
-    const nodeKinds = new Set([
-        ...shape.constraints.nodeKinds.orDefault(new Set()),
-    ]);
-    if (nodeKinds.size > 0) {
-        return nodeKinds;
-    }
-    if (shape instanceof input.PropertyShape) {
-        shape.defaultValue.ifJust((defaultValue) => nodeKinds.add(defaultValue.termType));
-        if (nodeKinds.size > 0) {
-            return nodeKinds;
-        }
-    }
-    for (const hasValue of shape.constraints.hasValues) {
-        nodeKinds.add(hasValue.termType);
-    }
-    if (nodeKinds.size > 0) {
-        return nodeKinds;
-    }
-    for (const term of shape.constraints.in_) {
-        nodeKinds.add(term.termType);
-    }
-    return nodeKinds;
-}
-//# sourceMappingURL=propertyShapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/shapeAstName.d.ts

@@ -1,5 +0,0 @@
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
-import * as input from "../input/index.js";
-export declare function shapeAstName(this: ShapesGraphToAstTransformer, shape: input.Shape): ast.Name;
-//# sourceMappingURL=shapeAstName.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeAstName.js

@@ -1,69 +0,0 @@
-import { Maybe } from "purify-ts";
-import { Curie } from "../ast/Curie.js";
-import * as input from "../input/index.js";
-import { logger } from "../logger.js";
-import { pickLiteral } from "./pickLiteral.js";
-export function shapeAstName(shape) {
-    const namedIdentifier = (namedNode) => {
-        const curie = Maybe.fromNullable(this.iriPrefixMap.shrink(namedNode)?.value).map(Curie.parse);
-        curie.ifJust((curie) => {
-            if (typeof this.iriLocalParts[curie.reference] === "undefined") {
-                this.iriLocalParts[curie.reference] = {};
-            }
-            if (typeof this.iriLocalParts[curie.reference][curie.prefix] === "undefined") {
-                this.iriLocalParts[curie.reference][curie.prefix] = 1;
-            }
-            else {
-                this.iriLocalParts[curie.reference][curie.prefix] += 1;
-            }
-        });
-        return {
-            equals: (other) => {
-                return namedNode.equals(other);
-            },
-            curie,
-            termType: "NamedNode",
-            uniqueLocalPart: () => curie
-                .filter((curie) => {
-                const curieReferenceInPrefixes = this.iriLocalParts[curie.reference];
-                if (Object.entries(curieReferenceInPrefixes).length === 1) {
-                    return true;
-                }
-                logger.debug(`duplicate local part ${curie.reference} in ${JSON.stringify(curieReferenceInPrefixes)}`);
-                return false;
-            })
-                .map((curie) => curie.reference),
-            value: namedNode.value,
-        };
-    };
-    let propertyPath;
-    let shName;
-    if (shape instanceof input.PropertyShape) {
-        if (shape.path.kind === "PredicatePath") {
-            propertyPath = Maybe.of(namedIdentifier(shape.path.iri));
-            // logger.debug(
-            //   `shape ${shape} property path: ${JSON.stringify(propertyPath.unsafeCoerce())}`,
-            // );
-        }
-        else {
-            propertyPath = Maybe.empty();
-            logger.warn(`property shape ${shape} has ${shape.path.kind} path`);
-        }
-        shName = pickLiteral(shape.names).map((literal) => literal.value);
-    }
-    else {
-        propertyPath = Maybe.empty();
-        shName = Maybe.empty();
-    }
-    return {
-        identifier: shape.identifier.termType === "NamedNode"
-            ? namedIdentifier(shape.identifier)
-            : shape.identifier,
-        label: pickLiteral(shape.labels).map((literal) => literal.value),
-        propertyPath,
-        shName,
-        shaclmateName: shape.shaclmateName,
-        syntheticName: Maybe.empty(),
-    };
-}
-//# sourceMappingURL=shapeAstName.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompositeType.d.ts

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

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompositeType.js

@@ -1,185 +0,0 @@
-import { owl, rdfs } from "@tpluscode/rdf-ns-builders";
-import { Either, Left, Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import * as input from "../input/index.js";
-import { logger } from "../logger.js";
-import { flattenAstObjectCompositeTypeMemberTypes } from "./flattenAstObjectCompositeTypeMemberTypes.js";
-/**
- * Try to convert a shape to a composite type (intersection or union) using some heuristics.
- */
-export function transformShapeToAstCompositeType(shape, shapeStack) {
-    shapeStack.push(shape);
-    try {
-        let memberTypeEithers;
-        let compositeTypeKind;
-        if (shape.constraints.and.length > 0) {
-            memberTypeEithers = shape.constraints.and.map((memberShape) => this.transformShapeToAstType(memberShape, shapeStack));
-            compositeTypeKind = "IntersectionType";
-        }
-        else if (shape.constraints.classes.length > 0) {
-            memberTypeEithers = shape.constraints.classes.map((classIri) => {
-                if (classIri.equals(owl.Class) ||
-                    classIri.equals(owl.Thing) ||
-                    classIri.equals(rdfs.Class)) {
-                    return Left(new Error(`class ${classIri.value} is not transformable`));
-                }
-                const classNodeShape = this.shapesGraph
-                    .nodeShapeByIdentifier(classIri)
-                    .extractNullable();
-                if (classNodeShape === null) {
-                    return Left(new Error(`class ${classIri.value} did not resolve to a node shape`));
-                }
-                return this.transformNodeShapeToAstType(classNodeShape);
-            });
-            compositeTypeKind = "IntersectionType";
-            if (Either.rights(memberTypeEithers).length === 0) {
-                // This frequently happens with e.g., sh:class skos:Concept
-                logger.debug("shape %s sh:class(es) did not map to any node shapes", shape);
-                return memberTypeEithers[0];
-            }
-        }
-        else if (shape.constraints.nodes.length > 0) {
-            memberTypeEithers = shape.constraints.nodes.map((nodeShape) => this.transformNodeShapeToAstType(nodeShape));
-            compositeTypeKind = "IntersectionType";
-        }
-        else if (shape.constraints.xone.length > 0) {
-            memberTypeEithers = shape.constraints.xone.map((memberShape) => this.transformShapeToAstType(memberShape, shapeStack));
-            compositeTypeKind = "UnionType";
-        }
-        else {
-            return Left(new Error(`unable to transform ${shape} into an AST type`));
-        }
-        invariant(memberTypeEithers.length > 0);
-        const memberObjectTypes = [];
-        let memberTypes = [];
-        for (const memberTypeEither of memberTypeEithers) {
-            if (memberTypeEither.isLeft()) {
-                return memberTypeEither;
-            }
-            const memberType = memberTypeEither.unsafeCoerce();
-            memberTypes.push(memberType);
-            switch (memberType.kind) {
-                case "ObjectType":
-                case "ObjectIntersectionType":
-                case "ObjectUnionType":
-                    memberObjectTypes.push(memberType);
-                    break;
-            }
-        }
-        if (memberTypes.length === 1) {
-            return Either.of(memberTypes[0]);
-        }
-        if (memberTypes.length === memberObjectTypes.length) {
-            // If all the member types are ast.ObjectType, flatten them.
-            const flattenedMemberObjectTypesEither = flattenAstObjectCompositeTypeMemberTypes({
-                objectCompositeTypeKind: compositeTypeKind === "IntersectionType"
-                    ? "ObjectIntersectionType"
-                    : "ObjectUnionType",
-                memberTypes: memberObjectTypes,
-                shape,
-            });
-            if (flattenedMemberObjectTypesEither.isLeft()) {
-                return flattenedMemberObjectTypesEither;
-            }
-            const { memberTypes: flattenedMemberTypes } = flattenedMemberObjectTypesEither.unsafeCoerce();
-            memberTypes = flattenedMemberTypes.concat();
-        }
-        return widenAstCompositeTypeToSingleType({
-            memberTypes,
-            shape,
-            shapeStack,
-        }).altLazy(() => 
-        // True composite type
-        Either.of({
-            kind: compositeTypeKind,
-            memberTypes,
-        }));
-    }
-    finally {
-        shapeStack.pop(shape);
-    }
-}
-function widenAstCompositeTypeToSingleType({ memberTypes, shape, shapeStack, }) {
-    const defaultValue = shapeStack.defaultValue;
-    const hasValues = shapeStack.constraints.hasValues;
-    if (hasValues.length > 0) {
-        return Left(new Error(`shape ${shape} hasValues, not attempting to widen composite type into a single type`));
-    }
-    if (shape instanceof input.PropertyShape && !shape.widen.orDefault(true)) {
-        return Left(new Error(`shape ${shape} has widening disabled`));
-    }
-    const canWiden = (memberType) => {
-        if (memberType.in_.length > 0) {
-            return false;
-        }
-        switch (memberType.kind) {
-            case "LiteralType": {
-                if (memberType.maxExclusive.isJust()) {
-                    return false;
-                }
-                if (memberType.maxInclusive.isJust()) {
-                    return false;
-                }
-                if (memberType.minExclusive.isJust()) {
-                    return false;
-                }
-                if (memberType.minInclusive.isJust()) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    };
-    if (memberTypes.every((memberType) => memberType.kind === "IdentifierType" && canWiden(memberType))) {
-        // Special case: all member types are identifiers without further constraints
-        return Either.of({
-            defaultValue: defaultValue.filter((term) => term.termType === "NamedNode"),
-            hasValues: [],
-            in_: [],
-            kind: "IdentifierType",
-            nodeKinds: new Set(memberTypes
-                .filter((memberType) => memberType.kind === "IdentifierType")
-                .flatMap((memberType) => [
-                ...memberType.nodeKinds,
-            ])),
-        });
-    }
-    if (memberTypes.every((memberType) => memberType.kind === "LiteralType" && canWiden(memberType))) {
-        // Special case: all the member types are Literals without further constraints,
-        // like dash:StringOrLangString
-        // Don't try to widen range constraints.
-        return Either.of({
-            datatype: Maybe.empty(),
-            defaultValue: defaultValue.filter((term) => term.termType === "Literal"),
-            hasValues: [],
-            in_: [],
-            kind: "LiteralType",
-            languageIn: [],
-            maxExclusive: Maybe.empty(),
-            maxInclusive: Maybe.empty(),
-            minExclusive: Maybe.empty(),
-            minInclusive: Maybe.empty(),
-            nodeKinds: new Set(["Literal"]),
-        });
-    }
-    if (memberTypes.every((memberType) => (memberType.kind === "IdentifierType" ||
-        memberType.kind === "LiteralType" ||
-        memberType.kind === "TermType") &&
-        canWiden(memberType))) {
-        // Special case: all member types are terms without further constraints
-        const nodeKinds = new Set(memberTypes.flatMap((memberType) => [
-            ...memberType.nodeKinds,
-        ]));
-        invariant(nodeKinds.has("Literal") &&
-            (nodeKinds.has("BlankNode") || nodeKinds.has("NamedNode"))); // The identifier-identifier and literal-literal cases should have been caught above
-        return Either.of({
-            defaultValue,
-            hasValues: [],
-            in_: [],
-            kind: "TermType",
-            nodeKinds,
-        });
-    }
-    return Left(new Error(`shape ${shape} member types could not be widened into a single type`));
-}
-//# sourceMappingURL=transformShapeToAstCompositeType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstIdentifierType.d.ts

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

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstIdentifierType.js

@@ -1,32 +0,0 @@
-import { Either, Left } from "purify-ts";
-import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
-/**
- * Try to convert a property shape to an AST IdentifierType using some heuristics.
- */
-export function transformShapeToAstIdentifierType(shape, shapeStack) {
-    shapeStack.push(shape);
-    try {
-        // defaultValue / hasValue / in only makes sense with IRIs
-        const identifierDefaultValue = shapeStack.defaultValue.filter((value) => value.termType === "NamedNode");
-        const identifierHasValues = shapeStack.constraints.hasValues.filter((term) => term.termType === "NamedNode");
-        const identifierIn = shapeStack.constraints.in_.filter((term) => term.termType === "NamedNode");
-        const nodeKinds = propertyShapeNodeKinds(shape);
-        if (identifierHasValues.length > 0 ||
-            identifierDefaultValue.isJust() ||
-            identifierIn.length > 0 ||
-            (nodeKinds.size > 0 && nodeKinds.size <= 2 && !nodeKinds.has("Literal"))) {
-            return Either.of({
-                defaultValue: identifierDefaultValue,
-                hasValues: identifierHasValues,
-                in_: identifierIn,
-                kind: "IdentifierType",
-                nodeKinds: nodeKinds,
-            });
-        }
-        return Left(new Error(`unable to transform ${shape} into an AST type`));
-    }
-    finally {
-        shapeStack.pop(shape);
-    }
-}
-//# sourceMappingURL=transformShapeToAstIdentifierType.js.map

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstLiteralType.d.ts

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

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstLiteralType.js

@@ -1,46 +0,0 @@
-import { Either, Left } from "purify-ts";
-import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
-/**
- * Try to convert a property shape to an AST LiteralType using some heuristics.
- */
-export function transformShapeToAstLiteralType(shape, shapeStack) {
-    shapeStack.push(shape);
-    try {
-        const literalDefaultValue = shapeStack.defaultValue.filter((term) => term.termType === "Literal");
-        const literalHasValues = shapeStack.constraints.hasValues.filter((term) => term.termType === "Literal");
-        const literalIn = shapeStack.constraints.in_.filter((term) => term.termType === "Literal");
-        const nodeKinds = propertyShapeNodeKinds(shape);
-        if ([
-            // Treat any shape with the constraints in the list as a literal type
-            shape.constraints.datatype,
-            shape.constraints.maxExclusive,
-            shape.constraints.maxInclusive,
-            shape.constraints.minExclusive,
-            shape.constraints.minInclusive,
-        ].some((constraint) => constraint.isJust()) ||
-            shape.constraints.languageIn.length > 0 ||
-            literalDefaultValue.isJust() ||
-            literalHasValues.length > 0 ||
-            literalIn.length > 0 ||
-            // Treat any shape with a single sh:nodeKind of sh:Literal as a literal type
-            (nodeKinds.size === 1 && nodeKinds.has("Literal")))
-            return Either.of({
-                datatype: shape.constraints.datatype,
-                defaultValue: literalDefaultValue,
-                hasValues: literalHasValues,
-                in_: literalIn,
-                kind: "LiteralType",
-                languageIn: [...new Set(shape.constraints.languageIn)],
-                maxExclusive: shape.constraints.maxExclusive,
-                maxInclusive: shape.constraints.maxInclusive,
-                minExclusive: shape.constraints.minExclusive,
-                minInclusive: shape.constraints.minInclusive,
-                nodeKinds: new Set(["Literal"]),
-            });
-        return Left(new Error(`unable to transform ${shape} into an AST type`));
-    }
-    finally {
-        shapeStack.pop(shape);
-    }
-}
-//# sourceMappingURL=transformShapeToAstLiteralType.js.map