@shaclmate/compiler 2.0.16 → 2.0.18

package/{Compiler.js → dist/Compiler.js}

@@ -2,6 +2,8 @@ import PrefixMap from "@rdfjs/prefix-map/PrefixMap.js";
 import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
 import { ShapesGraph } from "./input/ShapesGraph.js";
 export class Compiler {
+    generator;
+    iriPrefixMap;
     constructor({ generator, iriPrefixMap, }) {
         this.generator = generator;
         this.iriPrefixMap = iriPrefixMap ?? new PrefixMap();

package/{ShapesGraphToAstTransformer.js → dist/ShapesGraphToAstTransformer.js}

@@ -3,18 +3,20 @@ import { dash } from "@tpluscode/rdf-ns-builders";
 import { Either, Maybe } from "purify-ts";
 import * as _ShapesGraphToAstTransformer from "./_ShapesGraphToAstTransformer/index.js";
 export class ShapesGraphToAstTransformer {
+    // Members are protected so they're accessible to the bound functions
+    astObjectTypePropertiesByIdentifier = new TermMap();
+    iriPrefixMap;
+    nodeShapeAstTypesByIdentifier = new TermMap();
+    shapeAstName = _ShapesGraphToAstTransformer.shapeAstName;
+    shapesGraph;
+    transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
+    transformPropertyShapeToAstCompositeType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstCompositeType;
+    transformPropertyShapeToAstIdentifierType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstIdentifierType;
+    transformPropertyShapeToAstLiteralType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstLiteralType;
+    transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
+    transformPropertyShapeToAstTermType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstTermType;
+    transformPropertyShapeToAstType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstType;
     constructor({ iriPrefixMap, shapesGraph, }) {
-        // Members are protected so they're accessible to the bound functions
-        this.astObjectTypePropertiesByIdentifier = new TermMap();
-        this.nodeShapeAstTypesByIdentifier = new TermMap();
-        this.shapeAstName = _ShapesGraphToAstTransformer.shapeAstName;
-        this.transformNodeShapeToAstType = _ShapesGraphToAstTransformer.transformNodeShapeToAstType;
-        this.transformPropertyShapeToAstCompositeType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstCompositeType;
-        this.transformPropertyShapeToAstIdentifierType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstIdentifierType;
-        this.transformPropertyShapeToAstLiteralType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstLiteralType;
-        this.transformPropertyShapeToAstObjectTypeProperty = _ShapesGraphToAstTransformer.transformPropertyShapeToAstObjectTypeProperty;
-        this.transformPropertyShapeToAstTermType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstTermType;
-        this.transformPropertyShapeToAstType = _ShapesGraphToAstTransformer.transformPropertyShapeToAstType;
         this.iriPrefixMap = iriPrefixMap;
         this.shapesGraph = shapesGraph;
     }

package/{_ShapesGraphToAstTransformer → dist/_ShapesGraphToAstTransformer}/transformNodeShapeToAstType.js

@@ -24,7 +24,7 @@ function transformNodeShapeToListType(nodeShape) {
         label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
         mutable: nodeShape.mutable,
         name: this.shapeAstName(nodeShape),
-        mintingStrategy: nodeShape.mintingStrategy,
+        identifierMintingStrategy: nodeShape.identifierMintingStrategy,
         toRdfTypes: nodeShape.toRdfTypes,
     };
     this.nodeShapeAstTypesByIdentifier.set(nodeShape.identifier, listType);
@@ -141,7 +141,9 @@ export function transformNodeShapeToAstType(nodeShape) {
         label: pickLiteral(nodeShape.labels).map((literal) => literal.value),
         kind: "ObjectType",
         identifierIn,
-        identifierMintingStrategy: identifierIn.length === 0 ? nodeShape.mintingStrategy : Maybe.empty(),
+        identifierMintingStrategy: identifierIn.length === 0
+            ? nodeShape.identifierMintingStrategy
+            : Maybe.empty(),
         identifierKinds: identifierIn.length === 0 ? nodeShape.nodeKinds : new Set(["NamedNode"]),
         name: this.shapeAstName(nodeShape),
         properties: [], // This is mutable, we'll populate it below.

package/{_ShapesGraphToAstTransformer → dist/_ShapesGraphToAstTransformer}/transformPropertyShapeToAstType.js

@@ -30,6 +30,7 @@ export function transformPropertyShapeToAstType(shape, inherited) {
                 return {
                     itemType,
                     kind: "SetType",
+                    mutable: shape.mutable,
                     minCount: 0,
                 };
             }
@@ -52,6 +53,7 @@ export function transformPropertyShapeToAstType(shape, inherited) {
             itemType,
             kind: "SetType",
             minCount: minCount.orDefault(0),
+            mutable: shape.mutable,
         };
     });
 }

package/{ast → dist/ast}/ListType.d.ts

@@ -33,7 +33,7 @@ export interface ListType {
     /**
      * Strategy for minting new list and sub-list identifiers.
      */
-    readonly mintingStrategy: Maybe<IdentifierMintingStrategy>;
+    readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     /**
      * The list should be mutable in generated code.
      */

package/dist/ast/SetType.d.ts

@@ -0,0 +1,23 @@
+import type { Maybe } from "purify-ts";
+import type { Type } from "./Type.js";
+/**
+ * An unordered set of items of a specific type.
+ *
+ * This is a property with sh:maxCount != 1.
+ */
+export interface SetType {
+    /**
+     * Set item type.
+     */
+    readonly itemType: Type;
+    readonly kind: "SetType";
+    /**
+     * Minimum number of items in the set.
+     */
+    readonly minCount: number;
+    /**
+     * The set should be mutable in generated code.
+     */
+    readonly mutable: Maybe<boolean>;
+}
+//# sourceMappingURL=SetType.d.ts.map

package/dist/enums/IdentifierMintingStrategy.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TypeScript enum corresponding to shaclmate:identifierMintingStrategy, for simpler manipulation.
+ */
+export type IdentifierMintingStrategy = "sha256" | "uuidv4";
+//# sourceMappingURL=IdentifierMintingStrategy.d.ts.map

package/{generators → dist/generators}/index.d.ts

@@ -1,3 +1,4 @@
+export * from "./Generator.js";
 export * as json from "./json/index.js";
 export * as ts from "./ts/index.js";
 //# sourceMappingURL=index.d.ts.map

package/{generators → dist/generators}/index.js

@@ -1,3 +1,4 @@
+export * from "./Generator.js";
 export * as json from "./json/index.js";
 export * as ts from "./ts/index.js";
 //# sourceMappingURL=index.js.map

package/{generators → dist/generators}/ts/BooleanType.js

@@ -8,10 +8,7 @@ import { Memoize } from "typescript-memoize";
 import { PrimitiveType } from "./PrimitiveType.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class BooleanType extends PrimitiveType {
-    constructor() {
-        super(...arguments);
-        this.kind = "BooleanType";
-    }
+    kind = "BooleanType";
     get conversions() {
         const conversions = [
             {

package/{generators → dist/generators}/ts/DateTimeType.d.ts

@@ -1,10 +1,13 @@
+import type { NamedNode } from "@rdfjs/types";
 import type { TsFeature } from "../../enums/index.js";
 import { PrimitiveType } from "./PrimitiveType.js";
 import type { Type } from "./Type.js";
 export declare class DateTimeType extends PrimitiveType<Date> {
     readonly equalsFunction = "dateEquals";
-    readonly kind = "DateTimeType";
+    readonly kind: "DateTimeType" | "DateType";
     readonly mutable = true;
+    protected readonly xsdDatatype: NamedNode;
+    protected readonly zodDatatype: string;
     get conversions(): readonly Type.Conversion[];
     get jsonName(): string;
     get name(): string;

package/{generators → dist/generators}/ts/DateTimeType.js

@@ -1,13 +1,13 @@
+import { xsd } from "@tpluscode/rdf-ns-builders";
 import { PrimitiveType } from "./PrimitiveType.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class DateTimeType extends PrimitiveType {
-    constructor() {
-        super(...arguments);
-        this.equalsFunction = "dateEquals";
-        this.kind = "DateTimeType";
-        this.mutable = true;
-    }
+    equalsFunction = "dateEquals";
+    kind = "DateTimeType";
+    mutable = true;
+    xsdDatatype = xsd.dateTime;
+    zodDatatype = "datetime";
     get conversions() {
         const conversions = [
             {
@@ -38,12 +38,12 @@ export class DateTimeType extends PrimitiveType {
         return [`${variables.hasher}.update(${variables.value}.toISOString());`];
     }
     jsonZodSchema({ variables, }) {
-        return `${variables.zod}.string().datetime()`;
+        return `${variables.zod}.string().${this.zodDatatype}()`;
     }
     propertyFromRdfResourceValueExpression({ variables, }) {
         let expression = `${variables.resourceValue}.toDate()`;
         if (this.primitiveIn.length > 0) {
-            expression = `${expression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of(value); }`).join(" ")} return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
+            expression = `${expression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of(value); }`).join(" ")} return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: `rdfLiteral.toRdf(value, ${objectInitializer({ dataFactory: this.dataFactoryVariable, datatype: this.rdfjsTermExpression(this.xsdDatatype) })})`, expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
         }
         return expression;
     }
@@ -58,9 +58,10 @@ export class DateTimeType extends PrimitiveType {
         return `${variables.value}.toISOString()`;
     }
     toRdfExpression({ variables, }) {
+        const valueToRdf = `rdfLiteral.toRdf(${variables.value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable, datatype: this.rdfjsTermExpression(this.xsdDatatype) })})`;
         return this.primitiveDefaultValue
-            .map((defaultValue) => `${variables.value}.getTime() !== ${defaultValue.getTime()} ? ${variables.value} : undefined`)
-            .orDefault(variables.value);
+            .map((defaultValue) => `${variables.value}.getTime() !== ${defaultValue.getTime()} ? ${valueToRdf} : undefined`)
+            .orDefault(valueToRdf);
     }
 }
 //# sourceMappingURL=DateTimeType.js.map

package/dist/generators/ts/DateType.d.ts

@@ -0,0 +1,9 @@
+import { DateTimeType } from "./DateTimeType.js";
+import type { PrimitiveType } from "./PrimitiveType.js";
+export declare class DateType extends DateTimeType {
+    readonly kind = "DateType";
+    protected readonly xsdDatatype: import("@rdfjs/types").NamedNode<string> & import("@rdfjs/types").NamedNode<"http://www.w3.org/2001/XMLSchema#date">;
+    protected readonly zodDatatype = "date";
+    toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
+}
+//# sourceMappingURL=DateType.d.ts.map

package/dist/generators/ts/DateType.js

@@ -0,0 +1,11 @@
+import { xsd } from "@tpluscode/rdf-ns-builders";
+import { DateTimeType } from "./DateTimeType.js";
+export class DateType extends DateTimeType {
+    kind = "DateType";
+    xsdDatatype = xsd.date;
+    zodDatatype = "date";
+    toJsonExpression({ variables, }) {
+        return `${variables.value}.toISOString().replace(/T.*$/, '')`;
+    }
+}
+//# sourceMappingURL=DateType.js.map

package/{generators → dist/generators}/ts/DeclaredType.js

@@ -1,5 +1,8 @@
 import { Type } from "./Type.js";
 export class DeclaredType extends Type {
+    export;
+    features;
+    name;
     constructor({ export_, features, name, ...superParameters }) {
         super(superParameters);
         this.export = export_;

package/{generators → dist/generators}/ts/IdentifierType.js

@@ -7,10 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import { Memoize } from "typescript-memoize";
 import { TermType } from "./TermType.js";
 export class IdentifierType extends TermType {
-    constructor() {
-        super(...arguments);
-        this.kind = "IdentifierType";
-    }
+    kind = "IdentifierType";
     get conversions() {
         return super.conversions.concat([
             {

package/{generators → dist/generators}/ts/ListType.d.ts

@@ -6,14 +6,14 @@ 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 identifierMintingStrategy;
+    private readonly _mutable;
     private readonly toRdfTypes;
-    constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }: {
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }: {
         identifierNodeKind: ListType["identifierNodeKind"];
         itemType: Type;
-        mintingStrategy: Maybe<IdentifierMintingStrategy>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         mutable: boolean;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof Type>[0]);
@@ -21,6 +21,7 @@ export declare class ListType extends Type {
     get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get equalsFunction(): string;
     get jsonName(): string;
+    get mutable(): boolean;
     get name(): string;
     fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
     fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;

package/{generators → dist/generators}/ts/ListType.js

@@ -5,13 +5,19 @@ import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class ListType extends Type {
-    constructor({ identifierNodeKind, itemType, mintingStrategy, mutable, toRdfTypes, ...superParameters }) {
+    itemType;
+    kind = "ListType";
+    identifierNodeKind;
+    identifierMintingStrategy;
+    _mutable;
+    toRdfTypes;
+    constructor({ identifierNodeKind, itemType, identifierMintingStrategy, mutable, toRdfTypes, ...superParameters }) {
         super(superParameters);
-        this.kind = "ListType";
         this.identifierNodeKind = identifierNodeKind;
         this.itemType = itemType;
-        this.mintingStrategy = mintingStrategy.orDefault("sha256");
-        this.mutable = mutable;
+        this.identifierMintingStrategy =
+            identifierMintingStrategy.orDefault("sha256");
+        this._mutable = mutable;
         this.toRdfTypes = toRdfTypes;
     }
     get conversions() {
@@ -32,8 +38,11 @@ export class ListType extends Type {
     get jsonName() {
         return `readonly (${this.itemType.jsonName})[]`;
     }
+    get mutable() {
+        return this._mutable || this.itemType.mutable;
+    }
     get name() {
-        return `${this.mutable ? "" : "readonly "}${this.itemType.name}[]`;
+        return `${this._mutable ? "" : "readonly "}${this.itemType.name}[]`;
     }
     fromJsonExpression({ variables, }) {
         return `${variables.value}.map(_item => (${this.itemType.fromJsonExpression({ variables: { value: "_item" } })}))`;
@@ -57,7 +66,9 @@ export class ListType extends Type {
         return `${this.itemType.jsonZodSchema(parameters)}.array()`;
     }
     snippetDeclarations(features) {
-        const snippetDeclarations = [];
+        const snippetDeclarations = this.itemType
+            .snippetDeclarations(features)
+            .concat();
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }
@@ -218,7 +229,7 @@ export class ListType extends Type {
                 break;
             }
             case "NamedNode": {
-                switch (this.mintingStrategy) {
+                switch (this.identifierMintingStrategy) {
                     case "sha256":
                         listIdentifier = `dataFactory.namedNode(\`urn:shaclmate:list:\${${variables.value}.reduce(
         (_hasher, _item) => {

package/{generators → dist/generators}/ts/LiteralType.js

@@ -1,6 +1,7 @@
 import { xsd } from "@tpluscode/rdf-ns-builders";
 import { TermType } from "./TermType.js";
 export class LiteralType extends TermType {
+    languageIn;
     constructor({ languageIn, ...superParameters }) {
         super({
             ...superParameters,

package/{generators → dist/generators}/ts/NumberType.js

@@ -8,10 +8,7 @@ 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";
-    }
+    kind = "NumberType";
     get conversions() {
         const conversions = [
             {

package/{generators → dist/generators}/ts/ObjectType.d.ts

@@ -15,14 +15,14 @@ export declare class ObjectType extends DeclaredType {
     protected readonly extern: boolean;
     protected readonly fromRdfType: Maybe<NamedNode>;
     protected readonly label: Maybe<string>;
-    protected readonly mintingStrategy: Maybe<IdentifierMintingStrategy>;
+    protected readonly identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
     protected readonly toRdfTypes: readonly NamedNode[];
     private readonly imports;
     private readonly lazyAncestorObjectTypes;
     private readonly lazyDescendantObjectTypes;
     private readonly lazyParentObjectTypes;
     private readonly lazyProperties;
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, mintingStrategy, toRdfTypes, ...superParameters }: {
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, identifierMintingStrategy, toRdfTypes, ...superParameters }: {
         abstract: boolean;
         comment: Maybe<string>;
         declarationType: TsObjectDeclarationType;
@@ -34,7 +34,7 @@ export declare class ObjectType extends DeclaredType {
         lazyDescendantObjectTypes: () => readonly ObjectType[];
         lazyParentObjectTypes: () => readonly ObjectType[];
         lazyProperties: () => readonly ObjectType.Property[];
-        mintingStrategy: Maybe<IdentifierMintingStrategy>;
+        identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         toRdfTypes: readonly NamedNode[];
     } & ConstructorParameters<typeof DeclaredType>[0]);
     get _discriminatorProperty(): Type.DiscriminatorProperty;

package/{generators → dist/generators}/ts/ObjectType.js

@@ -16,9 +16,22 @@ import * as _ObjectType from "./_ObjectType/index.js";
 import { IdentifierProperty, TypeDiscriminatorProperty, } from "./_ObjectType/index.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class ObjectType extends DeclaredType {
-    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, mintingStrategy, toRdfTypes, ...superParameters }) {
+    abstract;
+    declarationType;
+    kind = "ObjectType";
+    comment;
+    extern;
+    fromRdfType;
+    label;
+    identifierMintingStrategy;
+    toRdfTypes;
+    imports;
+    lazyAncestorObjectTypes;
+    lazyDescendantObjectTypes;
+    lazyParentObjectTypes;
+    lazyProperties;
+    constructor({ abstract, comment, declarationType, extern, fromRdfType, label, lazyAncestorObjectTypes, lazyDescendantObjectTypes, lazyParentObjectTypes, lazyProperties, imports, identifierMintingStrategy, toRdfTypes, ...superParameters }) {
         super(superParameters);
-        this.kind = "ObjectType";
         this.abstract = abstract;
         this.comment = comment;
         this.declarationType = declarationType;
@@ -31,7 +44,7 @@ export class ObjectType extends DeclaredType {
         this.lazyDescendantObjectTypes = lazyDescendantObjectTypes;
         this.lazyParentObjectTypes = lazyParentObjectTypes;
         this.lazyProperties = lazyProperties;
-        this.mintingStrategy = mintingStrategy;
+        this.identifierMintingStrategy = identifierMintingStrategy;
         this.toRdfTypes = toRdfTypes;
     }
     get _discriminatorProperty() {

package/{generators → dist/generators}/ts/ObjectUnionType.js

@@ -26,9 +26,13 @@ import { tsComment } from "./tsComment.js";
  * It also generates SPARQL graph patterns that UNION the member object types.
  */
 export class ObjectUnionType extends DeclaredType {
+    kind = "ObjectUnionType";
+    _discriminatorProperty;
+    comment;
+    label;
+    memberTypes;
     constructor({ comment, label, memberTypes, ...superParameters }) {
         super(superParameters);
-        this.kind = "ObjectUnionType";
         this.comment = comment;
         this.label = label;
         invariant(memberTypes.length > 0);

package/{generators → dist/generators}/ts/OptionType.js

@@ -9,9 +9,10 @@ import { Import } from "./Import.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 export class OptionType extends Type {
+    itemType;
+    kind = "OptionType";
     constructor({ itemType, ...superParameters }) {
         super(superParameters);
-        this.kind = "OptionType";
         this.itemType = itemType;
     }
     get conversions() {
@@ -80,7 +81,9 @@ export class OptionType extends Type {
         return `${this.itemType.jsonZodSchema(parameters)}.optional()`;
     }
     snippetDeclarations(features) {
-        const snippetDeclarations = [];
+        const snippetDeclarations = this.itemType
+            .snippetDeclarations(features)
+            .concat();
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.maybeEquals);
         }

package/{generators → dist/generators}/ts/PrimitiveType.js

@@ -2,9 +2,11 @@ import { Maybe } from "purify-ts";
 import { LiteralType } from "./LiteralType.js";
 import { SnippetDeclarations } from "./SnippetDeclarations.js";
 export class PrimitiveType extends LiteralType {
+    equalsFunction = "strictEquals";
+    primitiveDefaultValue;
+    primitiveIn;
     constructor({ primitiveDefaultValue, primitiveIn, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "strictEquals";
         this.primitiveDefaultValue = primitiveDefaultValue;
         this.primitiveIn = primitiveIn;
     }

package/{generators → dist/generators}/ts/SetType.d.ts

@@ -5,8 +5,10 @@ export declare class SetType extends Type {
     readonly itemType: Type;
     readonly kind = "SetType";
     private readonly minCount;
-    constructor({ itemType, minCount, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
+    private readonly _mutable;
+    constructor({ itemType, minCount, mutable, ...superParameters }: ConstructorParameters<typeof Type>[0] & {
         itemType: Type;
+        mutable: boolean;
         minCount: number;
     });
     get conversions(): readonly Type.Conversion[];

package/{generators → dist/generators}/ts/SetType.js

@@ -10,12 +10,16 @@ import { SnippetDeclarations } from "./SnippetDeclarations.js";
 import { Type } from "./Type.js";
 import { objectInitializer } from "./objectInitializer.js";
 export class SetType extends Type {
-    constructor({ itemType, minCount, ...superParameters }) {
+    itemType;
+    kind = "SetType";
+    minCount;
+    _mutable;
+    constructor({ itemType, minCount, mutable, ...superParameters }) {
         super(superParameters);
-        this.kind = "SetType";
         this.itemType = itemType;
         this.minCount = minCount;
         invariant(this.minCount >= 0);
+        this._mutable = mutable;
     }
     get conversions() {
         const conversions = [];
@@ -44,15 +48,15 @@ export class SetType extends Type {
         return `((left, right) => arrayEquals(left, right, ${this.itemType.equalsFunction}))`;
     }
     get jsonName() {
-        if (this.minCount === 0) {
-            return `readonly (${this.itemType.jsonName})[]`;
-        }
-        return `purify.NonEmptyList<${this.itemType.jsonName}>`;
+        return `readonly (${this.itemType.jsonName})[]`;
     }
     get mutable() {
-        return this.itemType.mutable;
+        return this._mutable || this.itemType.mutable;
     }
     get name() {
+        if (this._mutable) {
+            return `(${this.itemType.name})[]`;
+        }
         if (this.minCount === 0) {
             return `readonly (${this.itemType.name})[]`;
         }
@@ -60,7 +64,7 @@ export class SetType extends Type {
     }
     fromJsonExpression({ variables, }) {
         let expression = variables.value;
-        if (this.minCount > 0) {
+        if (!this._mutable && this.minCount > 0) {
             expression = `purify.NonEmptyList.fromArray(${expression}).unsafeCoerce()`;
         }
         const itemFromJsonExpression = this.itemType.fromJsonExpression({
@@ -74,7 +78,7 @@ export class SetType extends Type {
         const itemFromRdfExpression = this.itemType.fromRdfExpression({
             variables: { ...variables, resourceValues: "_item.toValues()" },
         });
-        if (this.minCount === 0) {
+        if (this._mutable || 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 })}))`;
@@ -103,7 +107,9 @@ export class SetType extends Type {
         return schema;
     }
     snippetDeclarations(features) {
-        const snippetDeclarations = [];
+        const snippetDeclarations = this.itemType
+            .snippetDeclarations(features)
+            .concat();
         if (features.has("equals")) {
             snippetDeclarations.push(SnippetDeclarations.arrayEquals);
         }

package/{generators → dist/generators}/ts/StringType.js

@@ -8,10 +8,7 @@ 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";
-    }
+    kind = "StringType";
     get conversions() {
         const conversions = [
             {

package/{generators → dist/generators}/ts/TermType.js

@@ -16,10 +16,14 @@ import { objectInitializer } from "./objectInitializer.js";
  * Abstract base class for IdentifierType and LiteralType.
  */
 export class TermType extends Type {
+    defaultValue;
+    equalsFunction = "booleanEquals";
+    hasValues;
+    in_;
+    mutable = false;
+    nodeKinds;
     constructor({ defaultValue, hasValues, in_, nodeKinds, ...superParameters }) {
         super(superParameters);
-        this.equalsFunction = "booleanEquals";
-        this.mutable = false;
         this.defaultValue = defaultValue;
         this.hasValues = hasValues;
         this.in_ = in_;
@@ -30,15 +34,15 @@ export class TermType extends Type {
         const conversions = [];
         if (this.nodeKinds.has("Literal")) {
             conversions.push({
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
                 sourceTypeName: "boolean",
             }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
                 sourceTypeName: "Date",
             }, {
-                conversionExpression: (value) => `rdfLiteral.toRdf(${value})`,
+                conversionExpression: (value) => `rdfLiteral.toRdf(${value}, ${objectInitializer({ dataFactory: this.dataFactoryVariable })})`,
                 sourceTypeCheckExpression: (value) => `typeof ${value} === "number"`,
                 sourceTypeName: "number",
             }, {

package/{generators → dist/generators}/ts/Type.js

@@ -8,6 +8,7 @@ import { objectInitializer } from "./objectInitializer.js";
  * Subclasses are used for both property types (c.f., property* methods) and node/object types.
  */
 export class Type {
+    dataFactoryVariable;
     constructor({ dataFactoryVariable, }) {
         this.dataFactoryVariable = dataFactoryVariable;
     }