@shaclmate/compiler 2.0.16 → 2.0.18

package/{generators → dist/generators}/ts/TypeFactory.js

@@ -6,6 +6,7 @@ import { fromRdf } from "rdf-literal";
 import { logger } from "../../logger.js";
 import { BooleanType } from "./BooleanType.js";
 import { DateTimeType } from "./DateTimeType.js";
+import { DateType } from "./DateType.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { ListType } from "./ListType.js";
 import { LiteralType } from "./LiteralType.js";
@@ -19,9 +20,10 @@ import { TermType } from "./TermType.js";
 import { UnionType } from "./UnionType.js";
 import { tsName } from "./tsName.js";
 export class TypeFactory {
+    cachedObjectTypePropertiesByIdentifier = new TermMap();
+    cachedObjectTypesByIdentifier = new TermMap();
+    dataFactoryVariable;
     constructor({ dataFactoryVariable }) {
-        this.cachedObjectTypePropertiesByIdentifier = new TermMap();
-        this.cachedObjectTypesByIdentifier = new TermMap();
         this.dataFactoryVariable = dataFactoryVariable;
     }
     createTypeFromAstType(astType) {
@@ -42,7 +44,7 @@ export class TypeFactory {
                     identifierNodeKind: astType.identifierNodeKind,
                     itemType: this.createTypeFromAstType(astType.itemType),
                     mutable: astType.mutable.orDefault(false),
-                    mintingStrategy: astType.mintingStrategy,
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
                     toRdfTypes: astType.toRdfTypes,
                 });
             }
@@ -76,8 +78,8 @@ export class TypeFactory {
                                 .filter((value) => typeof value === "boolean"),
                         });
                     }
-                    if (datatype.equals(xsd.dateTime)) {
-                        return new DateTimeType({
+                    if (datatype.equals(xsd.date) || datatype.equals(xsd.dateTime)) {
+                        return new (datatype.equals(xsd.date) ? DateType : DateTimeType)({
                             dataFactoryVariable: this.dataFactoryVariable,
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
@@ -186,6 +188,7 @@ export class TypeFactory {
                 return new SetType({
                     dataFactoryVariable: this.dataFactoryVariable,
                     itemType: this.createTypeFromAstType(astType.itemType),
+                    mutable: astType.mutable.orDefault(false),
                     minCount: astType.minCount,
                 });
             case "TermType":
@@ -295,7 +298,7 @@ export class TypeFactory {
                 }
                 return properties.sort((left, right) => left.name.localeCompare(right.name));
             },
-            mintingStrategy: astType.identifierMintingStrategy,
+            identifierMintingStrategy: astType.identifierMintingStrategy,
             name: tsName(astType.name),
             toRdfTypes: astType.toRdfTypes,
         });

package/{generators → dist/generators}/ts/UnionType.js

@@ -10,13 +10,15 @@ import { Memoize } from "typescript-memoize";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class UnionType extends Type {
+    kind = "UnionType";
+    memberTypes;
     constructor({ memberTypes, name, ...superParameters }) {
         super(superParameters);
-        this.kind = "UnionType";
         invariant(memberTypes.length >= 2);
         this.memberTypes = memberTypes;
         this._name = name;
     }
+    _name;
     get name() {
         if (typeof this._name === "undefined") {
             switch (this._discriminatorProperty.kind) {

package/{generators → dist/generators}/ts/_ObjectType/IdentifierProperty.js

@@ -5,10 +5,15 @@ import { Import } from "../Import.js";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
+    abstract;
+    equalsFunction = "booleanEquals";
+    mutable = false;
+    classDeclarationVisibility;
+    identifierMintingStrategy;
+    lazyObjectTypeMutable;
+    override;
     constructor({ abstract, classDeclarationVisibility, lazyObjectTypeMutable, identifierMintingStrategy, override, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "booleanEquals";
-        this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
         this.classDeclarationVisibility = classDeclarationVisibility;
@@ -162,14 +167,14 @@ export class IdentifierProperty extends Property {
         }
         const statements = [];
         for (const conversion of this.type.conversions) {
-            if (conversion.sourceTypeName !== "undefined") {
-                statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${classPropertyDeclaration.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
-            }
+            invariant(conversion.sourceTypeName !== "undefined");
+            statements.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { this.${classPropertyDeclaration.name} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
-        if (!classPropertyDeclaration.hasQuestionToken) {
-            // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-            statements.push(`{ this.${classPropertyDeclaration.name} =( ${variables.parameter}) as never;\n }`);
+        if (classPropertyDeclaration.name.startsWith("_")) {
+            statements.push(`if (typeof ${variables.parameter} === "undefined") { }`);
         }
+        // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
+        statements.push(`{ this.${classPropertyDeclaration.name} =( ${variables.parameter}) as never;\n }`);
         return [statements.join(" else ")];
     }
     fromJsonStatements({ variables, }) {

package/{generators → dist/generators}/ts/_ObjectType/Property.js

@@ -1,6 +1,20 @@
 import { Scope, } from "ts-morph";
 import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
 export class Property {
+    /**
+     * TypeScript identifier-safe name of the property.
+     */
+    name;
+    /**
+     * Property type
+  .   */
+    type;
+    /**
+     * Property visibility: private, protected, public.
+     */
+    visibility;
+    dataFactoryVariable;
+    objectType;
     constructor({ dataFactoryVariable, name, objectType, type, visibility, }) {
         this.dataFactoryVariable = dataFactoryVariable;
         this.name = name;

package/{generators → dist/generators}/ts/_ObjectType/ShaclProperty.js

@@ -10,6 +10,11 @@ import { Memoize } from "typescript-memoize";
 import { tsComment } from "../tsComment.js";
 import { Property } from "./Property.js";
 export class ShaclProperty extends Property {
+    mutable;
+    comment;
+    description;
+    label;
+    path;
     constructor({ comment, description, label, mutable, path, ...superParameters }) {
         super(superParameters);
         this.comment = comment;

package/{generators → dist/generators}/ts/_ObjectType/TypeDiscriminatorProperty.js

@@ -10,10 +10,13 @@ import { Memoize } from "typescript-memoize";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { Property } from "./Property.js";
 export class TypeDiscriminatorProperty extends Property {
+    equalsFunction = "strictEquals";
+    mutable = false;
+    value;
+    abstract;
+    override;
     constructor({ abstract, override, type, value, ...superParameters }) {
         super({ ...superParameters, type });
-        this.equalsFunction = "strictEquals";
-        this.mutable = false;
         invariant(this.visibility === "public");
         this.abstract = abstract;
         this.override = override;
@@ -106,6 +109,8 @@ export class TypeDiscriminatorProperty extends Property {
 }
 (function (TypeDiscriminatorProperty) {
     class Type {
+        mutable;
+        values;
         constructor({ mutable, values, }) {
             this.mutable = mutable;
             this.values = values;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./Compiler.js";
+export * as generators from "./generators/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./Compiler.js";
+export * as generators from "./generators/index.js";
+//# sourceMappingURL=index.js.map

package/{input → dist/input}/NodeShape.d.ts

@@ -30,7 +30,7 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
     get export(): Maybe<boolean>;
     get extern(): Maybe<boolean>;
     get fromRdfType(): Maybe<NamedNode>;
-    get mintingStrategy(): Maybe<IdentifierMintingStrategy>;
+    get identifierMintingStrategy(): Maybe<IdentifierMintingStrategy>;
     get mutable(): Maybe<boolean>;
     get nodeKinds(): Set<"BlankNode" | "NamedNode">;
     get parentNodeShapes(): readonly NodeShape[];

package/{input → dist/input}/NodeShape.js

@@ -2,6 +2,13 @@ import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 import { tsFeatures } from "./tsFeatures.js";
 export class NodeShape extends ShaclCoreNodeShape {
+    isClass;
+    isList;
+    ancestorClassIris;
+    childClassIris;
+    descendantClassIris;
+    generatedShaclmateNodeShape;
+    parentClassIris;
     constructor({ ancestorClassIris, childClassIris, descendantClassIris, generatedShaclmateNodeShape, isClass, isList, parentClassIris, shapesGraph, }) {
         super(generatedShaclmateNodeShape, shapesGraph);
         this.ancestorClassIris = ancestorClassIris;
@@ -51,7 +58,7 @@ export class NodeShape extends ShaclCoreNodeShape {
         }
         return Maybe.empty();
     }
-    get mintingStrategy() {
+    get identifierMintingStrategy() {
         const thisMintingStrategy = this._mintingStrategy;
         if (thisMintingStrategy.isNothing()) {
             for (const ancestorNodeShape of this.ancestorNodeShapes) {
@@ -150,11 +157,11 @@ export class NodeShape extends ShaclCoreNodeShape {
             .tsObjectTypeDiscriminatorPropertyName;
     }
     get _mintingStrategy() {
-        return this.generatedShaclmateNodeShape.mintingStrategy.map((iri) => {
+        return this.generatedShaclmateNodeShape.identifierMintingStrategy.map((iri) => {
             switch (iri.value) {
-                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256":
+                case "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_SHA256":
                     return "sha256";
-                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4":
+                case "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_UUIDv4":
                     return "uuidv4";
                 default:
                     throw new RangeError(iri.value);

package/{input → dist/input}/Ontology.js

@@ -1,6 +1,7 @@
 import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
 import { tsFeatures } from "./tsFeatures.js";
 export class Ontology extends OwlOntology {
+    generatedShaclmateOntology;
     constructor(generatedShaclmateOntology) {
         super(generatedShaclmateOntology);
         this.generatedShaclmateOntology = generatedShaclmateOntology;

package/dist/input/PropertyPath.d.ts

@@ -0,0 +1,41 @@
+import type { NamedNode } from "@rdfjs/types";
+import type * as purify from "purify-ts";
+import type * as rdfjsResource from "rdfjs-resource";
+export interface AlternativePath {
+    readonly kind: "AlternativePath";
+    readonly members: readonly PropertyPath[];
+}
+export interface InversePath {
+    readonly kind: "InversePath";
+    readonly path: PropertyPath;
+}
+export interface OneOrMorePath {
+    readonly kind: "OneOrMorePath";
+    readonly path: PropertyPath;
+}
+export interface PredicatePath {
+    readonly iri: NamedNode;
+    readonly kind: "PredicatePath";
+}
+export interface SequencePath {
+    readonly kind: "SequencePath";
+    readonly members: readonly PropertyPath[];
+}
+export interface ZeroOrMorePath {
+    readonly kind: "ZeroOrMorePath";
+    readonly path: PropertyPath;
+}
+export interface ZeroOrOnePath {
+    readonly kind: "ZeroOrOnePath";
+    readonly path: PropertyPath;
+}
+export type PropertyPath = AlternativePath | InversePath | OneOrMorePath | PredicatePath | SequencePath | ZeroOrMorePath | ZeroOrOnePath;
+export declare namespace PropertyPath {
+    function fromRdf({ resource, }: {
+        [_index: string]: any;
+        ignoreRdfType?: boolean;
+        languageIn?: readonly string[];
+        resource: rdfjsResource.Resource;
+    }): purify.Either<rdfjsResource.Resource.ValueError, PropertyPath>;
+}
+//# sourceMappingURL=PropertyPath.d.ts.map

package/dist/input/PropertyPath.js

@@ -0,0 +1,105 @@
+import { rdf, sh } from "@tpluscode/rdf-ns-builders";
+import { Either, Left } from "purify-ts";
+import { Resource } from "rdfjs-resource";
+export var PropertyPath;
+(function (PropertyPath) {
+    function fromRdf({ resource, }) {
+        // Predicate path
+        // sh:path ex:parent
+        if (resource.identifier.termType === "NamedNode") {
+            return Either.of({ iri: resource.identifier, kind: "PredicatePath" });
+        }
+        // The other property path types are BlankNodes
+        const getPropertyPathList = (listResource) => {
+            return listResource.toList().chain((values) => {
+                const members = [];
+                for (const value of values) {
+                    const memberResource = value.toResource().toMaybe();
+                    if (memberResource.isNothing()) {
+                        return Left(new Resource.ValueError({
+                            focusResource: resource,
+                            message: "non-identifier in property path list",
+                            predicate: rdf.subject,
+                        }));
+                    }
+                    const member = PropertyPath.fromRdf({
+                        resource: memberResource.unsafeCoerce(),
+                    });
+                    if (member.isLeft()) {
+                        return member;
+                    }
+                    members.push(member.unsafeCoerce());
+                }
+                return Either.of(members);
+            });
+        };
+        for (const quad of resource.dataset.match(resource.identifier, null, null, null)) {
+            switch (quad.object.termType) {
+                case "BlankNode":
+                case "NamedNode":
+                    break;
+                default:
+                    return Left(new Resource.ValueError({
+                        focusResource: resource,
+                        message: `non-BlankNode/NamedNode property path object on path ${resource.identifier.value}: ${quad.object.termType} ${quad.object.value}`,
+                        predicate: quad.predicate,
+                    }));
+            }
+            const objectResource = new Resource({
+                dataset: resource.dataset,
+                identifier: quad.object,
+            });
+            // Alternative path
+            // sh:path: [ sh:alternativePath ( ex:father ex:mother  ) ]
+            if (quad.predicate.equals(sh.alternativePath)) {
+                return getPropertyPathList(objectResource).map((members) => ({
+                    kind: "AlternativePath",
+                    members,
+                }));
+            }
+            // Inverse path
+            // sh:path: [ sh:inversePath ex:parent ]
+            if (quad.predicate.equals(sh.inversePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "InversePath",
+                    path,
+                }));
+            }
+            // One or more path
+            if (quad.predicate.equals(sh.oneOrMorePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "OneOrMorePath",
+                    path,
+                }));
+            }
+            // Sequence path
+            // sh:path ( ex:parent ex:firstName )
+            if (quad.predicate.equals(rdf.first)) {
+                return getPropertyPathList(objectResource).map((members) => ({
+                    kind: "SequencePath",
+                    members,
+                }));
+            }
+            // Zero or more path
+            if (quad.predicate.equals(sh.zeroOrMorePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "ZeroOrMorePath",
+                    path,
+                }));
+            }
+            if (quad.predicate.equals(sh.zeroOrOnePath)) {
+                return PropertyPath.fromRdf({ resource: objectResource }).map((path) => ({
+                    kind: "ZeroOrOnePath",
+                    path,
+                }));
+            }
+        }
+        return Left(new Resource.ValueError({
+            focusResource: resource,
+            message: `unrecognized or ill-formed SHACL property path ${resource.identifier.value}`,
+            predicate: rdf.subject,
+        }));
+    }
+    PropertyPath.fromRdf = fromRdf;
+})(PropertyPath || (PropertyPath = {}));
+//# sourceMappingURL=PropertyPath.js.map

package/{input → dist/input}/PropertyShape.js

@@ -1,6 +1,7 @@
 import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
 import { Maybe } from "purify-ts";
 export class PropertyShape extends ShaclCorePropertyShape {
+    generatedShaclmatePropertyShape;
     constructor(generatedShaclmatePropertyShape, shapesGraph) {
         super({ ...generatedShaclmatePropertyShape, uniqueLang: Maybe.empty() }, shapesGraph);
         this.generatedShaclmatePropertyShape = generatedShaclmatePropertyShape;

package/{input → dist/input}/generated.d.ts

@@ -1,7 +1,7 @@
 import type * as rdfjs from "@rdfjs/types";
-import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
 import * as purify from "purify-ts";
 import * as rdfjsResource from "rdfjs-resource";
+import { PropertyPath } from "./PropertyPath.js";
 type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never;
 export interface BaseShaclCoreShape {
     readonly and: readonly (readonly (rdfjs.BlankNode | rdfjs.NamedNode)[])[];
@@ -202,7 +202,7 @@ export interface ShaclmateNodeShape extends ShaclCoreNodeShape {
     readonly extern: purify.Maybe<boolean>;
     readonly fromRdfType: purify.Maybe<rdfjs.NamedNode>;
     readonly identifier: rdfjs.BlankNode | rdfjs.NamedNode;
-    readonly mintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4">>;
+    readonly identifierMintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_UUIDv4">>;
     readonly mutable: purify.Maybe<boolean>;
     readonly name: purify.Maybe<string>;
     readonly toRdfTypes: readonly rdfjs.NamedNode[];
@@ -226,7 +226,7 @@ export declare namespace ShaclmateNodeShape {
         extern: purify.Maybe<boolean>;
         fromRdfType: purify.Maybe<rdfjs.NamedNode>;
         identifier: rdfjs.BlankNode | rdfjs.NamedNode;
-        mintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4">>;
+        identifierMintingStrategy: purify.Maybe<rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_UUIDv4">>;
         mutable: purify.Maybe<boolean>;
         name: purify.Maybe<string>;
         toRdfTypes: readonly rdfjs.NamedNode[];

package/{input → dist/input}/generated.js

@@ -1,7 +1,7 @@
-import { PropertyPath } from "@shaclmate/shacl-ast/PropertyPath.js";
 import { DataFactory as dataFactory } from "n3";
 import * as purify from "purify-ts";
 import * as rdfjsResource from "rdfjs-resource";
+import { PropertyPath } from "./PropertyPath.js";
 export var BaseShaclCoreShape;
 (function (BaseShaclCoreShape) {
     function propertiesFromRdf({ ignoreRdfType: _ignoreRdfType, languageIn: _languageIn, resource: _resource, 
@@ -1126,29 +1126,29 @@ export var ShaclmateNodeShape;
         }
         const fromRdfType = _fromRdfTypeEither.unsafeCoerce();
         const identifier = _resource.identifier;
-        const _mintingStrategyEither = purify.Either.of(_resource
-            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#mintingStrategy"), { unique: true })
+        const _identifierMintingStrategyEither = purify.Either.of(_resource
+            .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#identifierMintingStrategy"), { unique: true })
             .head()
             .chain((_value) => _value.toIri().chain((iri) => {
             switch (iri.value) {
-                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256":
+                case "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_SHA256":
                     return purify.Either.of(iri);
-                case "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4":
+                case "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_UUIDv4":
                     return purify.Either.of(iri);
                 default:
                     return purify.Left(new rdfjsResource.Resource.MistypedValueError({
                         actualValue: iri,
-                        expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_MintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_MintingStrategy_UUIDv4">',
+                        expectedValueType: 'rdfjs.NamedNode<"http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_SHA256" | "http://minorg.github.io/shaclmate/ns#_IdentifierMintingStrategy_UUIDv4">',
                         focusResource: _resource,
-                        predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#mintingStrategy"),
+                        predicate: dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#identifierMintingStrategy"),
                     }));
             }
         }))
             .toMaybe());
-        if (_mintingStrategyEither.isLeft()) {
-            return _mintingStrategyEither;
+        if (_identifierMintingStrategyEither.isLeft()) {
+            return _identifierMintingStrategyEither;
         }
-        const mintingStrategy = _mintingStrategyEither.unsafeCoerce();
+        const identifierMintingStrategy = _identifierMintingStrategyEither.unsafeCoerce();
         const _mutableEither = purify.Either.of(_resource
             .values(dataFactory.namedNode("http://minorg.github.io/shaclmate/ns#mutable"), { unique: true })
             .head()
@@ -1348,7 +1348,7 @@ export var ShaclmateNodeShape;
             extern,
             fromRdfType,
             identifier,
-            mintingStrategy,
+            identifierMintingStrategy,
             mutable,
             name,
             toRdfTypes,

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "2.0.16",
+    "@shaclmate/shacl-ast": "2.0.18",
     "@rdfjs/prefix-map": "^0.1.2",
     "@rdfjs/term-map": "^2.0.2",
     "@rdfjs/term-set": "^2.0.3",
@@ -20,30 +20,35 @@
     "typescript-memoize": "^1.1.1"
   },
   "devDependencies": {
-    "@shaclmate/runtime": "2.0.16",
+    "@shaclmate/runtime": "2.0.18",
     "oxigraph": "^0.4.0"
   },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
   "files": [
-    "*.d.ts",
-    "*.js",
-    "_ShapesGraphToAstTransformer/*.d.ts",
-    "_ShapesGraphToAstTransformer/*.js",
-    "ast/*.d.ts",
-    "ast/*.js",
-    "enums/*.d.ts",
-    "enums/*.js",
-    "generators/*.d.ts",
-    "generators/*.js",
-    "generators/json/*.d.ts",
-    "generators/json/*.js",
-    "generators/ts/*.d.ts",
-    "generators/ts/*.js",
-    "generators/ts/_ObjectType/*.d.ts",
-    "generators/ts/_ObjectType/*.js",
-    "input/*.d.ts",
-    "input/*.js"
+    "dist/*.d.ts",
+    "dist/*.js",
+    "dist/_ShapesGraphToAstTransformer/*.d.ts",
+    "dist/_ShapesGraphToAstTransformer/*.js",
+    "dist/ast/*.d.ts",
+    "dist/ast/*.js",
+    "dist/enums/*.d.ts",
+    "dist/enums/*.js",
+    "dist/generators/*.d.ts",
+    "dist/generators/*.js",
+    "dist/generators/json/*.d.ts",
+    "dist/generators/json/*.js",
+    "dist/generators/ts/*.d.ts",
+    "dist/generators/ts/*.js",
+    "dist/generators/ts/_ObjectType/*.d.ts",
+    "dist/generators/ts/_ObjectType/*.js",
+    "dist/input/*.d.ts",
+    "dist/input/*.js"
   ],
-  "main": "index.js",
   "license": "Apache-2.0",
   "name": "@shaclmate/compiler",
   "scripts": {
@@ -51,7 +56,7 @@
     "check": "biome check",
     "check:write": "biome check --write",
     "check:write:unsafe": "biome check --write --unsafe",
-    "clean": "rimraf -g **/*.d.ts* **/*.js **/*.js.map tsconfig.tsbuildinfo",
+    "clean": "rimraf dist",
     "format": "biome format",
     "format:write": "biome format --write",
     "format:write:unsafe": "biome format --write --unsafe",
@@ -72,6 +77,5 @@
     "url": "git+https://github.com/minorg/shaclmate"
   },
   "type": "module",
-  "types": "index.d.ts",
-  "version": "2.0.16"
+  "version": "2.0.18"
 }

package/ast/SetType.d.ts

@@ -1,12 +0,0 @@
-import type { Type } from "./Type.js";
-/**
- * An unordered set of items of a specific type.
- *
- * This is a property with sh:maxCount != 1.
- */
-export interface SetType {
-    readonly itemType: Type;
-    readonly kind: "SetType";
-    readonly minCount: number;
-}
-//# sourceMappingURL=SetType.d.ts.map

package/enums/IdentifierMintingStrategy.d.ts

@@ -1,5 +0,0 @@
-/**
- * TypeScript enum corresponding to shaclmate:mintingStrategy, for simpler manipulation.
- */
-export type IdentifierMintingStrategy = "sha256" | "uuidv4";
-//# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./Compiler.js";
-//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -1,2 +0,0 @@
-export * from "./Compiler.js";
-//# sourceMappingURL=index.js.map