@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/input/tsFeatures.d.ts

@@ -1,10 +1,11 @@
 import type * as rdfjs from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import { TsFeature } from "../enums/index.js";
-type TsFeatureIri = rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeature_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_FromJson" | "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql" | "http://purl.org/shaclmate/ontology#_TsFeature_ToJson" | "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf">;
+import type { TsFeature } from "../enums/index.js";
+type TsFeatureIri = rdfjs.NamedNode<"http://purl.org/shaclmate/ontology#_TsFeatures_All" | "http://purl.org/shaclmate/ontology#_TsFeature_Create" | "http://purl.org/shaclmate/ontology#_TsFeatures_Default" | "http://purl.org/shaclmate/ontology#_TsFeature_Equals" | "http://purl.org/shaclmate/ontology#_TsFeature_Graphql" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeature_Hash" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">;
 export declare function tsFeatures(generated: {
     readonly tsFeatureExcludes: readonly TsFeatureIri[];
     readonly tsFeatureIncludes: readonly TsFeatureIri[];
 }): Maybe<Set<TsFeature>>;
+export declare const tsFeaturesDefault: readonly TsFeature[];
 export {};
 //# sourceMappingURL=tsFeatures.d.ts.map

package/dist/input/tsFeatures.js

@@ -1,50 +1,67 @@
 import { Maybe } from "purify-ts";
-import { TsFeature } from "../enums/index.js";
 function iriToTsFeatures(iri) {
     switch (iri.value) {
-        case "http://purl.org/shaclmate/ontology#_TsFeature_All":
-            return TsFeature.MEMBERS;
+        case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
+            return tsFeaturesAll;
         case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
             return ["create"];
+        case "http://purl.org/shaclmate/ontology#_TsFeatures_Default":
+            return tsFeaturesDefault;
         case "http://purl.org/shaclmate/ontology#_TsFeature_Equals":
             return ["equals"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_FromJson":
-            return ["fromJson"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_FromRdf":
-            return ["fromRdf"];
+        case "http://purl.org/shaclmate/ontology#_TsFeature_Graphql":
+            return ["graphql"];
+        case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
+            return ["json"];
+        case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
+            return ["rdf"];
         case "http://purl.org/shaclmate/ontology#_TsFeature_Hash":
             return ["hash"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_Json":
-            return ["fromJson", "jsonSchema", "jsonUiSchema", "toJson"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_JsonSchema":
-            return ["jsonSchema"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_JsonUiSchema":
-            return ["jsonUiSchema"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_None":
+        case "http://purl.org/shaclmate/ontology#_TsFeatures_None":
             return [];
         case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
             return ["sparql"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_Rdf":
-            return ["fromRdf", "toRdf"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_ToJson":
-            return ["toJson"];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_ToRdf":
-            return ["toRdf"];
     }
 }
 export function tsFeatures(generated) {
     const tsFeatureIncludes = generated.tsFeatureIncludes.flatMap(iriToTsFeatures);
     const tsFeatureExcludes = generated.tsFeatureExcludes.flatMap(iriToTsFeatures);
+    if (tsFeatureExcludes.length === 0 && tsFeatureIncludes.length === 0) {
+        return Maybe.empty();
+    }
+    const tsFeatures = new Set();
     if (tsFeatureIncludes.length > 0) {
-        return Maybe.of(new Set(tsFeatureIncludes));
+        for (const tsFeatureInclude of tsFeatureIncludes) {
+            tsFeatures.add(tsFeatureInclude);
+        }
     }
-    if (tsFeatureExcludes.length > 0) {
-        const tsFeatures = new Set(TsFeature.MEMBERS);
-        for (const tsFeatureExclude of tsFeatureExcludes) {
-            tsFeatures.delete(tsFeatureExclude);
+    else {
+        for (const tsFeature of tsFeaturesDefault) {
+            tsFeatures.add(tsFeature);
         }
-        return Maybe.of(tsFeatures);
     }
-    return Maybe.empty();
+    for (const tsFeatureExclude of tsFeatureExcludes) {
+        tsFeatures.delete(tsFeatureExclude);
+    }
+    if (tsFeatures.has("graphql")) {
+        tsFeatures.add("rdf");
+    }
+    return Maybe.of(tsFeatures);
 }
+const tsFeaturesAll = [
+    "create",
+    "equals",
+    "graphql",
+    "hash",
+    "json",
+    "rdf",
+    "sparql",
+];
+export const tsFeaturesDefault = [
+    "create",
+    "equals",
+    "hash",
+    "json",
+    "rdf",
+];
 //# sourceMappingURL=tsFeatures.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.22",
+    "@shaclmate/shacl-ast": "2.0.24",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
@@ -13,15 +13,22 @@
     "@types/toposort": "2.0.7",
     "change-case": "^5.4.4",
     "pino": "^9.1.0",
+    "plur": "^5.1.0",
+    "purify-ts": "^2.1.0",
     "reserved-identifiers": "^1.0.0",
     "toposort": "2.0.2",
     "ts-invariant": "^0.10.3",
-    "ts-morph": "^24.0.0",
+    "ts-morph": "^26.0.0",
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/runtime": "2.0.22",
-    "oxigraph": "^0.4.0"
+    "@shaclmate/kitchen-sink-example": "2.0.24",
+    "@shaclmate/runtime": "2.0.24",
+    "@kos-kit/sparql-client": "2.0.115",
+    "@types/n3": "^1.21.1",
+    "oxigraph": "0.4.11",
+    "n3": "^1.21.3",
+    "rdfjs-resource": "1.0.22"
   },
   "exports": {
     ".": {
@@ -51,31 +58,26 @@
   ],
   "license": "Apache-2.0",
   "name": "@shaclmate/compiler",
+  "packageManager": "npm@10.9.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/minorg/shaclmate"
   },
   "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",
-    "format": "biome format",
-    "format:write": "biome format --write",
-    "format:write:unsafe": "biome format --write --unsafe",
-    "rebuild": "run-s clean build",
+    "dev": "tsc -w --preserveWatchOutput",
+    "dev:noEmit": "tsc --noEmit -w --preserveWatchOutput",
     "link-dependencies": "npm link rdfjs-resource",
-    "lint": "biome lint",
-    "lint:write": "biome lint --write",
-    "lint:write:unsafe": "biome lint --write --unsafe",
     "test": "biome check && vitest run",
     "test:coverage": "biome check && vitest run --coverage",
-    "test:watch": "vitest watch",
-    "unlink": "npm unlink -g @shaclmate/compiler",
-    "watch": "tsc -w --preserveWatchOutput",
-    "watch:noEmit": "tsc --noEmit -w --preserveWatchOutput"
+    "test:watch": "biome check && vitest watch",
+    "unlink": "npm unlink -g @shaclmate/compiler"
   },
   "type": "module",
-  "version": "2.0.22"
+  "version": "2.0.24"
 }

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.d.ts

@@ -1,13 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import { Either, Maybe } from "purify-ts";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
-import * as input from "../input/index.js";
-/**
- * Try to convert a property shape to a composite type (intersection or union) using some heuristics.
- */
-export declare function transformPropertyShapeToAstCompositeType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-    extern: Maybe<boolean>;
-} | null): Either<Error, ast.Type>;
-//# sourceMappingURL=transformPropertyShapeToAstCompositeType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstCompositeType.js

@@ -1,200 +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";
-/**
- * Try to convert a property shape to a composite type (intersection or union) using some heuristics.
- */
-export function transformPropertyShapeToAstCompositeType(shape, inherited) {
-    const defaultValue = (shape instanceof input.PropertyShape ? shape.defaultValue : Maybe.empty()).alt(inherited !== null ? inherited.defaultValue : Maybe.empty());
-    const hasValues = shape.constraints.hasValues;
-    const extern = shape.extern.alt(inherited !== null ? inherited.extern : Maybe.empty());
-    let memberTypeEithers;
-    let compositeTypeKind;
-    const transformNodeShapeToAstCompositeMemberType = (nodeShape) => {
-        const astTypeEither = this.transformNodeShapeToAstType(nodeShape);
-        if (astTypeEither.isLeft()) {
-            return astTypeEither;
-        }
-        const astType = astTypeEither.unsafeCoerce();
-        if (extern.orDefault(false)) {
-            // Use the identifier type instead
-            let nodeKinds;
-            switch (astType.kind) {
-                case "ListType":
-                    nodeKinds = new Set();
-                    nodeKinds.add(astType.identifierNodeKind);
-                    break;
-                case "ObjectType":
-                    nodeKinds = astType.identifierKinds;
-                    break;
-                case "ObjectIntersectionType":
-                case "ObjectUnionType":
-                    nodeKinds = new Set();
-                    for (const memberType of astType.memberTypes) {
-                        for (const nodeKind of memberType.identifierKinds) {
-                            nodeKinds.add(nodeKind);
-                        }
-                    }
-            }
-            return Either.of({
-                defaultValue: defaultValue.filter((term) => term.termType === "NamedNode"),
-                hasValues: [],
-                in_: [],
-                kind: "IdentifierType",
-                nodeKinds,
-            });
-        }
-        // Not extern, use the type
-        return Either.of(astType);
-    };
-    if (shape.constraints.and.length > 0) {
-        memberTypeEithers = shape.constraints.and.map((memberShape) => this.transformPropertyShapeToAstType(memberShape, {
-            defaultValue,
-            extern: extern,
-        }));
-        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 transformNodeShapeToAstCompositeMemberType(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) => transformNodeShapeToAstCompositeMemberType(nodeShape));
-        compositeTypeKind = "IntersectionType";
-    }
-    else if (shape.constraints.xone.length > 0) {
-        memberTypeEithers = shape.constraints.xone.map((memberShape) => this.transformPropertyShapeToAstType(memberShape, {
-            defaultValue,
-            extern: extern,
-        }));
-        compositeTypeKind = "UnionType";
-    }
-    else {
-        return Left(new Error(`unable to transform ${shape} into an AST type`));
-    }
-    invariant(memberTypeEithers.length > 0);
-    const memberTypes = Either.rights(memberTypeEithers);
-    if (memberTypes.length !== memberTypeEithers.length) {
-        logger.warn("shape %s composition did not map all member types successfully: %s", shape, Either.lefts(memberTypeEithers)
-            .map((left) => left.message)
-            .join("; "));
-        return memberTypeEithers[0];
-    }
-    invariant(memberTypes.length > 0);
-    if (memberTypes.length === 1) {
-        return Either.of(memberTypes[0]);
-    }
-    // Get the type underlying a set or option
-    const memberItemTypes = memberTypes.map((memberType) => {
-        switch (memberType.kind) {
-            case "SetType":
-                return memberType.itemType;
-            case "OptionType":
-                return memberType.itemType;
-            default:
-                return memberType;
-        }
-    });
-    if (hasValues.length === 0) {
-        // Can't handle hasValues when coalescing types
-        const canCoalesce = (memberItemType) => {
-            if (memberItemType.in_.length > 0) {
-                return false;
-            }
-            switch (memberItemType.kind) {
-                case "LiteralType": {
-                    if (memberItemType.maxExclusive.isJust()) {
-                        return false;
-                    }
-                    if (memberItemType.maxInclusive.isJust()) {
-                        return false;
-                    }
-                    if (memberItemType.minExclusive.isJust()) {
-                        return false;
-                    }
-                    if (memberItemType.minInclusive.isJust()) {
-                        return false;
-                    }
-                }
-            }
-            return true;
-        };
-        if (memberItemTypes.every((memberItemType) => memberItemType.kind === "IdentifierType" &&
-            canCoalesce(memberItemType))) {
-            // 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(memberItemTypes
-                    .filter((memberItemType) => memberItemType.kind === "IdentifierType")
-                    .flatMap((memberItemType) => [
-                    ...memberItemType.nodeKinds,
-                ])),
-            });
-        }
-        if (memberItemTypes.every((memberItemType) => memberItemType.kind === "LiteralType" && canCoalesce(memberItemType))) {
-            // Special case: all the member types are Literals without further constraints,
-            // like dash:StringOrLangString
-            // Don't try to coalesce 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 (memberItemTypes.every((memberItemType) => (memberItemType.kind === "IdentifierType" ||
-            memberItemType.kind === "LiteralType" ||
-            memberItemType.kind === "TermType") &&
-            canCoalesce(memberItemType))) {
-            // Special case: all member types are terms without further constraints
-            const nodeKinds = new Set(memberItemTypes.flatMap((memberItemType) => [
-                ...memberItemType
-                    .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 Either.of({
-        kind: compositeTypeKind,
-        memberTypes: memberTypes,
-    });
-}
-//# sourceMappingURL=transformPropertyShapeToAstCompositeType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstIdentifierType.d.ts

@@ -1,12 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import { Either, Maybe } from "purify-ts";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
-import * as input from "../input/index.js";
-/**
- * Try to convert a property shape to an AST IdentifierType using some heuristics.
- */
-export declare function transformPropertyShapeToAstIdentifierType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-} | null): Either<Error, ast.IdentifierType>;
-//# sourceMappingURL=transformPropertyShapeToAstIdentifierType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstIdentifierType.js

@@ -1,29 +0,0 @@
-import { Either, Left, Maybe } from "purify-ts";
-import * as input from "../input/index.js";
-import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
-/**
- * Try to convert a property shape to an AST IdentifierType using some heuristics.
- */
-export function transformPropertyShapeToAstIdentifierType(shape, inherited) {
-    // defaultValue / hasValue / in only makes sense with IRIs
-    const identifierDefaultValue = (shape instanceof input.PropertyShape ? shape.defaultValue : Maybe.empty())
-        .alt(inherited !== null ? inherited.defaultValue : Maybe.empty())
-        .filter((value) => value.termType === "NamedNode");
-    const identifierHasValues = shape.constraints.hasValues.filter((term) => term.termType === "NamedNode");
-    const identifierIn = shape.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`));
-}
-//# sourceMappingURL=transformPropertyShapeToAstIdentifierType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstLiteralType.d.ts

@@ -1,12 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import { Either, Maybe } from "purify-ts";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
-import * as input from "../input/index.js";
-/**
- * Try to convert a property shape to an AST LiteralType using some heuristics.
- */
-export declare function transformPropertyShapeToAstLiteralType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-} | null): Either<Error, ast.LiteralType>;
-//# sourceMappingURL=transformPropertyShapeToAstLiteralType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstLiteralType.js

@@ -1,43 +0,0 @@
-import { Either, Left, Maybe } from "purify-ts";
-import * as input from "../input/index.js";
-import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
-/**
- * Try to convert a property shape to an AST LiteralType using some heuristics.
- */
-export function transformPropertyShapeToAstLiteralType(shape, inherited) {
-    const literalDefaultValue = (shape instanceof input.PropertyShape ? shape.defaultValue : Maybe.empty())
-        .alt(inherited !== null ? inherited.defaultValue : Maybe.empty())
-        .filter((term) => term.termType === "Literal");
-    const literalHasValues = shape.constraints.hasValues.filter((term) => term.termType === "Literal");
-    const literalIn = shape.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: 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`));
-}
-//# sourceMappingURL=transformPropertyShapeToAstLiteralType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstTermType.d.ts

@@ -1,14 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import { Either, Maybe } from "purify-ts";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
-import * as input from "../input/index.js";
-/**
- * Try to convert a property shape to an AST TermType using some heuristics.
- */
-export declare function transformPropertyShapeToAstTermType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-} | null): Either<Error, Omit<ast.TermType<BlankNode | Literal | NamedNode>, "kind"> & {
-    readonly kind: "TermType";
-}>;
-//# sourceMappingURL=transformPropertyShapeToAstTermType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstTermType.js

@@ -1,21 +0,0 @@
-import { Either, Maybe } from "purify-ts";
-import * as input from "../input/index.js";
-import { propertyShapeNodeKinds } from "./propertyShapeNodeKinds.js";
-/**
- * Try to convert a property shape to an AST TermType using some heuristics.
- */
-export function transformPropertyShapeToAstTermType(shape, inherited) {
-    const nodeKinds = propertyShapeNodeKinds(shape);
-    return Either.of({
-        defaultValue: (shape instanceof input.PropertyShape
-            ? shape.defaultValue
-            : Maybe.empty()).alt(inherited !== null ? inherited.defaultValue : Maybe.empty()),
-        hasValues: shape.constraints.hasValues,
-        in_: shape.constraints.in_,
-        kind: "TermType",
-        nodeKinds: nodeKinds.size > 0
-            ? nodeKinds
-            : new Set(["BlankNode", "NamedNode", "Literal"]),
-    });
-}
-//# sourceMappingURL=transformPropertyShapeToAstTermType.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstType.d.ts

@@ -1,16 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import type { Either, Maybe } from "purify-ts";
-import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
-import type * as ast from "../ast/index.js";
-import * as input from "../input/index.js";
-/**
- * Try to convert a property shape to a type using some heuristics.
- *
- * We don't try to handle exotic cases allowed by the SHACL spec, such as combinations of sh:in and sh:node. Instead we assume
- * a shape has one type.
- */
-export declare function transformPropertyShapeToAstType(this: ShapesGraphToAstTransformer, shape: input.Shape, inherited: {
-    defaultValue: Maybe<BlankNode | Literal | NamedNode>;
-    extern: Maybe<boolean>;
-} | null): Either<Error, ast.Type>;
-//# sourceMappingURL=transformPropertyShapeToAstType.d.ts.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstType.js

@@ -1,60 +0,0 @@
-import { invariant } from "ts-invariant";
-import * as input from "../input/index.js";
-/**
- * Try to convert a property shape to a type using some heuristics.
- *
- * We don't try to handle exotic cases allowed by the SHACL spec, such as combinations of sh:in and sh:node. Instead we assume
- * a shape has one type.
- */
-export function transformPropertyShapeToAstType(shape, inherited) {
-    // Try to transform the property shape into an AST type without cardinality constraints
-    return this.transformPropertyShapeToAstCompositeType(shape, inherited)
-        .altLazy(() => this.transformPropertyShapeToAstIdentifierType(shape, inherited))
-        .altLazy(() => this.transformPropertyShapeToAstLiteralType(shape, inherited))
-        .altLazy(() => this.transformPropertyShapeToAstTermType(shape, inherited))
-        .map((itemType) => {
-        // Handle cardinality constraints
-        if ((shape instanceof input.PropertyShape && shape.defaultValue.isJust()) ||
-            inherited?.defaultValue.isJust()) {
-            // Ignore other cardinality constraints if there's a default value and treat the type as minCount=maxCount=1
-            return itemType;
-        }
-        const maxCount = shape.constraints.maxCount;
-        const minCount = shape.constraints.minCount;
-        if (maxCount.isNothing() && minCount.isNothing()) {
-            // The shape has no cardinality constraints
-            if (inherited === null) {
-                // The shape is top-level (not an sh:xone/sh:and of a top-level shape)
-                // Treat it as a Set, the default in RDF.
-                // We want Set to be the outermost type unless it's explicitly requested with sh:minCount 0.
-                return {
-                    itemType,
-                    kind: "SetType",
-                    mutable: shape.mutable,
-                    minCount: 0,
-                };
-            }
-            // else the shape is not top-level
-            // We want Set to be the outermost type, so just return the itemType here
-            return itemType;
-        }
-        if (minCount.orDefault(0) === 0 && maxCount.extractNullable() === 1) {
-            return {
-                itemType,
-                kind: "OptionType",
-            };
-        }
-        if (minCount.orDefault(0) === 1 && maxCount.extractNullable() === 1) {
-            return itemType;
-        }
-        invariant(minCount.isJust() || maxCount.isJust());
-        // There are cardinality constraints for a Set. It may be an inner type.
-        return {
-            itemType,
-            kind: "SetType",
-            minCount: minCount.orDefault(0),
-            mutable: shape.mutable,
-        };
-    });
-}
-//# sourceMappingURL=transformPropertyShapeToAstType.js.map

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

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function fromJsonFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=fromJsonFunctionDeclarations.d.ts.map