@shaclmate/compiler 4.0.2 → 4.0.4

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -5,6 +5,7 @@ import { Either } from "purify-ts";
 import { CurieFactory } from "./_ShapesGraphToAstTransformer/CurieFactory.js";
 import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
 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 class ShapesGraphToAstTransformer {
     protected readonly curieFactory: CurieFactory;
@@ -14,9 +15,11 @@ export declare class ShapesGraphToAstTransformer {
     protected transformNodeShapeToAstType: typeof _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
     protected transformPropertyShapeToAstObjectTypeProperty: typeof _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
     protected transformShapeToAstType: typeof _ShapesGraphToAstTransformer.transformShapeToAstType;
-    constructor({ iriPrefixMap, shapesGraph, }: {
+    protected tsFeaturesDefault: ReadonlySet<TsFeature>;
+    constructor({ iriPrefixMap, shapesGraph, tsFeaturesDefault, }: {
         iriPrefixMap: PrefixMap;
         shapesGraph: input.ShapesGraph;
+        tsFeaturesDefault?: ReadonlySet<TsFeature>;
     });
     transform(): Either<Error, ast.Ast>;
 }

package/dist/ShapesGraphToAstTransformer.js

@@ -12,9 +12,13 @@ export class ShapesGraphToAstTransformer {
     transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
     transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
     transformShapeToAstType = _ShapesGraphToAstTransformer.transformShapeToAstType;
-    constructor({ iriPrefixMap, shapesGraph, }) {
+    tsFeaturesDefault;
+    constructor({ iriPrefixMap, shapesGraph, tsFeaturesDefault, }) {
         this.curieFactory = new CurieFactory({ prefixMap: iriPrefixMap });
         this.shapesGraph = shapesGraph;
+        this.tsFeaturesDefault =
+            tsFeaturesDefault ??
+                new Set(["create", "equals", "hash", "json", "rdf"]);
     }
     transform() {
         const nodeShapeAstObjectIntersectionTypes = [];

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.d.ts

@@ -1,5 +1,6 @@
-import { Either, type Maybe } from "purify-ts";
-import type { TsFeature } from "../enums/TsFeature.js";
+import { Either } from "purify-ts";
+import { type TsFeature } from "../enums/TsFeature.js";
 import type * as input from "../input/index.js";
-export declare function nodeShapeTsFeatures(nodeShape: input.NodeShape): Either<Error, Maybe<ReadonlySet<TsFeature>>>;
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function nodeShapeTsFeatures(this: ShapesGraphToAstTransformer, nodeShape: input.NodeShape): Either<Error, ReadonlySet<TsFeature>>;
 //# sourceMappingURL=nodeShapeTsFeatures.d.ts.map

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.js

@@ -1,8 +1,63 @@
 import { Either } from "purify-ts";
+import { TS_FEATURES } from "../enums/TsFeature.js";
 export function nodeShapeTsFeatures(nodeShape) {
-    if (nodeShape.tsFeatures.isJust()) {
-        return Either.of(nodeShape.tsFeatures);
+    const tsFeaturesDefault = this.tsFeaturesDefault;
+    function iriToTsFeatures(iri) {
+        switch (iri.value) {
+            case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
+                return TS_FEATURES;
+            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_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#_TsFeatures_None":
+                return [];
+            case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
+                return ["sparql"];
+        }
     }
-    return nodeShape.isDefinedBy.map((ontology) => ontology.chain((ontology) => ontology.tsFeatures));
+    return nodeShape.isDefinedBy.chain((ontologyMaybe) => {
+        let tsFeatureExcludes = nodeShape.tsFeatureExcludes.flatMap(iriToTsFeatures);
+        let tsFeatureIncludes = nodeShape.tsFeatureIncludes.flatMap(iriToTsFeatures);
+        if (tsFeatureExcludes.length === 0 && tsFeatureIncludes.length === 0) {
+            ontologyMaybe.ifJust((ontology) => {
+                tsFeatureExcludes = ontology.tsFeatureExcludes.flatMap(iriToTsFeatures);
+                tsFeatureIncludes = ontology.tsFeatureIncludes.flatMap(iriToTsFeatures);
+            });
+        }
+        const tsFeatures = new Set();
+        if (tsFeatureIncludes.length > 0) {
+            for (const tsFeatureInclude of tsFeatureIncludes) {
+                tsFeatures.add(tsFeatureInclude);
+            }
+        }
+        else {
+            for (const tsFeature of this.tsFeaturesDefault) {
+                tsFeatures.add(tsFeature);
+            }
+        }
+        for (const tsFeatureExclude of tsFeatureExcludes) {
+            tsFeatures.delete(tsFeatureExclude);
+        }
+        if (tsFeatures.size === 0) {
+            for (const tsFeature of tsFeaturesDefault) {
+                tsFeatures.add(tsFeature);
+            }
+        }
+        if (tsFeatures.has("graphql")) {
+            tsFeatures.add("rdf");
+        }
+        return Either.of(tsFeatures);
+    });
 }
 //# sourceMappingURL=nodeShapeTsFeatures.js.map

package/dist/_ShapesGraphToAstTransformer/transformNodeShapeToAstType.js

@@ -4,7 +4,6 @@ import { Either, Left, Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import * as ast from "../ast/index.js";
 import { Eithers } from "../Eithers.js";
-import { tsFeaturesDefault } from "../input/tsFeatures.js";
 import { nodeShapeIdentifierMintingStrategy } from "./nodeShapeIdentifierMintingStrategy.js";
 import { nodeShapeTsFeatures } from "./nodeShapeTsFeatures.js";
 import { shapeNodeKinds } from "./shapeNodeKinds.js";
@@ -157,7 +156,7 @@ function transformNodeShapeToAstListType(nodeShape) {
     });
 }
 export function transformNodeShapeToAstObjectCompoundType({ export_, nodeShape, }) {
-    return Eithers.chain3(nodeShape.constraints.and, nodeShapeTsFeatures(nodeShape), nodeShape.constraints.xone).chain(([andShapes, tsFeatures, xoneShapes]) => {
+    return Eithers.chain3(nodeShape.constraints.and, nodeShapeTsFeatures.bind(this)(nodeShape), nodeShape.constraints.xone).chain(([andShapes, tsFeatures, xoneShapes]) => {
         let compoundTypeShapes;
         let compoundTypeKind;
         if (andShapes.length > 0) {
@@ -210,7 +209,7 @@ export function transformNodeShapeToAstType(nodeShape) {
     if (nodeShape.isList) {
         return transformNodeShapeToAstListType.bind(this)(nodeShape);
     }
-    return Eithers.chain11(nodeShape.ancestorNodeShapes, nodeShape.childNodeShapes, nodeShape.descendantNodeShapes, nodeShape.parentNodeShapes, nodeShape.constraints.and, nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.properties, nodeShapeTsFeatures(nodeShape), nodeShape.tsObjectDeclarationType.isJust()
+    return Eithers.chain11(nodeShape.ancestorNodeShapes, nodeShape.childNodeShapes, nodeShape.descendantNodeShapes, nodeShape.parentNodeShapes, nodeShape.constraints.and, nodeShapeIdentifierMintingStrategy(nodeShape), shapeNodeKinds(nodeShape, { defaultNodeShapeNodeKinds }), nodeShape.constraints.properties, nodeShapeTsFeatures.bind(this)(nodeShape), nodeShape.tsObjectDeclarationType.isJust()
         ? Either.of(nodeShape.tsObjectDeclarationType)
         : nodeShape.isDefinedBy.map((ontology) => ontology.chain((ontology) => ontology.tsObjectDeclarationType)), nodeShape.constraints.xone).chain(([ancestorNodeShapes, childNodeShapes, descendantNodeShapes, parentNodeShapes, andShapes, identifierMintingStrategy, nodeKinds, propertyShapes, tsFeatures, tsObjectDeclarationType, xoneShapes,]) => {
         const abstract = nodeShape.abstract.orDefault(false);
@@ -293,7 +292,7 @@ export function transformNodeShapeToAstType(nodeShape) {
             shapeIdentifier: this.shapeIdentifier(nodeShape),
             synthetic: false,
             toRdfTypes,
-            tsFeatures: tsFeatures.orDefault(new Set(tsFeaturesDefault)),
+            tsFeatures,
             tsImports: nodeShape.tsImports,
             tsObjectDeclarationType: tsObjectDeclarationType.orDefault("class"),
         });

package/dist/_ShapesGraphToAstTransformer/transformShapeToAstCompoundType.js

@@ -104,7 +104,7 @@ export function transformShapeToAstCompoundType(shape, shapeStack) {
                         export_: true,
                         name: shape.shaclmateName,
                         shapeIdentifier: this.shapeIdentifier(shape),
-                        tsFeatures: Maybe.empty(),
+                        tsFeatures: this.tsFeaturesDefault,
                     });
                     for (const memberType of memberTypes) {
                         const addMemberTypeResult = compoundType.addMemberType(memberType);

package/dist/ast/AbstractObjectCompoundType.d.ts

@@ -33,7 +33,7 @@ export declare abstract class AbstractObjectCompoundType<ObjectCompoundTypeT ext
         export_: boolean;
         name: Maybe<string>;
         shapeIdentifier: BlankNode | NamedNode;
-        tsFeatures: Maybe<ReadonlySet<TsFeature>>;
+        tsFeatures: ReadonlySet<TsFeature>;
     } & ConstructorParameters<typeof AbstractCompoundType<ObjectCompoundTypeT | ObjectType>>[0]);
     equals(other: AbstractObjectCompoundType<ObjectCompoundTypeT>): boolean;
     get identifierType(): BlankNodeType | IdentifierType | IriType;

package/dist/ast/AbstractObjectCompoundType.js

@@ -135,7 +135,7 @@ export class AbstractObjectCompoundType extends AbstractCompoundType {
                 }
             }
         }
-        return this.#tsFeatures.orDefault(mergedMemberTsFeatures);
+        return this.#tsFeatures;
     }
     addMemberType(memberType) {
         return Either.encase(() => {

package/dist/ast/ObjectType.d.ts

@@ -1,7 +1,10 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
 import { PropertyPath } from "rdfjs-resource";
-import type { IdentifierMintingStrategy, PropertyVisibility, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
+import type { PropertyVisibility } from "../enums/PropertyVisibility.js";
+import type { TsFeature } from "../enums/TsFeature.js";
+import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { Curie } from "./Curie.js";

package/dist/enums/TsFeature.d.ts

@@ -1,2 +1,3 @@
-export type TsFeature = "create" | "equals" | "graphql" | "hash" | "json" | "rdf" | "sparql";
+export type TsFeature = (typeof TS_FEATURES)[number];
+export declare const TS_FEATURES: readonly ["create", "equals", "graphql", "hash", "json", "rdf", "sparql"];
 //# sourceMappingURL=TsFeature.d.ts.map

package/dist/enums/TsFeature.js

@@ -1,2 +1,10 @@
-export {};
+export const TS_FEATURES = [
+    "create",
+    "equals",
+    "graphql",
+    "hash",
+    "json",
+    "rdf",
+    "sparql",
+];
 //# sourceMappingURL=TsFeature.js.map

package/dist/generators/codeName.d.ts

@@ -0,0 +1,6 @@
+import * as ast from "../ast/index.js";
+/**
+ * Code-safe name from an AST construct such as an ast.ObjectType.
+ */
+export declare function codeName(sanitize: (unsanitized: string) => string, syntheticNamePrefix: string): (astConstruct: ast.ObjectType | ast.ObjectUnionType | ast.ObjectType.Property) => string;
+//# sourceMappingURL=codeName.d.ts.map

package/dist/generators/codeName.js

@@ -0,0 +1,66 @@
+import { Resource } from "rdfjs-resource";
+import * as ast from "../ast/index.js";
+/**
+ * Code-safe name from an AST construct such as an ast.ObjectType.
+ */
+export function codeName(sanitize, syntheticNamePrefix) {
+    return (astConstruct) => {
+        // The order of checks determines the order of preference.
+        // Explicit shaclmate:name or sh:name
+        const name = astConstruct.name.extract();
+        if (name) {
+            if (astConstruct instanceof ast.ObjectType && astConstruct.synthetic) {
+                return `${syntheticNamePrefix}${name}`;
+            }
+            return sanitize(name);
+        }
+        // Explicit rdfs:label
+        const label = astConstruct.label.extract();
+        if (label) {
+            return sanitize(label.replace(" ", "_"));
+        }
+        let propertyPath;
+        if (astConstruct instanceof ast.ObjectType.Property) {
+            // Pick up the common pattern of a property shape identifier being the node shape's identifier -localName,
+            // like ex:NodeShape-property
+            if (astConstruct.objectType.shapeIdentifier.termType === "NamedNode" &&
+                astConstruct.shapeIdentifier.termType === "NamedNode") {
+                const propertyShapeIdentifierPrefix = `${astConstruct.objectType.shapeIdentifier.value}-`;
+                if (astConstruct.shapeIdentifier.value.startsWith(propertyShapeIdentifierPrefix) &&
+                    astConstruct.shapeIdentifier.value.length >
+                        propertyShapeIdentifierPrefix.length) {
+                    return sanitize(astConstruct.shapeIdentifier.value.substring(propertyShapeIdentifierPrefix.length));
+                }
+            }
+            propertyPath = astConstruct.path;
+        }
+        // Unique reference part on a CURIE sh:path
+        if (propertyPath instanceof ast.Curie && propertyPath.hasUniqueReference) {
+            return sanitize(propertyPath.reference);
+        }
+        const shapeIdentifier = astConstruct.shapeIdentifier;
+        // Unique reference part on a CURIE shape identifier
+        if (shapeIdentifier instanceof ast.Curie &&
+            shapeIdentifier.hasUniqueReference) {
+            return sanitize(shapeIdentifier.reference);
+        }
+        // CURIE sh:path
+        if (propertyPath instanceof ast.Curie) {
+            return sanitize(`${propertyPath.prefix}_${propertyPath.reference}`);
+        }
+        // CURIE shape identifier
+        if (shapeIdentifier instanceof ast.Curie) {
+            return sanitize(`${shapeIdentifier.prefix}_${shapeIdentifier.reference}`);
+        }
+        // IRI shape identifier
+        if (shapeIdentifier.termType === "NamedNode") {
+            return sanitize(shapeIdentifier.value);
+        }
+        // IRI sh:path
+        if (propertyPath?.termType === "NamedNode") {
+            return sanitize(propertyPath.value);
+        }
+        throw new Error(`should never reach this point (shapeIdentifier=${Resource.Identifier.toString(shapeIdentifier)})`);
+    };
+}
+//# sourceMappingURL=codeName.js.map

package/dist/generators/ts/AbstractDeclaredType.d.ts

@@ -1,4 +1,4 @@
-import type { TsFeature } from "../../enums/index.js";
+import type { TsFeature } from "../../enums/TsFeature.js";
 import { AbstractType } from "./AbstractType.js";
 import type { Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractDeclaredType extends AbstractType {

package/dist/generators/ts/ListType.d.ts

@@ -1,6 +1,6 @@
 import type { NamedNode } from "@rdfjs/types";
 import type { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../enums/index.js";
+import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
 import type { BigDecimalType } from "./BigDecimalType.js";
 import type { BigIntType } from "./BigIntType.js";

package/dist/generators/ts/ObjectType.d.ts

@@ -1,6 +1,7 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe, NonEmptyList } from "purify-ts";
-import type { IdentifierMintingStrategy, TsObjectDeclarationType } from "../../enums/index.js";
+import type { IdentifierMintingStrategy } from "../../enums/IdentifierMintingStrategy.js";
+import type { TsObjectDeclarationType } from "../../enums/TsObjectDeclarationType.js";
 import { IdentifierPrefixProperty as _IdentifierPrefixProperty } from "./_ObjectType/IdentifierPrefixProperty.js";
 import { IdentifierProperty as _IdentifierProperty } from "./_ObjectType/IdentifierProperty.js";
 import type { Property as _Property } from "./_ObjectType/Property.js";

package/dist/generators/ts/TypeFactory.js

@@ -1,9 +1,12 @@
 import TermMap from "@rdfjs/term-map";
 import TermSet from "@rdfjs/term-set";
+import base62 from "@sindresorhus/base62";
 import { rdf, xsd } from "@tpluscode/rdf-ns-builders";
 import { LiteralDecoder, literalDatatypeDefinitions } from "rdfjs-resource";
+import reservedTsIdentifiers_ from "reserved-identifiers";
 import { invariant } from "ts-invariant";
 import { logger } from "../../logger.js";
+import { codeName } from "../codeName.js";
 import { BigDecimalType } from "./BigDecimalType.js";
 import { BigIntType } from "./BigIntType.js";
 import { BlankNodeType } from "./BlankNodeType.js";
@@ -28,8 +31,18 @@ import { StringType } from "./StringType.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TermType } from "./TermType.js";
 import { code } from "./ts-poet-wrapper.js";
-import { tsName } from "./tsName.js";
 import { UnionType } from "./UnionType.js";
+const reservedTsIdentifiers = reservedTsIdentifiers_({
+    includeGlobalProperties: true,
+});
+const tsName = codeName((value) => {
+    // Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
+    if (reservedTsIdentifiers.has(value)) {
+        // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
+        return `$_${value}$`;
+    }
+    return value.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
+}, syntheticNamePrefix);
 export class TypeFactory {
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();

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

@@ -1,5 +1,5 @@
 import type { Maybe } from "purify-ts";
-import type { PropertyVisibility } from "../../../enums/index.js";
+import type { PropertyVisibility } from "../../../enums/PropertyVisibility.js";
 import type { ObjectType } from "../ObjectType.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";

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

@@ -1,5 +1,5 @@
 import { Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy } from "../../../enums/index.js";
+import type { IdentifierMintingStrategy } from "../../../enums/IdentifierMintingStrategy.js";
 import type { BlankNodeType } from "../BlankNodeType.js";
 import type { IdentifierType } from "../IdentifierType.js";
 import type { IriType } from "../IriType.js";

package/dist/generators/ts/_ObjectUnionType/MemberType.d.ts

@@ -13,7 +13,7 @@ export declare class MemberType {
     get declarationType(): import("../../../enums/TsObjectDeclarationType.js").TsObjectDeclarationType;
     get descendantFromRdfTypeVariables(): readonly import("ts-poet").Code[];
     get discriminantPropertyValues(): readonly string[];
-    get features(): ReadonlySet<import("../../../enums/TsFeature.js").TsFeature>;
+    get features(): ReadonlySet<"create" | "equals" | "graphql" | "hash" | "json" | "rdf" | "sparql">;
     get filterFunction(): import("ts-poet").Code;
     get filterType(): import("ts-poet").Code;
     get fromRdfType(): import("purify-ts").Maybe<import("@rdfjs/types").NamedNode<string>>;

package/dist/input/NodeShape.d.ts

@@ -1,7 +1,8 @@
 import type { NamedNode } from "@rdfjs/types";
 import { NodeShape as ShaclCoreNodeShape } from "@shaclmate/shacl-ast";
 import { Either, type Maybe } from "purify-ts";
-import type { IdentifierMintingStrategy, TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { IdentifierMintingStrategy } from "../enums/IdentifierMintingStrategy.js";
+import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import type * as generated from "./generated.js";
 import type { Ontology, PropertyGroup, PropertyShape, ShapesGraph } from "./index.js";
 import type { Shape } from "./Shape.js";
@@ -41,7 +42,8 @@ export declare class NodeShape extends ShaclCoreNodeShape<any, Ontology, Propert
     get rdfType(): Maybe<NamedNode>;
     get shaclmateName(): Maybe<string>;
     get toRdfTypes(): readonly NamedNode[];
-    get tsFeatures(): Maybe<ReadonlySet<TsFeature>>;
+    get tsFeatureExcludes(): readonly 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_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+    get tsFeatureIncludes(): readonly 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_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
 }

package/dist/input/NodeShape.js

@@ -9,7 +9,6 @@ import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Either, List } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { tsFeatures } from "./tsFeatures.js";
 export class NodeShape extends ShaclCoreNodeShape {
     ancestorClassIris;
     childClassIris;
@@ -103,8 +102,11 @@ export class NodeShape extends ShaclCoreNodeShape {
     get toRdfTypes() {
         return this.generatedShaclmateNodeShape.toRdfTypes;
     }
-    get tsFeatures() {
-        return tsFeatures(this.generatedShaclmateNodeShape);
+    get tsFeatureExcludes() {
+        return this.generatedShaclmateNodeShape.tsFeatureExcludes;
+    }
+    get tsFeatureIncludes() {
+        return this.generatedShaclmateNodeShape.tsFeatureIncludes;
     }
     get tsImports() {
         return this.generatedShaclmateNodeShape.tsImports;
@@ -149,9 +151,6 @@ __decorate([
 __decorate([
     Memoize()
 ], NodeShape.prototype, "rdfType", null);
-__decorate([
-    Memoize()
-], NodeShape.prototype, "tsFeatures", null);
 __decorate([
     Memoize()
 ], NodeShape.prototype, "tsObjectDeclarationType", null);

package/dist/input/Ontology.d.ts

@@ -1,11 +1,12 @@
 import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
 import type { Maybe } from "purify-ts";
-import type { TsFeature, TsObjectDeclarationType } from "../enums/index.js";
+import type { TsObjectDeclarationType } from "../enums/TsObjectDeclarationType.js";
 import type * as generated from "./generated.js";
 export declare class Ontology extends OwlOntology {
     private readonly generatedShaclmateOntology;
     constructor(generatedShaclmateOntology: generated.ShaclmateOntology);
-    get tsFeatures(): Maybe<ReadonlySet<TsFeature>>;
+    get tsFeatureExcludes(): readonly import("@rdfjs/types").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_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
+    get tsFeatureIncludes(): readonly import("@rdfjs/types").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_Hash" | "http://purl.org/shaclmate/ontology#_TsFeature_Json" | "http://purl.org/shaclmate/ontology#_TsFeatures_None" | "http://purl.org/shaclmate/ontology#_TsFeature_Rdf" | "http://purl.org/shaclmate/ontology#_TsFeature_Sparql">[];
     get tsImports(): readonly string[];
     get tsObjectDeclarationType(): Maybe<TsObjectDeclarationType>;
 }

package/dist/input/Ontology.js

@@ -6,15 +6,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { Ontology as OwlOntology } from "@shaclmate/shacl-ast";
 import { Memoize } from "typescript-memoize";
-import { tsFeatures } from "./tsFeatures.js";
 export class Ontology extends OwlOntology {
     generatedShaclmateOntology;
     constructor(generatedShaclmateOntology) {
         super(generatedShaclmateOntology);
         this.generatedShaclmateOntology = generatedShaclmateOntology;
     }
-    get tsFeatures() {
-        return tsFeatures(this.generatedShaclmateOntology);
+    get tsFeatureExcludes() {
+        return this.generatedShaclmateOntology.tsFeatureExcludes;
+    }
+    get tsFeatureIncludes() {
+        return this.generatedShaclmateOntology.tsFeatureIncludes;
     }
     get tsImports() {
         return this.generatedShaclmateOntology.tsImports;
@@ -32,9 +34,6 @@ export class Ontology extends OwlOntology {
         });
     }
 }
-__decorate([
-    Memoize()
-], Ontology.prototype, "tsFeatures", null);
 __decorate([
     Memoize()
 ], Ontology.prototype, "tsObjectDeclarationType", null);

package/dist/input/PropertyShape.d.ts

@@ -1,6 +1,6 @@
 import { PropertyShape as ShaclCorePropertyShape } from "@shaclmate/shacl-ast";
 import { Either, Maybe } from "purify-ts";
-import type { PropertyVisibility } from "../enums/index.js";
+import type { PropertyVisibility } from "../enums/PropertyVisibility.js";
 import type * as generated from "./generated.js";
 import type { NodeShape, Ontology, PropertyGroup, ShapesGraph } from "./index.js";
 import type { Shape } from "./Shape.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.2",
+    "@shaclmate/shacl-ast": "4.0.4",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -63,7 +63,7 @@
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "name": "@shaclmate/compiler",
-  "packageManager": "npm@10.9.0",
+  "packageManager": "npm@11.11.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/minorg/shaclmate.git"
@@ -74,10 +74,11 @@
     "depcheck": "depcheck .",
     "dev": "tsc -w --preserveWatchOutput",
     "dev:tests": "tsc -p __tests__ -w --preserveWatchOutput",
+    "test": "cd ../.. && vitest run --project @shaclmate/compiler",
     "typecheck": "tsc --noEmit",
     "typecheck:watch": "tsc --noEmit -w --preserveWatchOutput"
   },
   "type": "module",
   "types": "./dist/index.d.ts",
-  "version": "4.0.2"
+  "version": "4.0.4"
 }

package/dist/enums/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./IdentifierMintingStrategy.js";
-export * from "./PropertyVisibility.js";
-export * from "./TsFeature.js";
-export * from "./TsObjectDeclarationType.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/enums/index.js

@@ -1,5 +0,0 @@
-export * from "./IdentifierMintingStrategy.js";
-export * from "./PropertyVisibility.js";
-export * from "./TsFeature.js";
-export * from "./TsObjectDeclarationType.js";
-//# sourceMappingURL=index.js.map

package/dist/generators/ts/stringToValidTsIdentifier.d.ts

@@ -1,2 +0,0 @@
-export declare function stringToValidTsIdentifier(value: string): string;
-//# sourceMappingURL=stringToValidTsIdentifier.d.ts.map

package/dist/generators/ts/stringToValidTsIdentifier.js

@@ -1,14 +0,0 @@
-import base62 from "@sindresorhus/base62";
-import reservedTsIdentifiers_ from "reserved-identifiers";
-const reservedTsIdentifiers = reservedTsIdentifiers_({
-    includeGlobalProperties: true,
-});
-// Adapted from https://github.com/sindresorhus/to-valid-identifier , MIT license
-export function stringToValidTsIdentifier(value) {
-    if (reservedTsIdentifiers.has(value)) {
-        // We prefix with underscore to avoid any potential conflicts with the Base62 encoded string.
-        return `$_${value}$`;
-    }
-    return value.replaceAll(/\P{ID_Continue}/gu, (x) => `$${base62.encodeInteger(x.codePointAt(0))}$`);
-}
-//# sourceMappingURL=stringToValidTsIdentifier.js.map

package/dist/generators/ts/tsName.d.ts

@@ -1,12 +0,0 @@
-import type { BlankNode, NamedNode } from "@rdfjs/types";
-import type { Maybe } from "purify-ts";
-import { type PropertyPath } from "rdfjs-resource";
-import * as ast from "../../ast/index.js";
-export declare function tsName(astConstruct: {
-    label: Maybe<string>;
-    name: Maybe<string>;
-    path?: ast.Curie | PropertyPath;
-    synthetic?: boolean;
-    shapeIdentifier: BlankNode | NamedNode;
-}): string;
-//# sourceMappingURL=tsName.d.ts.map

package/dist/generators/ts/tsName.js

@@ -1,34 +0,0 @@
-import { Resource } from "rdfjs-resource";
-import * as ast from "../../ast/index.js";
-import { stringToValidTsIdentifier } from "./stringToValidTsIdentifier.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
-export function tsName(astConstruct) {
-    const name = astConstruct.name.extract();
-    if (name) {
-        if (astConstruct.synthetic) {
-            return `${syntheticNamePrefix}${name}`;
-        }
-        return stringToValidTsIdentifier(name);
-    }
-    const label = astConstruct.label.extract();
-    if (label) {
-        return stringToValidTsIdentifier(label.replace(" ", "_"));
-    }
-    const path = astConstruct.path;
-    if (path instanceof ast.Curie) {
-        if (path.hasUniqueReference) {
-            return stringToValidTsIdentifier(path.reference);
-        }
-        return stringToValidTsIdentifier(`${path.prefix}_${path.reference}`);
-    }
-    const shapeIdentifier = astConstruct.shapeIdentifier;
-    if (shapeIdentifier.termType === "NamedNode" &&
-        shapeIdentifier instanceof ast.Curie) {
-        if (shapeIdentifier.hasUniqueReference) {
-            return stringToValidTsIdentifier(shapeIdentifier.reference);
-        }
-        return stringToValidTsIdentifier(`${shapeIdentifier.prefix}_${shapeIdentifier.reference}`);
-    }
-    throw new Error(`should never reach this point (shapeIdentifier=${Resource.Identifier.toString(shapeIdentifier)})`);
-}
-//# sourceMappingURL=tsName.js.map

package/dist/input/tsFeatures.d.ts

@@ -1,11 +0,0 @@
-import type * as rdfjs from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-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<ReadonlySet<TsFeature>>;
-export declare const tsFeaturesDefault: readonly TsFeature[];
-export {};
-//# sourceMappingURL=tsFeatures.d.ts.map

package/dist/input/tsFeatures.js

@@ -1,67 +0,0 @@
-import { Maybe } from "purify-ts";
-function iriToTsFeatures(iri) {
-    switch (iri.value) {
-        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_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#_TsFeatures_None":
-            return [];
-        case "http://purl.org/shaclmate/ontology#_TsFeature_Sparql":
-            return ["sparql"];
-    }
-}
-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) {
-        for (const tsFeatureInclude of tsFeatureIncludes) {
-            tsFeatures.add(tsFeatureInclude);
-        }
-    }
-    else {
-        for (const tsFeature of tsFeaturesDefault) {
-            tsFeatures.add(tsFeature);
-        }
-    }
-    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