@shaclmate/compiler 2.0.16 → 2.0.17

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/{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

@@ -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

@@ -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.17",
     "@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.17",
     "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.17"
 }

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