@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/PrimitiveType.js

@@ -1,41 +1,37 @@
 import { Maybe } from "purify-ts";
-import { fromRdf } from "rdf-literal";
 import { LiteralType } from "./LiteralType.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 export class PrimitiveType extends LiteralType {
-    get conversions() {
-        const conversions = [
-            {
-                conversionExpression: (value) => value,
-                sourceTypeName: this.name,
-            },
-        ];
-        this.defaultValue.ifJust((defaultValue) => {
-            conversions.push({
-                conversionExpression: () => fromRdf(defaultValue, true),
-                sourceTypeName: "undefined",
-            });
-        });
-        return conversions;
+    constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }) {
+        super(superParameters);
+        this.equalsFunction = "strictEquals";
+        this.primitiveDefaultValue = primitiveDefaultValue;
+        this.primitiveIn = primitiveIn;
     }
     get discriminatorProperty() {
         return Maybe.empty();
     }
-    get importStatements() {
-        return [];
-    }
-    equalsFunction() {
-        return "purifyHelpers.Equatable.strictEquals";
-    }
-    toRdfExpression({ variables, }) {
-        return this.defaultValue
-            .map((defaultValue) => {
-            let primitiveDefaultValue = fromRdf(defaultValue, true);
-            if (typeof primitiveDefaultValue === "string") {
-                primitiveDefaultValue = `"${primitiveDefaultValue}"`;
-            }
-            return `${variables.value} !== ${primitiveDefaultValue} ? ${variables.value} : undefined`;
-        })
-            .orDefault(variables.value);
+    get jsonName() {
+        return this.name;
+    }
+    fromJsonExpression({ variables, }) {
+        return variables.value;
+    }
+    hashStatements({ variables, }) {
+        return [`${variables.hasher}.update(${variables.value}.toString());`];
+    }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.strictEquals);
+        }
+        return snippetDeclarations;
+    }
+    toJsonExpression({ variables, }) {
+        return variables.value;
+    }
+    propertyFilterRdfResourceValuesExpression({ variables, }) {
+        return variables.resourceValues;
     }
 }
 //# sourceMappingURL=PrimitiveType.js.map

package/generators/ts/SetType.d.ts

@@ -1,3 +1,5 @@
+import type { TsFeature } from "../../enums/index.js";
+import type { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class SetType extends Type {
     readonly itemType: Type;
@@ -8,12 +10,20 @@ export declare class SetType extends Type {
         minCount: number;
     });
     get conversions(): readonly Type.Conversion[];
+    get equalsFunction(): string;
+    get jsonName(): string;
+    get mutable(): boolean;
     get name(): string;
-    chainSparqlGraphPatternExpression(parameters: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): ReturnType<Type["chainSparqlGraphPatternExpression"]>;
-    equalsFunction(): string;
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    propertySparqlGraphPatternExpression(parameters: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression | Type.SparqlGraphPatternsExpression;
+    hashStatements({ depth, variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonUiSchemaElement(parameters: Parameters<Type["jsonUiSchemaElement"]>[0]): ReturnType<Type["jsonUiSchemaElement"]>;
+    jsonZodSchema(parameters: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
+    sparqlConstructTemplateTriples({ context, variables, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns({ context, variables, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(features: Set<TsFeature>): readonly Import[];
 }
 //# sourceMappingURL=SetType.d.ts.map

package/generators/ts/SetType.js

@@ -4,70 +4,148 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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 { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
+import { objectInitializer } from "./objectInitializer.js";
 export class SetType extends Type {
     constructor({ itemType, minCount, ...superParameters }) {
         super(superParameters);
         this.kind = "SetType";
         this.itemType = itemType;
         this.minCount = minCount;
+        invariant(this.minCount >= 0);
     }
     get conversions() {
-        return [
-            {
+        const conversions = [];
+        if (this.minCount === 0) {
+            conversions.push({
                 conversionExpression: () => "[]",
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
                 sourceTypeName: "undefined",
-            },
-            {
+            });
+            conversions.push({
                 conversionExpression: (value) => value,
                 sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                sourceTypeName: `readonly (${this.itemType.name})[]`,
+            });
+        }
+        else {
+            conversions.push({
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `purify.NonEmptyList.isNonEmpty(${value})`,
                 sourceTypeName: this.name,
-            },
-        ];
+            });
+        }
+        return conversions;
     }
-    get name() {
-        return `readonly (${this.itemType.name})[]`;
+    get equalsFunction() {
+        return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
     }
-    chainSparqlGraphPatternExpression(parameters) {
-        return this.itemType.chainSparqlGraphPatternExpression(parameters);
+    get jsonName() {
+        if (this.minCount === 0) {
+            return `readonly (${this.itemType.jsonName})[]`;
+        }
+        return `purify.NonEmptyList<${this.itemType.jsonName}>`;
+    }
+    get mutable() {
+        return this.itemType.mutable;
     }
-    equalsFunction() {
-        const itemTypeEqualsFunction = this.itemType.equalsFunction();
-        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.equals") {
-            return "purifyHelpers.Equatable.arrayEquals";
+    get name() {
+        if (this.minCount === 0) {
+            return `readonly (${this.itemType.name})[]`;
         }
-        return `(left, right) => purifyHelpers.Arrays.equals(left, right, ${itemTypeEqualsFunction})`;
+        return `purify.NonEmptyList<${this.itemType.name}>`;
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = variables.value;
+        if (this.minCount > 0) {
+            expression = `purify.NonEmptyList.fromArray(${expression}).unsafeCoerce()`;
+        }
+        const itemFromJsonExpression = this.itemType.fromJsonExpression({
+            variables: { value: "_item" },
+        });
+        return itemFromJsonExpression === "_item"
+            ? expression
+            : `${expression}.map(_item => (${itemFromJsonExpression}))`;
     }
     fromRdfExpression({ variables, }) {
-        return `purify.Either.of([...${variables.resourceValues}.flatMap(value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "value.toValues()" } })}.toMaybe().toList())])`;
+        const itemFromRdfExpression = this.itemType.fromRdfExpression({
+            variables: { ...variables, resourceValues: "_item.toValues()" },
+        });
+        if (this.minCount === 0) {
+            return `purify.Either.of([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())])`;
+        }
+        return `purify.NonEmptyList.fromArray([...${variables.resourceValues}.flatMap(_item => ${itemFromRdfExpression}.toMaybe().toList())]).toEither(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} is empty\``, predicate: variables.predicate })}))`;
     }
-    hashStatements({ variables, }) {
+    hashStatements({ depth, variables, }) {
         return [
-            `for (const element of ${variables.value}) { ${this.itemType
+            `for (const _item${depth} of ${variables.value}) { ${this.itemType
                 .hashStatements({
+                depth: depth + 1,
                 variables: {
                     hasher: variables.hasher,
-                    value: "element",
+                    value: `_item${depth}`,
                 },
             })
                 .join("\n")} }`,
         ];
     }
-    propertySparqlGraphPatternExpression(parameters) {
-        if (this.minCount === 0) {
-            return new Type.SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.optional(${this.itemType.propertySparqlGraphPatternExpression(parameters).toSparqlGraphPatternExpression()})`);
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    jsonZodSchema(parameters) {
+        let schema = `${this.itemType.jsonZodSchema(parameters)}.array()`;
+        if (this.minCount > 0) {
+            schema = `${schema}.nonempty().min(${this.minCount})`;
         }
-        return this.itemType.propertySparqlGraphPatternExpression(parameters);
+        return schema;
     }
-    toRdfExpression({ variables, }) {
-        const itemTypeToRdfExpression = this.itemType.toRdfExpression({
-            variables: { ...variables, value: "value" },
-        });
-        if (itemTypeToRdfExpression === "value") {
-            return variables.value;
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }
-        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
+        return snippetDeclarations;
+    }
+    sparqlConstructTemplateTriples({ context, variables, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlConstructTemplateTriples({ context, variables });
+            case "type":
+                return this.itemType.sparqlConstructTemplateTriples({
+                    context,
+                    variables,
+                });
+        }
+    }
+    sparqlWherePatterns({ context, variables, }) {
+        switch (context) {
+            case "property": {
+                const patterns = super.sparqlWherePatterns({ context, variables });
+                if (patterns.length === 0) {
+                    return [];
+                }
+                return this.minCount > 0
+                    ? patterns
+                    : [`{ patterns: [${patterns.join(", ")}], type: "optional" }`];
+            }
+            case "type": {
+                return this.itemType.sparqlWherePatterns({ context, variables });
+            }
+        }
+    }
+    toJsonExpression({ variables, }) {
+        return `${variables.value}.map(_item => (${this.itemType.toJsonExpression({ variables: { value: "_item" } })}))`;
+    }
+    toRdfExpression({ variables, }) {
+        return `${variables.value}.map((_item) => ${this.itemType.toRdfExpression({
+            variables: { ...variables, value: "_item" },
+        })})`;
+    }
+    useImports(features) {
+        return this.itemType.useImports(features);
     }
 }
 __decorate([

package/generators/ts/SnippetDeclarations.d.ts

@@ -0,0 +1,11 @@
+export declare namespace SnippetDeclarations {
+    const arrayEquals = "export function arrayEquals<T>(\n  leftArray: readonly T[],\n  rightArray: readonly T[],\n  elementEquals: (left: T, right: T) => boolean | EqualsResult,\n): EqualsResult {\n  if (leftArray.length !== rightArray.length) {\n    return purify.Left({\n      left: leftArray,\n      right: rightArray,\n      type: \"ArrayLength\",\n    });\n  }\n\n  for (\n    let leftElementIndex = 0;\n    leftElementIndex < leftArray.length;\n    leftElementIndex++\n  ) {\n    const leftElement = leftArray[leftElementIndex];\n\n    const rightUnequals: EqualsResult.Unequal[] = [];\n    for (\n      let rightElementIndex = 0;\n      rightElementIndex < rightArray.length;\n      rightElementIndex++\n    ) {\n      const rightElement = rightArray[rightElementIndex];\n\n      const leftElementEqualsRightElement =\n        EqualsResult.fromBooleanEqualsResult(\n          leftElement,\n          rightElement,\n          elementEquals(leftElement, rightElement),\n        );\n      if (leftElementEqualsRightElement.isRight()) {\n        break; // left element === right element, break out of the right iteration\n      }\n      rightUnequals.push(\n        leftElementEqualsRightElement.extract() as EqualsResult.Unequal,\n      );\n    }\n\n    if (rightUnequals.length === rightArray.length) {\n      // All right elements were unequal to the left element\n      return purify.Left({\n        left: {\n          array: leftArray,\n          element: leftElement,\n          elementIndex: leftElementIndex,\n        },\n        right: {\n          array: rightArray,\n          unequals: rightUnequals,\n        },\n        type: \"ArrayElement\",\n      });\n    }\n    // Else there was a right element equal to the left element, continue to the next left element\n  }\n\n  return EqualsResult.Equal;\n}\n";
+    const booleanEquals = "/**\n * Compare two objects with equals(other: T): boolean methods and return an EqualsResult.\n */\nexport function booleanEquals<T extends { equals: (other: T) => boolean }>(\n  left: T,\n  right: T,\n): EqualsResult {\n  return EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.equals(right),\n  );\n}";
+    const dateEquals = "/**\n * Compare two Dates and return an EqualsResult.\n */\nexport function dateEquals(left: Date, right: Date): EqualsResult {\n  return EqualsResult.fromBooleanEqualsResult(\n    left,\n    right,\n    left.getTime() === right.getTime(),\n  );\n}";
+    const EqualsResult = "export type EqualsResult = purify.Either<EqualsResult.Unequal, true>;\n\nexport namespace EqualsResult {\n    export const Equal: EqualsResult = purify.Either.of<Unequal, true>(true);\n\n    export function fromBooleanEqualsResult(\n      left: any,\n      right: any,\n      equalsResult: boolean | EqualsResult,\n    ): EqualsResult {\n      if (typeof equalsResult !== \"boolean\") {\n        return equalsResult;\n      }\n\n      if (equalsResult) {\n        return Equal;\n      }\n      return purify.Left({\n        left,\n        right,\n        type: \"BooleanEquals\",\n      });\n    }\n\n    export type Unequal =\n      | {\n          readonly left: {\n            readonly array: readonly any[];\n            readonly element: any;\n            readonly elementIndex: number;\n          };\n          readonly right: {\n            readonly array: readonly any[];\n            readonly unequals: readonly Unequal[];\n          };\n          readonly type: \"ArrayElement\";\n        }\n      | {\n          readonly left: readonly any[];\n          readonly right: readonly any[];\n          readonly type: \"ArrayLength\";\n        }\n      | {\n          readonly left: any;\n          readonly right: any;\n          readonly type: \"BooleanEquals\";\n        }\n      | {\n          readonly left: any;\n          readonly right: any;\n          readonly type: \"LeftError\";\n        }\n      | {\n          readonly right: any;\n          readonly type: \"LeftNull\";\n        }\n      | {\n          readonly left: bigint | boolean | number | string;\n          readonly right: bigint | boolean | number | string;\n          readonly type: \"Primitive\";\n        }\n      | {\n          readonly left: object;\n          readonly right: object;\n          readonly propertyName: string;\n          readonly propertyValuesUnequal: Unequal;\n          readonly type: \"Property\";\n        }\n      | {\n          readonly left: any;\n          readonly right: any;\n          readonly type: \"RightError\";\n        }\n      | {\n          readonly left: any;\n          readonly type: \"RightNull\";\n        };\n}    \n";
+    const maybeEquals = "export function maybeEquals<T>(\n  leftMaybe: purify.Maybe<T>,\n  rightMaybe: purify.Maybe<T>,\n  valueEquals: (left: T, right: T) => boolean | EqualsResult,\n): EqualsResult {\n  if (leftMaybe.isJust()) {\n    if (rightMaybe.isJust()) {\n      return EqualsResult.fromBooleanEqualsResult(\n        leftMaybe,\n        rightMaybe,\n        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),\n      );\n    }\n    return purify.Left({\n      left: leftMaybe.unsafeCoerce(),\n      type: \"RightNull\",\n    });\n  }\n\n  if (rightMaybe.isJust()) {\n    return purify.Left({\n      right: rightMaybe.unsafeCoerce(),\n      type: \"LeftNull\",\n    });\n  }\n\n  return EqualsResult.Equal;\n}\n";
+    const strictEquals = "/**\n * Compare two values for strict equality (===), returning an EqualsResult rather than a boolean.\n */\nexport function strictEquals<T extends bigint | boolean | number | string>(\n  left: T,\n  right: T,\n): EqualsResult {\n  return EqualsResult.fromBooleanEqualsResult(left, right, left === right);\n}";
+    const UnwrapL = "type UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never";
+    const UnwrapR = "type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never";
+}
+//# sourceMappingURL=SnippetDeclarations.d.ts.map

package/generators/ts/SnippetDeclarations.js

@@ -0,0 +1,215 @@
+export var SnippetDeclarations;
+(function (SnippetDeclarations) {
+    SnippetDeclarations.arrayEquals = `\
+export function arrayEquals<T>(
+  leftArray: readonly T[],
+  rightArray: readonly T[],
+  elementEquals: (left: T, right: T) => boolean | EqualsResult,
+): EqualsResult {
+  if (leftArray.length !== rightArray.length) {
+    return purify.Left({
+      left: leftArray,
+      right: rightArray,
+      type: "ArrayLength",
+    });
+  }
+
+  for (
+    let leftElementIndex = 0;
+    leftElementIndex < leftArray.length;
+    leftElementIndex++
+  ) {
+    const leftElement = leftArray[leftElementIndex];
+
+    const rightUnequals: EqualsResult.Unequal[] = [];
+    for (
+      let rightElementIndex = 0;
+      rightElementIndex < rightArray.length;
+      rightElementIndex++
+    ) {
+      const rightElement = rightArray[rightElementIndex];
+
+      const leftElementEqualsRightElement =
+        EqualsResult.fromBooleanEqualsResult(
+          leftElement,
+          rightElement,
+          elementEquals(leftElement, rightElement),
+        );
+      if (leftElementEqualsRightElement.isRight()) {
+        break; // left element === right element, break out of the right iteration
+      }
+      rightUnequals.push(
+        leftElementEqualsRightElement.extract() as EqualsResult.Unequal,
+      );
+    }
+
+    if (rightUnequals.length === rightArray.length) {
+      // All right elements were unequal to the left element
+      return purify.Left({
+        left: {
+          array: leftArray,
+          element: leftElement,
+          elementIndex: leftElementIndex,
+        },
+        right: {
+          array: rightArray,
+          unequals: rightUnequals,
+        },
+        type: "ArrayElement",
+      });
+    }
+    // Else there was a right element equal to the left element, continue to the next left element
+  }
+
+  return EqualsResult.Equal;
+}
+`;
+    SnippetDeclarations.booleanEquals = `\
+/**
+ * Compare two objects with equals(other: T): boolean methods and return an EqualsResult.
+ */
+export function booleanEquals<T extends { equals: (other: T) => boolean }>(
+  left: T,
+  right: T,
+): EqualsResult {
+  return EqualsResult.fromBooleanEqualsResult(
+    left,
+    right,
+    left.equals(right),
+  );
+}`;
+    SnippetDeclarations.dateEquals = `\
+/**
+ * Compare two Dates and return an EqualsResult.
+ */
+export function dateEquals(left: Date, right: Date): EqualsResult {
+  return EqualsResult.fromBooleanEqualsResult(
+    left,
+    right,
+    left.getTime() === right.getTime(),
+  );
+}`;
+    SnippetDeclarations.EqualsResult = `\
+export type EqualsResult = purify.Either<EqualsResult.Unequal, true>;
+
+export namespace EqualsResult {
+    export const Equal: EqualsResult = purify.Either.of<Unequal, true>(true);
+
+    export function fromBooleanEqualsResult(
+      left: any,
+      right: any,
+      equalsResult: boolean | EqualsResult,
+    ): EqualsResult {
+      if (typeof equalsResult !== "boolean") {
+        return equalsResult;
+      }
+
+      if (equalsResult) {
+        return Equal;
+      }
+      return purify.Left({
+        left,
+        right,
+        type: "BooleanEquals",
+      });
+    }
+
+    export type Unequal =
+      | {
+          readonly left: {
+            readonly array: readonly any[];
+            readonly element: any;
+            readonly elementIndex: number;
+          };
+          readonly right: {
+            readonly array: readonly any[];
+            readonly unequals: readonly Unequal[];
+          };
+          readonly type: "ArrayElement";
+        }
+      | {
+          readonly left: readonly any[];
+          readonly right: readonly any[];
+          readonly type: "ArrayLength";
+        }
+      | {
+          readonly left: any;
+          readonly right: any;
+          readonly type: "BooleanEquals";
+        }
+      | {
+          readonly left: any;
+          readonly right: any;
+          readonly type: "LeftError";
+        }
+      | {
+          readonly right: any;
+          readonly type: "LeftNull";
+        }
+      | {
+          readonly left: bigint | boolean | number | string;
+          readonly right: bigint | boolean | number | string;
+          readonly type: "Primitive";
+        }
+      | {
+          readonly left: object;
+          readonly right: object;
+          readonly propertyName: string;
+          readonly propertyValuesUnequal: Unequal;
+          readonly type: "Property";
+        }
+      | {
+          readonly left: any;
+          readonly right: any;
+          readonly type: "RightError";
+        }
+      | {
+          readonly left: any;
+          readonly type: "RightNull";
+        };
+}    
+`;
+    SnippetDeclarations.maybeEquals = `\
+export function maybeEquals<T>(
+  leftMaybe: purify.Maybe<T>,
+  rightMaybe: purify.Maybe<T>,
+  valueEquals: (left: T, right: T) => boolean | EqualsResult,
+): EqualsResult {
+  if (leftMaybe.isJust()) {
+    if (rightMaybe.isJust()) {
+      return EqualsResult.fromBooleanEqualsResult(
+        leftMaybe,
+        rightMaybe,
+        valueEquals(leftMaybe.unsafeCoerce(), rightMaybe.unsafeCoerce()),
+      );
+    }
+    return purify.Left({
+      left: leftMaybe.unsafeCoerce(),
+      type: "RightNull",
+    });
+  }
+
+  if (rightMaybe.isJust()) {
+    return purify.Left({
+      right: rightMaybe.unsafeCoerce(),
+      type: "LeftNull",
+    });
+  }
+
+  return EqualsResult.Equal;
+}
+`;
+    SnippetDeclarations.strictEquals = `\
+/**
+ * Compare two values for strict equality (===), returning an EqualsResult rather than a boolean.
+ */
+export function strictEquals<T extends bigint | boolean | number | string>(
+  left: T,
+  right: T,
+): EqualsResult {
+  return EqualsResult.fromBooleanEqualsResult(left, right, left === right);
+}`;
+    SnippetDeclarations.UnwrapL = "type UnwrapL<T> = T extends purify.Either<infer L, any> ? L : never";
+    SnippetDeclarations.UnwrapR = "type UnwrapR<T> = T extends purify.Either<any, infer R> ? R : never";
+})(SnippetDeclarations || (SnippetDeclarations = {}));
+//# sourceMappingURL=SnippetDeclarations.js.map

package/generators/ts/StringType.d.ts

@@ -1,7 +1,12 @@
 import { PrimitiveType } from "./PrimitiveType.js";
-export declare class StringType extends PrimitiveType {
+import type { Type } from "./Type.js";
+export declare class StringType extends PrimitiveType<string> {
+    readonly kind = "StringType";
+    get conversions(): readonly Type.Conversion[];
     get name(): string;
-    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType["fromRdfResourceValueExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<PrimitiveType["hashStatements"]>[0]): readonly string[];
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<string>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=StringType.d.ts.map

package/generators/ts/StringType.js

@@ -1,13 +1,67 @@
+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 { PrimitiveType } from "./PrimitiveType.js";
+import { objectInitializer } from "./objectInitializer.js";
 export class StringType extends PrimitiveType {
+    constructor() {
+        super(...arguments);
+        this.kind = "StringType";
+    }
+    get conversions() {
+        const conversions = [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "string"`,
+                sourceTypeName: this.name,
+            },
+        ];
+        this.primitiveDefaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => `"${defaultValue}"`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+        });
+        return conversions;
+    }
     get name() {
+        if (this.primitiveIn.length > 0) {
+            return this.primitiveIn.map((value) => `"${value}"`).join(" | ");
+        }
         return "string";
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        return `${variables.resourceValue}.toString()`;
-    }
     hashStatements({ variables, }) {
         return [`${variables.hasher}.update(${variables.value});`];
     }
+    jsonZodSchema({ variables, }) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return `${variables.zod}.string()`;
+            case 1:
+                return `${variables.zod}.literal(${this.primitiveIn[0]})`;
+            default:
+                return `${variables.zod}.enum(${JSON.stringify(this.primitiveIn)})`;
+        }
+    }
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        let expression = `${variables.resourceValue}.toString()`;
+        if (this.primitiveIn.length > 0) {
+            expression = `${expression}.chain(value => { switch (value) { ${this.primitiveIn.map((value) => `case "${value}":`).join(" ")} return purify.Either.of(value); default: return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); } })`;
+        }
+        return expression;
+    }
+    toRdfExpression({ variables, }) {
+        return this.primitiveDefaultValue
+            .map((defaultValue) => `${variables.value} !== "${defaultValue}" ? ${variables.value} : undefined`)
+            .orDefault(variables.value);
+    }
 }
+__decorate([
+    Memoize()
+], StringType.prototype, "name", null);
 //# sourceMappingURL=StringType.js.map

package/generators/ts/TermType.d.ts

@@ -0,0 +1,54 @@
+import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/index.js";
+import { Import } from "./Import.js";
+import { Type } from "./Type.js";
+/**
+ * Abstract base class for IdentifierType and LiteralType.
+ */
+export declare class TermType<TermT extends BlankNode | Literal | NamedNode> extends Type {
+    readonly defaultValue: Maybe<TermT>;
+    readonly equalsFunction: string;
+    readonly hasValues: readonly TermT[];
+    readonly in_: readonly TermT[];
+    readonly mutable: boolean;
+    readonly nodeKinds: Set<TermT["termType"]>;
+    constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }: {
+        defaultValue: Maybe<TermT>;
+        hasValues: readonly TermT[];
+        in_: readonly TermT[];
+        nodeKinds: Set<TermT["termType"]>;
+    } & ConstructorParameters<typeof Type>[0]);
+    get conversions(): readonly Type.Conversion[];
+    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
+    get jsonName(): string;
+    get name(): string;
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
+    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
+    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
+    useImports(): readonly Import[];
+    /**
+     * Filter the rdfjsResource.Resource.Values to those that are relevant to the type.
+     *
+     * This is done before
+     */
+    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    /**
+     * Convert an rdfjsResource.Resource.Value to a value of this type.
+     * @param variables
+     * @protected
+     */
+    protected propertyFromRdfResourceValueExpression({ variables, }: {
+        variables: {
+            predicate: string;
+            resource: string;
+            resourceValue: string;
+        };
+    }): string;
+}
+//# sourceMappingURL=TermType.d.ts.map