@shaclmate/compiler 2.0.12 → 2.0.14

package/generators/ts/ListType.d.ts

@@ -1,26 +1,36 @@
 import type { NamedNode } from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import { MintingStrategy } from "../../ast";
+import type { MintingStrategy } from "../../enums/index.js";
+import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class ListType extends Type {
     readonly itemType: Type;
     readonly kind = "ListType";
+    readonly mutable: boolean;
     private readonly identifierNodeKind;
     private readonly mintingStrategy;
-    private readonly rdfType;
-    constructor({ identifierNodeKind, itemType, mintingStrategy, rdfType, ...superParameters }: {
+    private readonly toRdfTypes;
+    constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType["identifierNodeKind"];
         itemType: Type;
         mintingStrategy: Maybe<MintingStrategy>;
-        rdfType: Maybe<NamedNode>;
+        mutable: boolean;
+        toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof Type>[0]);
+    get conversions(): readonly Type.Conversion[];
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get importStatements(): readonly string[];
+    get equalsFunction(): string;
+    get jsonName(): string;
     get name(): string;
-    chainSparqlGraphPatternExpression({ variables, }: Parameters<Type["chainSparqlGraphPatternExpression"]>[0]): Maybe<Type.SparqlGraphPatternsExpression>;
-    equalsFunction(): string;
+    get useImports(): readonly Import[];
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    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"]>;
+    sparqlConstructTemplateTriples({ variables, context, }: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
+    sparqlWherePatterns({ variables, context, }: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
     toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=ListType.d.ts.map

package/generators/ts/ListType.js

@@ -1,74 +1,228 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
-import { NodeKind } from "shacl-ast";
-import { MintingStrategy } from "../../ast";
+import { Import } from "./Import.js";
 import { Type } from "./Type.js";
+import { objectInitializer } from "./objectInitializer.js";
 export class ListType extends Type {
-    constructor({ identifierNodeKind, itemType, mintingStrategy, rdfType, ...superParameters }) {
+    constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }) {
         super(superParameters);
         this.kind = "ListType";
         this.identifierNodeKind = identifierNodeKind;
         this.itemType = itemType;
-        this.mintingStrategy = mintingStrategy.orDefault(MintingStrategy.SHA256);
-        this.rdfType = rdfType;
+        this.mintingStrategy = mintingStrategy.orDefault("sha256");
+        this.mutable = mutable;
+        this.toRdfTypes = toRdfTypes;
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `Array.isArray(${value})`,
+                sourceTypeName: this.name,
+            },
+        ];
     }
     get discriminatorProperty() {
         return Maybe.empty();
     }
-    get importStatements() {
-        if (this.identifierNodeKind === NodeKind.IRI) {
-            return ['import { sha256 } from "js-sha256";'];
-        }
-        return [];
+    get equalsFunction() {
+        return `((left, right) => purifyHelpers.Arrays.equals(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get jsonName() {
+        return `readonly (${this.itemType.jsonName})[]`;
     }
     get name() {
-        return `readonly ${this.itemType.name}[]`;
+        return `${this.mutable ? "" : "readonly "}${this.itemType.name}[]`;
     }
-    chainSparqlGraphPatternExpression({ variables, }) {
-        return Maybe.of(new Type.SparqlGraphPatternsExpression(`new sparqlBuilder.RdfListGraphPatterns({ ${this.itemType
-            .chainSparqlGraphPatternExpression({
-            variables: {
-                subject: "itemVariable",
-            },
-        })
-            .map((itemSparqlGraphPatternsExpression) => `itemGraphPatterns: (itemVariable) => ${itemSparqlGraphPatternsExpression.toSparqlGraphPatternsExpression()}, `)
-            .orDefault("")} rdfList: ${variables.subject} })`));
+    get useImports() {
+        const imports = this.itemType.useImports.concat();
+        if (this.identifierNodeKind === "NamedNode") {
+            imports.push(Import.SHA256);
+        }
+        return imports;
     }
-    equalsFunction() {
-        return `(left, right) => purifyHelpers.Arrays.equals(left, right, ${this.itemType.equalsFunction()})`;
+    fromJsonExpression({ variables, }) {
+        return `${variables.value}.map(_item => (${this.itemType.fromJsonExpression({ variables: { value: "_item" } })}))`;
     }
     fromRdfExpression({ variables, }) {
-        return `${variables.resourceValues}.head().chain(value => value.toList()).map(values => values.flatMap(value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "value.toValues()" } })}.toMaybe().toList()))`;
+        const chain = [variables.resourceValues];
+        chain.push("head()");
+        chain.push("chain(value => value.toList())");
+        chain.push(`map(values => values.flatMap(_value => ${this.itemType.fromRdfExpression({ variables: { ...variables, resourceValues: "_value.toValues()" } })}.toMaybe().toList()))`);
+        return chain.join(".");
     }
-    hashStatements({ variables, }) {
+    hashStatements({ depth, variables, }) {
         return [
-            `for (const element of ${variables.value}) { ${this.itemType.hashStatements({ variables: { ...variables, value: "element" } }).join("\n")} }`,
+            `for (const _element${depth} of ${variables.value}) { ${this.itemType.hashStatements({ depth: depth + 1, variables: { ...variables, value: `_element${depth}` } }).join("\n")} }`,
         ];
     }
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    jsonZodSchema(parameters) {
+        return `${this.itemType.jsonZodSchema(parameters)}.array()`;
+    }
+    sparqlConstructTemplateTriples({ variables, context, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlConstructTemplateTriples({ context, variables });
+            case "type": {
+                const triples = [];
+                const listVariable = variables.subject;
+                const variable = (suffix) => `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
+                const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
+                {
+                    // ?list rdf:first ?item0
+                    const item0Variable = variable("Item0");
+                    triples.push(objectInitializer({
+                        subject: listVariable,
+                        predicate: this.rdfjsTermExpression(rdf.first),
+                        object: item0Variable,
+                    }), ...this.itemType.sparqlConstructTemplateTriples({
+                        context: "type",
+                        variables: {
+                            subject: item0Variable,
+                            variablePrefix: variablePrefix("Item0"),
+                        },
+                    }));
+                }
+                {
+                    // ?list rdf:rest ?rest0
+                    const rest0Variable = variable("Rest0");
+                    triples.push(objectInitializer({
+                        subject: listVariable,
+                        predicate: this.rdfjsTermExpression(rdf.rest),
+                        object: rest0Variable,
+                    }));
+                }
+                // Don't do ?list rdf:rest+ ?restN in CONSTRUCT
+                const restNVariable = variable("RestN");
+                {
+                    // ?rest rdf:first ?itemN
+                    const itemNVariable = variable("ItemN");
+                    triples.push(objectInitializer({
+                        subject: restNVariable,
+                        predicate: this.rdfjsTermExpression(rdf.first),
+                        object: itemNVariable,
+                    }), ...this.itemType.sparqlConstructTemplateTriples({
+                        context: "type",
+                        variables: {
+                            subject: itemNVariable,
+                            variablePrefix: variablePrefix("ItemN"),
+                        },
+                    }));
+                }
+                // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
+                triples.push(objectInitializer({
+                    subject: restNVariable,
+                    predicate: this.rdfjsTermExpression(rdf.rest),
+                    object: variable("RestNBasic"),
+                }));
+                return triples;
+            }
+        }
+    }
+    sparqlWherePatterns({ variables, context, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlWherePatterns({ context, variables });
+            case "type": {
+                const patterns = [];
+                const listVariable = variables.subject;
+                const variable = (suffix) => `${this.dataFactoryVariable}.variable!(\`\${${variables.variablePrefix}}${suffix}\`)`;
+                const variablePrefix = (suffix) => `\`\${${variables.variablePrefix}}${suffix}\``;
+                {
+                    // ?list rdf:first ?item0
+                    const item0Variable = variable("Item0");
+                    patterns.push(`{ type: "bgp", triples: [${objectInitializer({
+                        subject: listVariable,
+                        predicate: this.rdfjsTermExpression(rdf.first),
+                        object: item0Variable,
+                    })}] }`, ...this.itemType.sparqlWherePatterns({
+                        context: "type",
+                        variables: {
+                            subject: item0Variable,
+                            variablePrefix: variablePrefix("Item0"),
+                        },
+                    }));
+                }
+                {
+                    // ?list rdf:rest ?rest0
+                    const rest0Variable = variable("Rest0");
+                    patterns.push(`{ type: "bgp", triples: [${objectInitializer({
+                        subject: listVariable,
+                        predicate: this.rdfjsTermExpression(rdf.rest),
+                        object: rest0Variable,
+                    })}] }`);
+                }
+                const optionalPatterns = [];
+                const restNVariable = variable("RestN");
+                // ?list rdf:rest+ ?restN
+                optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
+                    subject: listVariable,
+                    predicate: `{ type: "path", pathType: "*", items: [${this.rdfjsTermExpression(rdf.rest)}] }`,
+                    object: restNVariable,
+                })}] }`);
+                {
+                    // ?rest rdf:first ?itemN
+                    const itemNVariable = variable("ItemN");
+                    optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
+                        subject: restNVariable,
+                        predicate: this.rdfjsTermExpression(rdf.first),
+                        object: itemNVariable,
+                    })}] }`, ...this.itemType.sparqlConstructTemplateTriples({
+                        context: "type",
+                        variables: {
+                            subject: itemNVariable,
+                            variablePrefix: variablePrefix("ItemN"),
+                        },
+                    }));
+                }
+                // ?restN rdf:rest ?restNBasic to get the rdf:rest statement in the CONSTRUCT
+                optionalPatterns.push(`{ type: "bgp", triples: [${objectInitializer({
+                    subject: restNVariable,
+                    predicate: this.rdfjsTermExpression(rdf.rest),
+                    object: variable("RestNBasic"),
+                })}] }`);
+                patterns.push(`{ type: "optional", patterns: [${optionalPatterns.join(", ")}] }`);
+                return patterns;
+            }
+        }
+    }
+    toJsonExpression({ variables, }) {
+        let expression = variables.value;
+        const itemFromJsonExpression = this.itemType.fromJsonExpression({
+            variables: { value: "_item" },
+        });
+        if (itemFromJsonExpression !== "_item") {
+            expression = `${expression}.map(_item => (${itemFromJsonExpression}))`;
+        }
+        return `${variables.value}.map(_item => (${this.itemType.toJsonExpression({ variables: { value: "_item" } })}))`;
+    }
     toRdfExpression({ variables, }) {
         let listIdentifier;
         let mutableResourceTypeName;
         let resourceSetMethodName;
         let subListIdentifier;
         switch (this.identifierNodeKind) {
-            case NodeKind.BLANK_NODE: {
+            case "BlankNode": {
                 listIdentifier = subListIdentifier = "dataFactory.blankNode()";
                 mutableResourceTypeName = "rdfjsResource.MutableResource";
                 resourceSetMethodName = "mutableResource";
                 break;
             }
-            case NodeKind.IRI: {
+            case "NamedNode": {
                 switch (this.mintingStrategy) {
-                    case MintingStrategy.SHA256:
+                    case "sha256":
                         listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
-        (hasher, item) => {
-          ${this.itemType.hashStatements({ variables: { hasher: "hasher", value: "item" } })}
-          return hasher;
+        (_hasher, _item) => {
+          ${this.itemType.hashStatements({ depth: 0, variables: { hasher: "_hasher", value: "_item" } }).join("\n")}
+          return _hasher;
         },
         sha256.create(),
       )}\`)`;
                         break;
-                    case MintingStrategy.UUIDv4:
+                    case "uuidv4":
                         listIdentifier =
                             "dataFactory.namedNode(`urn:shaclmate:list:${uuid.v4()}`)";
                         break;
@@ -81,23 +235,23 @@ export class ListType extends Type {
                 break;
             }
         }
-        return `${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex) => {
+        return `${variables.value}.reduce(({ currentSubListResource, listResource }, item, itemIndex, list) => {
     if (itemIndex === 0) {
       currentSubListResource = listResource;
     } else {
-      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}({
-        identifier: ${subListIdentifier},
-        mutateGraph: ${variables.mutateGraph},
-      });
+      const newSubListResource = ${variables.resourceSet}.${resourceSetMethodName}(${objectInitializer({
+            identifier: subListIdentifier,
+            mutateGraph: variables.mutateGraph,
+        })});
       currentSubListResource!.add(dataFactory.namedNode("${rdf.rest.value}"), newSubListResource.identifier);
       currentSubListResource = newSubListResource;
     }
     
-    ${this.rdfType.map((rdfType) => `currentSubListResource.add(dataFactory.namedNode("${rdf.type.value}"), dataFactory.namedNode("${rdfType.value}"))`).orDefault("")}
+    ${this.toRdfTypes.map((rdfType) => `currentSubListResource.add(dataFactory.namedNode("${rdf.type.value}"), dataFactory.namedNode("${rdfType.value}"))`).join("\n")}
         
     currentSubListResource.add(dataFactory.namedNode("${rdf.first.value}"), ${this.itemType.toRdfExpression({ variables: { mutateGraph: variables.mutateGraph, predicate: `dataFactory.namedNode("${rdf.first.value}")`, resource: "currentSubListResource", resourceSet: variables.resourceSet, value: "item" } })});
 
-    if (itemIndex + 1 === ${variables.value}.length) {
+    if (itemIndex + 1 === list.length) {
       currentSubListResource.add(dataFactory.namedNode("${rdf.rest.value}"), dataFactory.namedNode("${rdf.nil.value}"));
     }
     
@@ -105,10 +259,10 @@ export class ListType extends Type {
   },
   {
     currentSubListResource: null,
-    listResource: resourceSet.${resourceSetMethodName}({
-      identifier: ${listIdentifier},
-      mutateGraph: ${variables.mutateGraph}
-    }),
+    listResource: resourceSet.${resourceSetMethodName}(${objectInitializer({
+            identifier: listIdentifier,
+            mutateGraph: variables.mutateGraph,
+        })}),
   } as {
     currentSubListResource: ${mutableResourceTypeName} | null;
     listResource: ${mutableResourceTypeName};

package/generators/ts/LiteralType.d.ts

@@ -1,14 +1,16 @@
 import type { Literal } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { RdfjsTermType } from "./RdfjsTermType.js";
-import type { Type } from "./Type";
-export declare class LiteralType extends RdfjsTermType<Literal> {
-    readonly kind = "LiteralType";
-    get conversions(): readonly Type.Conversion[];
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get importStatements(): readonly string[];
-    get name(): string;
-    fromRdfResourceValueExpression({ variables, }: Parameters<RdfjsTermType<Literal>["fromRdfResourceValueExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<RdfjsTermType<Literal>["hashStatements"]>[0]): readonly string[];
+import { TermType } from "./TermType.js";
+export declare class LiteralType extends TermType<Literal> {
+    private readonly languageIn;
+    constructor({ languageIn, ...superParameters }: {
+        languageIn: readonly string[];
+    } & Omit<ConstructorParameters<typeof TermType<Literal>>[0], "nodeKinds">);
+    get jsonName(): string;
+    fromJsonExpression({ variables, }: Parameters<TermType<Literal>["fromJsonExpression"]>[0]): string;
+    hashStatements({ depth, variables, }: Parameters<TermType<Literal>["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<TermType<Literal>["jsonZodSchema"]>[0]): ReturnType<TermType<Literal>["jsonZodSchema"]>;
+    propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<Literal>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    toJsonExpression({ variables, }: Parameters<TermType<Literal>["toJsonExpression"]>[0]): string;
+    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<TermType<Literal>["propertyFilterRdfResourceValuesExpression"]>[0]): string;
 }
 //# sourceMappingURL=LiteralType.d.ts.map

package/generators/ts/LiteralType.js

@@ -1,61 +1,46 @@
-import { Maybe } from "purify-ts";
-import { RdfjsTermType } from "./RdfjsTermType.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression";
-export class LiteralType extends RdfjsTermType {
-    constructor() {
-        super(...arguments);
-        this.kind = "LiteralType";
-    }
-    get conversions() {
-        const conversions = [];
-        conversions.push({
-            conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
-            sourceTypeName: "boolean",
+import { xsd } from "@tpluscode/rdf-ns-builders";
+import { TermType } from "./TermType.js";
+export class LiteralType extends TermType {
+    constructor({ languageIn, ...superParameters }) {
+        super({
+            ...superParameters,
+            nodeKinds: new Set(["Literal"]),
         });
-        conversions.push({
-            conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
-            sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
-            sourceTypeName: "Date",
-        });
-        conversions.push({
-            conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
-            sourceTypeName: "number",
-        });
-        conversions.push({
-            conversionExpression: (value) => `${this.configuration.dataFactoryVariable}.literal(${value})`,
-            sourceTypeName: "string",
-        });
-        this.defaultValue.ifJust((defaultValue) => {
-            conversions.push({
-                conversionExpression: () => rdfjsTermExpression(defaultValue, this.configuration),
-                sourceTypeName: "undefined",
-            });
-        });
-        conversions.push({
-            conversionExpression: (value) => value,
-            sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
-            sourceTypeName: this.name,
-        });
-        return conversions;
+        this.languageIn = languageIn;
     }
-    get discriminatorProperty() {
-        return Maybe.of({
-            name: "termType",
-            type: "string",
-            values: ["Literal"],
-        });
+    get jsonName() {
+        return '{ readonly "@language": string | undefined, readonly "@type": string | undefined, readonly "@value": string }';
     }
-    get importStatements() {
-        return ["// @ts-ignore", 'import * as rdfLiteral from "rdf-literal";'];
+    fromJsonExpression({ variables, }) {
+        return `${this.dataFactoryVariable}.literal(${variables.value}["@value"], typeof ${variables.value}["@language"] !== "undefined" ? ${variables.value}["@language"] : (typeof ${variables.value}["@type"] !== "undefined" ? dataFactory.namedNode(${variables.value}["@type"]) : undefined))`;
     }
-    get name() {
-        return "rdfjs.Literal";
+    hashStatements({ depth, variables, }) {
+        return [
+            `${variables.hasher}.update(${variables.value}.datatype.value);`,
+            `${variables.hasher}.update(${variables.value}.language);`,
+        ].concat(super.hashStatements({ depth, variables }));
     }
-    fromRdfResourceValueExpression({ variables, }) {
+    jsonZodSchema({ variables, }) {
+        return `${variables.zod}.object({ "@language": ${variables.zod}.string().optional(), "@type": ${variables.zod}.string().optional(), "@value": ${variables.zod}.string() })`;
+    }
+    propertyFromRdfResourceValueExpression({ variables, }) {
         return `${variables.resourceValue}.toLiteral()`;
     }
-    hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value}.value);`];
+    toJsonExpression({ variables, }) {
+        return `{ "@language": ${variables.value}.language.length > 0 ? ${variables.value}.language : undefined, "@type": ${variables.value}.datatype.value !== "${xsd.string.value}" ? ${variables.value}.datatype.value : undefined, "@value": ${variables.value}.value }`;
+    }
+    propertyFilterRdfResourceValuesExpression({ variables, }) {
+        return `${variables.resourceValues}.filter(_value => {
+  const _languageInOrDefault = ${variables.languageIn} ?? ${JSON.stringify(this.languageIn)};
+  if (_languageInOrDefault.length === 0) {
+    return true;
+  }
+  const _valueLiteral = _value.toLiteral().toMaybe().extract();
+  if (typeof _valueLiteral === "undefined") {
+    return false;
+  }
+  return _languageInOrDefault.some(_languageIn => _languageIn === _valueLiteral.language);
+})`;
     }
 }
 //# sourceMappingURL=LiteralType.js.map

package/generators/ts/NumberType.d.ts

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

package/generators/ts/NumberType.js

@@ -1,13 +1,64 @@
+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 NumberType extends PrimitiveType {
+    constructor() {
+        super(...arguments);
+        this.kind = "NumberType";
+    }
+    get conversions() {
+        const conversions = [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
+                sourceTypeName: this.name,
+            },
+        ];
+        this.primitiveDefaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => defaultValue.toString(),
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+        });
+        return conversions;
+    }
     get name() {
+        if (this.primitiveIn.length > 0) {
+            return this.primitiveIn.map((value) => value.toString()).join(" | ");
+        }
         return "number";
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        return `${variables.resourceValue}.toNumber()`;
+    jsonZodSchema({ variables, }) {
+        switch (this.primitiveIn.length) {
+            case 0:
+                return `${variables.zod}.number()`;
+            case 1:
+                return `${variables.zod}.literal(${this.primitiveIn[0]})`;
+            default:
+                return `${variables.zod}.union([${this.primitiveIn.map((value) => `${variables.zod}.literal(${value})`).join(", ")}])`;
+        }
+    }
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        let expression = `${variables.resourceValue}.toNumber()`;
+        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;
     }
-    hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value}.toString());`];
+    toRdfExpression({ variables, }) {
+        return this.primitiveDefaultValue
+            .map((defaultValue) => `${variables.value} !== ${defaultValue} ? ${variables.value} : undefined`)
+            .orDefault(variables.value);
     }
 }
+__decorate([
+    Memoize()
+], NumberType.prototype, "name", null);
 //# sourceMappingURL=NumberType.js.map