@shaclmate/compiler 2.0.13 → 2.0.15

package/generators/ts/ObjectUnionType.js

@@ -0,0 +1,450 @@
+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 { camelCase, pascalCase } from "change-case";
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+import { StructureKind, } from "ts-morph";
+import { Memoize } from "typescript-memoize";
+import { DeclaredType } from "./DeclaredType.js";
+import { hasherTypeConstraint } from "./_ObjectType/hashFunctionOrMethodDeclaration.js";
+import { sparqlConstructQueryFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryFunctionDeclaration.js";
+import { sparqlConstructQueryStringFunctionDeclaration } from "./_ObjectType/sparqlConstructQueryStringFunctionDeclaration.js";
+import { objectInitializer } from "./objectInitializer.js";
+import { tsComment } from "./tsComment.js";
+/**
+ * A union of object types, generated as a type alias
+ *
+ *   type SomeUnion = Member1 | Member2 | ...
+ *
+ * with associated functions that switch on the type discriminator property and delegate to the appropriate
+ * member type code.
+ *
+ * It also generates SPARQL graph patterns that UNION the member object types.
+ */
+export class ObjectUnionType extends DeclaredType {
+    constructor({ comment, label, memberTypes, ...superParameters }) {
+        super(superParameters);
+        this.kind = "ObjectUnionType";
+        this.comment = comment;
+        this.label = label;
+        invariant(memberTypes.length > 0);
+        this.memberTypes = memberTypes;
+        const discriminatorPropertyName = memberTypes[0].discriminatorProperty.unsafeCoerce().name;
+        const discriminatorPropertyValues = [];
+        for (const memberType of this.memberTypes) {
+            invariant(memberType.declarationType === memberTypes[0].declarationType);
+            invariant(memberType._discriminatorProperty.name === discriminatorPropertyName);
+            discriminatorPropertyValues.push(...memberType._discriminatorProperty.values);
+        }
+        this._discriminatorProperty = {
+            name: discriminatorPropertyName,
+            values: discriminatorPropertyValues,
+        };
+    }
+    get conversions() {
+        return [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object"`,
+                sourceTypeName: this.name,
+            },
+        ];
+    }
+    get declarationImports() {
+        return this.memberTypes.flatMap((memberType) => memberType.useImports(this.features));
+    }
+    get declarations() {
+        const declarations = [this.typeAliasDeclaration];
+        const moduleStatements = [
+            ...this.equalsFunctionDeclaration.toList(),
+            ...this.fromJsonFunctionDeclaration.toList(),
+            ...this.fromRdfFunctionDeclaration.toList(),
+            ...this.hashFunctionDeclaration.toList(),
+            ...this.jsonZodSchemaFunctionDeclaration.toList(),
+            ...this.sparqlFunctionDeclarations,
+            ...this.toJsonFunctionDeclaration.toList(),
+            ...this.toRdfFunctionDeclaration.toList(),
+        ];
+        if (moduleStatements.length > 0) {
+            declarations.push({
+                isExported: this.export,
+                kind: StructureKind.Module,
+                name: this.name,
+                statements: moduleStatements,
+            });
+        }
+        return declarations;
+    }
+    get discriminatorProperty() {
+        return Maybe.of(this._discriminatorProperty);
+    }
+    get equalsFunction() {
+        return `${this.name}.equals`;
+    }
+    get jsonName() {
+        return this.memberTypes
+            .map((memberType) => memberType.jsonName)
+            .join(" | ");
+    }
+    get mutable() {
+        return this.memberTypes.some((memberType) => memberType.mutable);
+    }
+    get thisVariable() {
+        return `_${camelCase(this.name)}`;
+    }
+    get equalsFunctionDeclaration() {
+        if (!this.features.has("equals")) {
+            return Maybe.empty();
+        }
+        const caseBlocks = this.memberTypes.map((memberType) => {
+            let returnExpression;
+            switch (memberType.declarationType) {
+                case "class":
+                    returnExpression = `left.equals(right as unknown as ${memberType.name})`;
+                    break;
+                case "interface":
+                    returnExpression = `${memberType.name}.equals(left, right as unknown as ${memberType.name})`;
+                    break;
+            }
+            return `case "${memberType.name}": return ${returnExpression};`;
+        });
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "equals",
+            parameters: [
+                {
+                    name: "left",
+                    type: this.name,
+                },
+                {
+                    name: "right",
+                    type: this.name,
+                },
+            ],
+            returnType: "EqualsResult",
+            statements: `\
+return strictEquals(left.type, right.type).chain(() => {
+  switch (left.${this._discriminatorProperty.name}) {
+   ${caseBlocks.join(" ")}
+  }
+})`,
+        });
+    }
+    get fromJsonFunctionDeclaration() {
+        if (!this.features.has("fromJson")) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromJson",
+            parameters: [
+                {
+                    name: "json",
+                    type: "unknown",
+                },
+            ],
+            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
+            statements: [
+                `return ${this.memberTypes.reduce((expression, memberType) => {
+                    const memberTypeExpression = `(${memberType.name}.fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
+                    return expression.length > 0
+                        ? `${expression}.altLazy(() => ${memberTypeExpression})`
+                        : memberTypeExpression;
+                }, "")};`,
+            ],
+        });
+    }
+    get fromRdfFunctionDeclaration() {
+        if (!this.features.has("fromRdf")) {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "fromRdf",
+            parameters: [
+                {
+                    name: "parameters",
+                    type: `{ [_index: string]: any; ignoreRdfType?: boolean; resource: ${this.rdfjsResourceType().name}; }`,
+                },
+            ],
+            returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
+            statements: [
+                `return ${this.memberTypes.reduce((expression, memberType) => {
+                    const memberTypeExpression = `(${memberType.name}.fromRdf(parameters) as purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>)`;
+                    return expression.length > 0
+                        ? `${expression}.altLazy(() => ${memberTypeExpression})`
+                        : memberTypeExpression;
+                }, "")};`,
+            ],
+        });
+    }
+    get hashFunctionDeclaration() {
+        if (!this.features.has("hash")) {
+            return Maybe.empty();
+        }
+        const hasherVariable = "_hasher";
+        const caseBlocks = this.memberTypes.map((memberType) => {
+            let returnExpression;
+            switch (memberType.declarationType) {
+                case "class":
+                    returnExpression = `${this.thisVariable}.hash(${hasherVariable})`;
+                    break;
+                case "interface":
+                    returnExpression = `${memberType.name}.${memberType.hashFunctionName}(${this.thisVariable}, ${hasherVariable})`;
+                    break;
+            }
+            return `case "${memberType.name}": return ${returnExpression};`;
+        });
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "hash",
+            parameters: [
+                {
+                    name: this.thisVariable,
+                    type: this.name,
+                },
+                {
+                    name: hasherVariable,
+                    type: "HasherT",
+                },
+            ],
+            returnType: "HasherT",
+            statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
+            typeParameters: [
+                {
+                    name: "HasherT",
+                    constraint: hasherTypeConstraint,
+                },
+            ],
+        });
+    }
+    get jsonZodSchemaFunctionDeclaration() {
+        if (!this.features.has("fromJson")) {
+            return Maybe.empty();
+        }
+        const variables = { zod: "zod" };
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "jsonZodSchema",
+            statements: `return ${variables.zod}.discriminatedUnion("${this._discriminatorProperty.name}", [${this.memberTypes.map((memberType) => memberType.jsonZodSchema({ variables })).join(", ")}]);`,
+        });
+    }
+    get sparqlFunctionDeclarations() {
+        if (!this.features.has("sparql")) {
+            return [];
+        }
+        return [
+            sparqlConstructQueryFunctionDeclaration.bind(this)(),
+            sparqlConstructQueryStringFunctionDeclaration.bind(this)(),
+            {
+                isExported: true,
+                kind: StructureKind.Function,
+                name: "sparqlConstructTemplateTriples",
+                parameters: [
+                    {
+                        name: "parameters",
+                        type: '{ ignoreRdfType?: boolean, subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                    },
+                ],
+                returnType: "readonly sparqljs.Triple[]",
+                statements: [
+                    `return [${this.memberTypes
+                        .map((memberType) => `...${memberType.name}.sparqlConstructTemplateTriples({ ignoreRdfType: parameters?.ignoreRdfType, subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`)
+                        .join(", ")}];`,
+                ],
+            },
+            {
+                isExported: true,
+                kind: StructureKind.Function,
+                name: "sparqlWherePatterns",
+                parameters: [
+                    {
+                        name: "parameters",
+                        type: '{ ignoreRdfType?: boolean; subject?: sparqljs.Triple["subject"], variablePrefix?: string }',
+                    },
+                ],
+                returnType: "readonly sparqljs.Pattern[]",
+                statements: [
+                    `return [{ patterns: [${this.memberTypes
+                        .map((memberType) => objectInitializer({
+                        patterns: `${memberType.name}.sparqlWherePatterns({ ignoreRdfType: parameters?.ignoreRdfType, subject: parameters.subject ?? ${this.dataFactoryVariable}.variable!("${camelCase(this.name)}${pascalCase(memberType.name)}"), variablePrefix: parameters?.variablePrefix ? \`\${parameters.variablePrefix}${pascalCase(memberType.name)}\` : "${camelCase(this.name)}${pascalCase(memberType.name)}" }).concat()`,
+                        type: '"group"',
+                    }))
+                        .join(", ")}], type: "union" }];`,
+                ],
+            },
+        ];
+    }
+    get toJsonFunctionDeclaration() {
+        if (!this.features.has("toJson")) {
+            return Maybe.empty();
+        }
+        const caseBlocks = this.memberTypes.map((memberType) => {
+            let returnExpression;
+            switch (memberType.declarationType) {
+                case "class":
+                    returnExpression = `${this.thisVariable}.toJson()`;
+                    break;
+                case "interface":
+                    returnExpression = `${memberType.name}.toJson(${this.thisVariable})`;
+                    break;
+            }
+            return `case "${memberType.name}": return ${returnExpression};`;
+        });
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "toJson",
+            parameters: [
+                {
+                    name: this.thisVariable,
+                    type: this.name,
+                },
+            ],
+            returnType: this.jsonName,
+            statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
+        });
+    }
+    get toRdfFunctionDeclaration() {
+        if (!this.features.has("toRdf")) {
+            return Maybe.empty();
+        }
+        const parametersVariable = "_parameters";
+        const caseBlocks = this.memberTypes.map((memberType) => {
+            let returnExpression;
+            switch (memberType.declarationType) {
+                case "class":
+                    returnExpression = `${this.thisVariable}.toRdf(${parametersVariable})`;
+                    break;
+                case "interface":
+                    returnExpression = `${memberType.name}.toRdf(${this.thisVariable}, ${parametersVariable})`;
+                    break;
+            }
+            return `case "${memberType.name}": return ${returnExpression};`;
+        });
+        return Maybe.of({
+            isExported: true,
+            kind: StructureKind.Function,
+            name: "toRdf",
+            parameters: [
+                {
+                    name: this.thisVariable,
+                    type: this.name,
+                },
+                {
+                    name: parametersVariable,
+                    type: "{ mutateGraph: rdfjsResource.MutableResource.MutateGraph, resourceSet: rdfjsResource.MutableResourceSet }",
+                },
+            ],
+            returnType: this.rdfjsResourceType({ mutable: true }).name,
+            statements: `switch (${this.thisVariable}.${this._discriminatorProperty.name}) { ${caseBlocks.join(" ")} }`,
+        });
+    }
+    get typeAliasDeclaration() {
+        return {
+            isExported: true,
+            leadingTrivia: this.comment.alt(this.label).map(tsComment).extract(),
+            kind: StructureKind.TypeAlias,
+            name: this.name,
+            type: this.memberTypes.map((memberType) => memberType.name).join(" | "),
+        };
+    }
+    fromJsonExpression({ variables, }) {
+        // Assumes the JSON object has been recursively validated already.
+        return `${this.name}.fromJson(${variables.value}).unsafeCoerce()`;
+    }
+    fromRdfExpression({ variables, }) {
+        return `${variables.resourceValues}.head().chain(value => value.to${this.rdfjsResourceType().named ? "Named" : ""}Resource()).chain(_resource => ${this.name}.fromRdf({ ...${variables.context}, resource: _resource }))`;
+    }
+    hashStatements({ variables, }) {
+        switch (this.memberTypes[0].declarationType) {
+            case "class":
+                return [`${variables.value}.hash(${variables.hasher});`];
+            case "interface":
+                return [`${this.name}.hash(${variables.value}, ${variables.hasher});`];
+        }
+    }
+    jsonZodSchema() {
+        return `${this.name}.jsonZodSchema()`;
+    }
+    sparqlConstructTemplateTriples({ context, variables, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlConstructTemplateTriples({ context, variables });
+            case "type":
+                return [
+                    `...${this.name}.sparqlConstructTemplateTriples(${objectInitializer({
+                        ignoreRdfType: true,
+                        subject: variables.subject,
+                        variablePrefix: variables.variablePrefix,
+                    })})`,
+                ];
+        }
+    }
+    sparqlWherePatterns({ context, variables, }) {
+        switch (context) {
+            case "property":
+                return super.sparqlWherePatterns({ context, variables });
+            case "type":
+                return [
+                    `...${this.name}.sparqlWherePatterns(${objectInitializer({
+                        ignoreRdfType: true,
+                        subject: variables.subject,
+                        variablePrefix: variables.variablePrefix,
+                    })})`,
+                ];
+        }
+    }
+    toJsonExpression({ variables, }) {
+        switch (this.memberTypes[0].declarationType) {
+            case "class":
+                return `${variables.value}.toJson()`;
+            case "interface":
+                throw new Error("not implemented: need a freestanding toJson function like the toRdf function");
+            // return `${this.name}.toJson(${variables.value})`;
+        }
+    }
+    toRdfExpression({ variables, }) {
+        const options = `{ mutateGraph: ${variables.mutateGraph}, resourceSet: ${variables.resourceSet} }`;
+        switch (this.memberTypes[0].declarationType) {
+            case "class":
+                return `${variables.value}.toRdf(${options})`;
+            case "interface":
+                return `${this.name}.toRdf(${variables.value}, ${options})`;
+        }
+    }
+    useImports() {
+        return [];
+    }
+    rdfjsResourceType(options) {
+        const memberRdfjsResourceTypes = [];
+        for (const memberType of this.memberTypes) {
+            const memberRdfjsResourceType = memberType.rdfjsResourceType(options);
+            if (memberRdfjsResourceTypes.some((existingMemberRdfjsResourceType) => existingMemberRdfjsResourceType.name !==
+                memberRdfjsResourceType.name)) {
+                // The types don't agree, return a generic type
+                return {
+                    mutable: !!options?.mutable,
+                    name: "rdfjsResource.Resource",
+                    named: false,
+                };
+            }
+            memberRdfjsResourceTypes.push(memberRdfjsResourceType);
+        }
+        // The types agree
+        return memberRdfjsResourceTypes[0];
+    }
+}
+__decorate([
+    Memoize()
+], ObjectUnionType.prototype, "thisVariable", null);
+//# sourceMappingURL=ObjectUnionType.js.map

package/generators/ts/OptionType.d.ts

@@ -1,3 +1,5 @@
+import type { TsFeature } from "../../enums/index.js";
+import { Import } from "./Import.js";
 import { Type } from "./Type.js";
 export declare class OptionType extends Type {
     readonly itemType: Type;
@@ -6,12 +8,20 @@ export declare class OptionType extends Type {
         itemType: Type;
     });
     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(parameters: Parameters<Type["fromRdfExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    propertySparqlGraphPatternExpression(parameters: Parameters<Type["propertySparqlGraphPatternExpression"]>[0]): Type.SparqlGraphPatternExpression;
+    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=OptionType.d.ts.map

package/generators/ts/OptionType.js

@@ -5,6 +5,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Memoize } from "typescript-memoize";
+import { Import } from "./Import.js";
+import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 export class OptionType extends Type {
     constructor({ itemType, ...superParameters }) {
@@ -28,53 +30,101 @@ export class OptionType extends Type {
         if (!conversions.some((conversion) => conversion.sourceTypeName === "undefined")) {
             conversions.push({
                 conversionExpression: () => "purify.Maybe.empty()",
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
                 sourceTypeName: "undefined",
             });
         }
         return conversions;
     }
+    get equalsFunction() {
+        return `((left, right) => maybeEquals(left, right, ${this.itemType.equalsFunction}))`;
+    }
+    get jsonName() {
+        return `(${this.itemType.jsonName}) | undefined`;
+    }
+    get mutable() {
+        return this.itemType.mutable;
+    }
     get name() {
         return `purify.Maybe<${this.itemType.name}>`;
     }
-    chainSparqlGraphPatternExpression(parameters) {
-        return this.itemType.chainSparqlGraphPatternExpression(parameters);
-    }
-    equalsFunction() {
-        const itemTypeEqualsFunction = this.itemType.equalsFunction();
-        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.equals") {
-            return "purifyHelpers.Equatable.maybeEquals";
-        }
-        if (itemTypeEqualsFunction === "purifyHelpers.Equatable.strictEquals") {
-            return "purifyHelpers.Equatable.booleanEquals"; // Use Maybe.equals
-        }
-        return `(left, right) => purifyHelpers.Maybes.equals(left, right, ${itemTypeEqualsFunction})`;
+    fromJsonExpression({ variables, }) {
+        const expression = `purify.Maybe.fromNullable(${variables.value})`;
+        const itemFromJsonExpression = this.itemType.fromJsonExpression({
+            variables: { value: "_item" },
+        });
+        return itemFromJsonExpression === "_item"
+            ? expression
+            : `${expression}.map(_item => (${itemFromJsonExpression}))`;
     }
     fromRdfExpression(parameters) {
         return `purify.Either.of(${this.itemType.fromRdfExpression(parameters)}.toMaybe())`;
     }
-    hashStatements({ variables, }) {
+    hashStatements({ depth, variables, }) {
         return [
-            `${variables.value}.ifJust((value) => { ${this.itemType
+            `${variables.value}.ifJust((_value${depth}) => { ${this.itemType
                 .hashStatements({
+                depth: depth + 1,
                 variables: {
                     hasher: variables.hasher,
-                    value: "value",
+                    value: `_value${depth}`,
                 },
             })
                 .join("\n")} })`,
         ];
     }
-    propertySparqlGraphPatternExpression(parameters) {
-        return new Type.SparqlGraphPatternExpression(`sparqlBuilder.GraphPattern.optional(${this.itemType.propertySparqlGraphPatternExpression(parameters).toSparqlGraphPatternExpression()})`);
+    jsonUiSchemaElement(parameters) {
+        return this.itemType.jsonUiSchemaElement(parameters);
+    }
+    jsonZodSchema(parameters) {
+        return `${this.itemType.jsonZodSchema(parameters)}.optional()`;
+    }
+    snippetDeclarations(features) {
+        const snippetDeclarations = [];
+        if (features.has("equals")) {
+            snippetDeclarations.push(SnippetDeclarations.maybeEquals);
+        }
+        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 [`{ 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" } })})).extract()`;
     }
     toRdfExpression({ variables, }) {
         const itemTypeToRdfExpression = this.itemType.toRdfExpression({
-            variables: { ...variables, value: "value" },
+            variables: { ...variables, value: "_value" },
         });
-        if (itemTypeToRdfExpression === "value") {
+        if (itemTypeToRdfExpression === "_value") {
             return variables.value;
         }
-        return `${variables.value}.map((value) => ${itemTypeToRdfExpression})`;
+        return `${variables.value}.map((_value) => ${itemTypeToRdfExpression})`;
+    }
+    useImports(features) {
+        return [...this.itemType.useImports(features), Import.PURIFY];
     }
 }
 __decorate([

package/generators/ts/PrimitiveType.d.ts

@@ -1,11 +1,21 @@
 import { Maybe } from "purify-ts";
+import type { TsFeature } from "../../enums/index.js";
 import { LiteralType } from "./LiteralType.js";
 import type { Type } from "./Type.js";
-export declare abstract class PrimitiveType extends LiteralType {
-    get conversions(): readonly Type.Conversion[];
+export declare abstract class PrimitiveType<ValueT extends boolean | Date | string | number> extends LiteralType {
+    readonly equalsFunction: string;
+    readonly primitiveDefaultValue: Maybe<ValueT>;
+    readonly primitiveIn: readonly ValueT[];
+    constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }: {
+        primitiveDefaultValue: Maybe<ValueT>;
+        primitiveIn: readonly ValueT[];
+    } & ConstructorParameters<typeof LiteralType>[0]);
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get importStatements(): readonly string[];
-    equalsFunction(): string;
-    toRdfExpression({ variables, }: Parameters<LiteralType["toRdfExpression"]>[0]): string;
+    get jsonName(): string;
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    snippetDeclarations(features: Set<TsFeature>): readonly string[];
+    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
+    protected propertyFilterRdfResourceValuesExpression({ variables, }: Parameters<LiteralType["propertyFilterRdfResourceValuesExpression"]>[0]): string;
 }
 //# sourceMappingURL=PrimitiveType.d.ts.map