@shaclmate/compiler 4.0.3 → 4.0.5

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.d.ts

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

package/dist/_ShapesGraphToAstTransformer/nodeShapeTsFeatures.js

@@ -1,19 +1,11 @@
 import { Either } from "purify-ts";
-const tsFeaturesAll = [
-    "create",
-    "equals",
-    "graphql",
-    "hash",
-    "json",
-    "rdf",
-    "sparql",
-];
+import { TS_FEATURES } from "../enums/TsFeature.js";
 export function nodeShapeTsFeatures(nodeShape) {
     const tsFeaturesDefault = this.tsFeaturesDefault;
     function iriToTsFeatures(iri) {
         switch (iri.value) {
             case "http://purl.org/shaclmate/ontology#_TsFeatures_All":
-                return tsFeaturesAll;
+                return TS_FEATURES;
             case "http://purl.org/shaclmate/ontology#_TsFeature_Create":
                 return ["create"];
             case "http://purl.org/shaclmate/ontology#_TsFeatures_Default":

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/ObjectType.js

@@ -201,10 +201,10 @@ ${joinCode(staticModuleDeclarations, { on: "\n\n" })}
         return code `typeof ${this.schema}`;
     }
     get sparqlConstructTriplesFunction() {
-        return code `(({ ignoreRdfType, schema, ...otherParameters }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ ignoreRdfType: ignoreRdfType ?? true, ...otherParameters }))`;
+        return code `(({ filter, ignoreRdfType, valueVariable, variablePrefix }: ${snippets.SparqlConstructTriplesFunctionParameters}<${this.filterType}, ${this.schemaType}>) => ${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTriples({ filter, focusIdentifier: valueVariable, ignoreRdfType: ignoreRdfType ?? true, variablePrefix }))`;
     }
     get sparqlWherePatternsFunction() {
-        return code `(({ ignoreRdfType, propertyPatterns, schema, valueVariable, ...otherParameters }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ focusIdentifier: valueVariable, ignoreRdfType: ignoreRdfType ?? true, ...otherParameters })))`;
+        return code `(({ filter, ignoreRdfType, propertyPatterns, valueVariable, variablePrefix }: ${snippets.SparqlWherePatternsFunctionParameters}<${this.filterType}, ${this.schemaType}>) => (propertyPatterns as readonly ${snippets.SparqlPattern}[]).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ filter, focusIdentifier: valueVariable, ignoreRdfType: ignoreRdfType ?? true, variablePrefix })))`;
     }
     get toRdfjsResourceType() {
         if (this.parentObjectTypes.length > 0) {

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/UnionType.js

@@ -294,7 +294,7 @@ ${memberType.discriminantValues.map((discriminantValue) => `case "${discriminant
   let triples: ${imports.sparqljs}.Triple[] = [];
 
   ${joinCode(this.memberTypes.map((memberType) => code `\
-triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type, ...otherParameters }));`))}
+triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ ...otherParameters, filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type }));`))}
   
   return triples;
 })`;
@@ -305,7 +305,7 @@ triples = triples.concat(${memberType.sparqlConstructTriplesFunction}({ filter:
   const unionPatterns: ${imports.sparqljs}.GroupPattern[] = [];
 
   ${joinCode(this.memberTypes.map((memberType) => code `\
-unionPatterns.push({ patterns: ${memberType.sparqlWherePatternsFunction}({ filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type, ...otherParameters }).concat(), type: "group" });`))}
+unionPatterns.push({ patterns: ${memberType.sparqlWherePatternsFunction}({ ...otherParameters, filter: filter?.on?.["${memberType.discriminantValues[0]}"], ignoreRdfType: false, schema: schema.members["${memberType.discriminantValues[0]}"].type }).concat(), type: "group" });`))}
   
   return [{ patterns: unionPatterns, type: "union" }];
 })`;

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/package.json

@@ -1,6 +1,6 @@
 {
   "dependencies": {
-    "@shaclmate/shacl-ast": "4.0.3",
+    "@shaclmate/shacl-ast": "4.0.5",
     "@rdfjs/data-model": "~2.1.1",
     "@rdfjs/dataset": "~2.0.2",
     "@rdfjs/prefix-map": "~0.1.2",
@@ -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.3"
+  "version": "4.0.5"
 }

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