@shaclmate/compiler 4.0.99 → 4.0.101

package/dist/generators/ts/SchemaObject.js

@@ -0,0 +1,143 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
+import { CodeThunk } from "./CodeThunk.js";
+import { code, joinCode } from "./ts-poet-wrapper.js";
+/**
+ * Runtime schema/metadata objects for types and properties.
+ */
+export class SchemaObject {
+    /**
+     * Object literal properties, usually property assignments like name: value
+     * without a terminating comma.
+     *
+     * Note the name is repeated between the key and the value:
+     *   { name: code`name: value` }
+     * Only the value is incorporated into generated code. The keys are used to sort properties.
+     *
+     * This enables overwriting in the *Type tree while also supporting non-property assignments such as
+     *   { name: code`get name() { return value; }` }
+     * or
+     *   { shorthand: code `shorthand` }
+     */
+    properties;
+    /**
+     * Type of the schema object.
+     */
+    type;
+    /**
+     * Variable pointing to the schema object.
+     */
+    variable;
+    constructor({ properties, type, variable, }) {
+        this.properties = properties;
+        this.type = type;
+        this.variable = variable;
+    }
+    /**
+     * Expression for this schema object, either the variable or a literal expression.
+     */
+    get expression() {
+        return this.variable.orDefaultLazy(() => this.literalExpression);
+    }
+    /**
+     * Literal expression of the schema object e.g., { name1: value1, name2: value2 }
+     */
+    get literalExpression() {
+        return code `{ ${joinCode(Object.keys(this.properties)
+            .sort()
+            .map((key) => CodeThunk.evaluate(this.properties[key])), { on: ", " })} } as const`;
+    }
+    toString() {
+        throw new Error("should never be called");
+    }
+}
+__decorate([
+    Memoize()
+], SchemaObject.prototype, "expression", null);
+__decorate([
+    Memoize()
+], SchemaObject.prototype, "literalExpression", null);
+(function (SchemaObject) {
+    /**
+     * Placeholder for abstract base classes.
+     */
+    class AbstractType {
+        ownerKind;
+        constructor(ownerKind) {
+            this.ownerKind = ownerKind;
+        }
+        get expression() {
+            throw new Error(`should never be called (instantiated by ${this.ownerKind})`);
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    SchemaObject.AbstractType = AbstractType;
+    /**
+     * A built-in schema object type from a snippet or import.
+     */
+    class BuiltinType {
+        expression;
+        constructor(expression) {
+            this.expression = code `${expression}`;
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    SchemaObject.BuiltinType = BuiltinType;
+    /**
+     * A user-defined schema object type, typically corresponding to user-defined types.
+     */
+    class UserDefinedType {
+        /**
+         * Members of the schema object type, usually property signatures like name: string.
+         *
+         * Note the name is repeated between the key and the value:
+         *   { name: code`name: string` }
+         * This enables overwriting in the *Type tree. Unlike property assignments (above),
+         * we don't really need to support other member types (index signatures, methods, et al.).
+         * Rather, the name is repeated here for consistency with property assignments.
+         */
+        members;
+        /**
+         * Name of the type, can be used in type annotations.
+         */
+        name;
+        constructor({ members, name, }) {
+            this.members = members;
+            this.name = name;
+        }
+        /**
+         * Expression of the schema object type, either the name or a literal expression.
+         */
+        get expression() {
+            return this.name.orDefaultLazy(() => this.literalExpression);
+        }
+        /**
+         * Literal expression of the schema object type e.g., { name1: string, name2: string }.
+         */
+        get literalExpression() {
+            return code `{ ${joinCode(Object.keys(this.members)
+                .sort()
+                .map((key) => code `${CodeThunk.evaluate(this.members[key])};`))} }`;
+        }
+        toString() {
+            throw new Error("should never be called");
+        }
+    }
+    __decorate([
+        Memoize()
+    ], UserDefinedType.prototype, "expression", null);
+    __decorate([
+        Memoize()
+    ], UserDefinedType.prototype, "literalExpression", null);
+    SchemaObject.UserDefinedType = UserDefinedType;
+})(SchemaObject || (SchemaObject = {}));
+//# sourceMappingURL=SchemaObject.js.map

package/dist/generators/ts/Snippets.d.ts

@@ -190,7 +190,6 @@ export declare class Snippets {
     get iriFromJsonObject(): Snippet;
     get iriFromJsonString(): Snippet;
     get iriFromRdfResourceValues(): Snippet;
-    get iriFromString(): Snippet;
     get iriLiteralFromJsonObject(): Snippet;
     get iriLiteralFromJsonString(): Snippet;
     get iriSparqlWherePatterns(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -184,7 +184,6 @@ import { snippets_intFromRdfResourceValues } from "./_snippets/snippets_intFromR
 import { snippets_iriFromJsonObject } from "./_snippets/snippets_iriFromJsonObject.js";
 import { snippets_iriFromJsonString } from "./_snippets/snippets_iriFromJsonString.js";
 import { snippets_iriFromRdfResourceValues } from "./_snippets/snippets_iriFromRdfResourceValues.js";
-import { snippets_iriFromString } from "./_snippets/snippets_iriFromString.js";
 import { snippets_iriLiteralFromJsonObject } from "./_snippets/snippets_iriLiteralFromJsonObject.js";
 import { snippets_iriLiteralFromJsonString } from "./_snippets/snippets_iriLiteralFromJsonString.js";
 import { snippets_iriSparqlWherePatterns } from "./_snippets/snippets_iriSparqlWherePatterns.js";
@@ -795,9 +794,6 @@ export class Snippets {
     get iriFromRdfResourceValues() {
         return this.snippet(snippets_iriFromRdfResourceValues);
     }
-    get iriFromString() {
-        return this.snippet(snippets_iriFromString);
-    }
     get iriLiteralFromJsonObject() {
         return this.snippet(snippets_iriLiteralFromJsonObject);
     }
@@ -1605,9 +1601,6 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "iriFromRdfResourceValues", null);
-__decorate([
-    Memoize()
-], Snippets.prototype, "iriFromString", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "iriLiteralFromJsonObject", null);

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

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

package/dist/generators/ts/_ObjectType/ObjectType_jsonObjectType.js

@@ -0,0 +1,26 @@
+import { InlineCallable } from "../InlineCallable.js";
+import { code, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectType_jsonObjectType() {
+    // If the JSON object type is { "@id": string }, allow a shorthand of string => that type.
+    let shorthand;
+    this.identifierProperty.ifJust((identifierProperty) => {
+        const fromJsonObjectInitializerParameters = {
+            variables: { context: code ``, jsonObject: code ``, options: code `` },
+        };
+        if (this.properties.some((property) => !Object.is(property, identifierProperty) &&
+            property
+                .fromJsonObjectInitializer(fromJsonObjectInitializerParameters)
+                .isJust())) {
+            return;
+        }
+        shorthand = {
+            transformer: new InlineCallable(code `(id) => ({ ${literalOf(identifierProperty.jsonObjectMember.unsafeCoerce().name)}: id })`),
+            type: identifierProperty.type.jsonValueType,
+        };
+    });
+    return this.jsonTypeFactory.createJsonObjectType(this.properties.flatMap((property) => property.jsonObjectMember.toList()), {
+        name: this.name.map((name) => [name, "Json"]).extract(),
+        shorthand,
+    });
+}
+//# sourceMappingURL=ObjectType_jsonObjectType.js.map

package/dist/generators/ts/_snippets/snippets_LazySchema.d.ts

@@ -0,0 +1,3 @@
+import type { SnippetFactory } from "../SnippetFactory.js";
+export declare const snippets_LazySchema: SnippetFactory;
+//# sourceMappingURL=snippets_LazySchema.d.ts.map

package/dist/generators/ts/_snippets/snippets_LazySchema.js

@@ -0,0 +1,7 @@
+import { code, conditionalOutput } from "../ts-poet-wrapper.js";
+export const snippets_LazySchema = ({ syntheticNamePrefix }) => conditionalOutput(`${syntheticNamePrefix}LazySchema`, code `\
+interface ${syntheticNamePrefix}LazySchema<PartialSchemaT>{
+  readonly kind: "Lazy" | "LazyOption" | "LazySet";
+  readonly partialType: PartialSchemaT;
+}`);
+//# sourceMappingURL=snippets_LazySchema.js.map

package/dist/generators/ts/_snippets/snippets_convertToIdentifier.js

@@ -5,7 +5,7 @@ function ${syntheticNamePrefix}convertToIdentifier<DefaultNamespaceT extends ${s
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${snippets.iriFromString}(value, { defaultNamespace });
+      return ${imports.expandIri}(value, { dataFactory: ${imports.dataFactory}, defaultNamespace });
     case "undefined":
       return ${imports.Either}.of(${imports.dataFactory}.blankNode());
   }

package/dist/generators/ts/_snippets/snippets_convertToIdentifierProperty.js

@@ -9,7 +9,7 @@ function ${syntheticNamePrefix}convertToIdentifierProperty<DefaultNamespaceT ext
       return ${imports.Either}.of(() => captureIdentifier);
     }
     case "string":
-      return ${snippets.iriFromString}(identifier, { defaultNamespace }).map(iri => (() => iri));
+      return ${imports.expandIri}(identifier, { dataFactory: ${imports.dataFactory}, defaultNamespace }).map(iri => (() => iri));
     case "undefined": {
       const captureIdentifier = ${imports.dataFactory}.blankNode();
       return ${imports.Either}.of(() => captureIdentifier);

package/dist/generators/ts/_snippets/snippets_convertToIri.js

@@ -5,7 +5,7 @@ function ${syntheticNamePrefix}convertToIri<DefaultNamespaceT extends ${snippets
     case "object":
       return ${imports.Either}.of(value);
     case "string":
-      return ${snippets.iriFromString}(value, { defaultNamespace });
+      return ${imports.expandIri}(value, { dataFactory: ${imports.dataFactory}, defaultNamespace });
   }
 }`);
 //# sourceMappingURL=snippets_convertToIri.js.map

package/dist/generators/ts/_snippets/snippets_convertToIriIdentifierProperty.js

@@ -9,7 +9,7 @@ function ${syntheticNamePrefix}convertToIriIdentifierProperty<DefaultNamespaceT
       return ${imports.Either}.of(() => captureIdentifier);
     }
     case "string": {
-      return ${snippets.iriFromString}(identifier, { defaultNamespace }).map(iri => (() => iri));
+      return ${imports.expandIri}(identifier, { dataFactory: ${imports.dataFactory}, defaultNamespace }).map(iri => (() => iri));
     }
   }
 }`);

package/dist/generators/ts/_snippets/snippets_iriFromJsonString.js

@@ -1,6 +1,6 @@
 import { code, conditionalOutput } from "../ts-poet-wrapper.js";
 export const snippets_iriFromJsonString = ({ imports, snippets, syntheticNamePrefix, }) => conditionalOutput(`${syntheticNamePrefix}iriFromJsonString`, code `\
 function ${syntheticNamePrefix}iriFromJsonString(jsonString: string, options: Parameters<${snippets.FromJsonFunction}<string, ${imports.NamedNode}, object>>[1]): ${imports.Either}<Error, ${imports.NamedNode}> {
-  return ${snippets.iriFromString}(jsonString, options);
+  return ${imports.expandIri}(jsonString, { ...options, dataFactory: ${imports.dataFactory} });
 }`);
 //# sourceMappingURL=snippets_iriFromJsonString.js.map

package/dist/input/ShapesGraph.js

@@ -1,5 +1,5 @@
 import { datasetFactory, TermMap } from "@rdfx/collection";
-import { Curie } from "@rdfx/curie";
+import { shrinkIri } from "@rdfx/curie";
 import dataFactory from "@rdfx/data-factory";
 import { ResourceSet } from "@rdfx/resource";
 import { AbstractShapesGraph } from "@shaclmate/shacl-ast";
@@ -31,7 +31,7 @@ export class ShapesGraph extends AbstractShapesGraph {
                 if (cachedCurie) {
                     return cachedCurie;
                 }
-                const curie = Curie.fromIri(term, {
+                const curie = shrinkIri(term, {
                     prefixMap: options.prefixMap,
                 }).extract();
                 if (curie) {