@shaclmate/compiler 4.0.18 → 4.0.20

package/dist/ast/SetType.d.ts

@@ -12,6 +12,17 @@ export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemTy
         minCount: number;
     } & Pick<ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0], "itemType" | "mutable">);
     equals(other: SetType<ItemTypeT>): boolean;
+    toJSON(): {
+        minCount: number;
+        mutable: boolean | undefined;
+        itemType: any;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
 }
 export declare namespace SetType {
     type ItemType = AbstractCollectionType.ItemType;

package/dist/ast/SetType.js

@@ -28,6 +28,12 @@ export class SetType extends AbstractCollectionType {
         }
         return true;
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            minCount: this.minCount,
+        };
+    }
 }
 (function (SetType) {
     SetType.isItemType = AbstractCollectionType.isItemType;

package/dist/ast/UnionType.d.ts

@@ -7,6 +7,18 @@ import type { ObjectUnionType } from "./ObjectUnionType.js";
 export declare class UnionType<MemberTypeT extends UnionType.MemberType = UnionType.MemberType> extends AbstractCompoundType<UnionType.Member<MemberTypeT>, MemberTypeT> {
     readonly kind = "UnionType";
     isObjectUnionType(): this is ObjectUnionType;
+    toJSON(): {
+        members: {
+            discriminantValue: string | number | undefined;
+            type: any;
+        }[] | undefined;
+        comment: string | undefined;
+        kind: string;
+        label: string | undefined;
+        name: string | undefined;
+        recursive: boolean | undefined;
+        shapeIdentifier: import("@rdfjs/types").BlankNode | import("@rdfjs/types").NamedNode<string>;
+    };
 }
 export declare namespace UnionType {
     interface Member<TypeT extends UnionType.MemberType> extends AbstractCompoundType.Member<TypeT> {

package/dist/ast/UnionType.js

@@ -9,6 +9,17 @@ export class UnionType extends AbstractCompoundType {
             this.members.every((member) => member.type.kind === "ObjectType" ||
                 (member.type.kind === "UnionType" && member.type.isObjectUnionType())));
     }
+    toJSON() {
+        return {
+            ...super.toJSON(),
+            members: !this.recursive
+                ? this.members.map((member) => ({
+                    discriminantValue: member.discriminantValue.extract(),
+                    type: member.type.toJSON(),
+                }))
+                : undefined,
+        };
+    }
 }
 (function (UnionType) {
     UnionType.isMemberType = AbstractCompoundType.isMemberType;

package/dist/generators/AstJsonGenerator.d.ts

@@ -0,0 +1,6 @@
+import type * as ast from "../ast/index.js";
+import type { Generator } from "./Generator.js";
+export declare class AstJsonGenerator implements Generator {
+    generate(ast: ast.Ast): string;
+}
+//# sourceMappingURL=AstJsonGenerator.d.ts.map

package/dist/generators/AstJsonGenerator.js

@@ -0,0 +1,11 @@
+export class AstJsonGenerator {
+    generate(ast) {
+        return JSON.stringify({
+            objectTypes: ast.namedObjectTypes.map((objectType) => ({
+                ...objectType.toJSON(),
+                properties: objectType.properties.map((property) => property.toJSON()),
+            })),
+        }, undefined, 2);
+    }
+}
+//# sourceMappingURL=AstJsonGenerator.js.map

package/dist/generators/Cx2Generator.d.ts

@@ -0,0 +1,10 @@
+import type { Ast } from "../ast/Ast.js";
+import type { Generator } from "./Generator.js";
+export declare class Cx2Generator implements Generator {
+    private readonly visualProperties;
+    constructor(options?: {
+        visualProperties?: Record<string, unknown>;
+    });
+    generate(ast: Ast): string;
+}
+//# sourceMappingURL=Cx2Generator.d.ts.map

package/dist/generators/Cx2Generator.js

@@ -0,0 +1,140 @@
+import { transformAstToLabeledPropertyGraph } from "./transformAstToLabeledPropertyGraph.js";
+export class Cx2Generator {
+    visualProperties;
+    constructor(options) {
+        this.visualProperties = options?.visualProperties;
+    }
+    generate(ast) {
+        const labeledPropertyGraph = transformAstToLabeledPropertyGraph(ast);
+        const edgeAttributeDeclarations = {
+            interaction: { d: "string" },
+        };
+        const edgeIdMap = {};
+        const edges = [];
+        const nodeAttributeDeclarations = {
+            name: { d: "string" },
+        };
+        const nodeIdMap = {};
+        const nodes = [];
+        function attributeDeclaration(lpgPropertyValue) {
+            switch (lpgPropertyValue.type) {
+                case "boolean":
+                case "double":
+                case "integer":
+                case "long":
+                case "string":
+                    return { d: lpgPropertyValue.type };
+                case "boolean[]":
+                case "double[]":
+                case "integer[]":
+                case "long[]":
+                case "string[]":
+                    return {
+                        d: `list_of_${lpgPropertyValue.type.substring(0, lpgPropertyValue.type.length - 2)}`,
+                    };
+            }
+        }
+        for (const lpgNode of labeledPropertyGraph.nodes) {
+            let id = nodeIdMap[lpgNode.id];
+            if (id === undefined) {
+                id = Object.keys(nodeIdMap).length + 1;
+                nodeIdMap[lpgNode.id] = id;
+            }
+            const v = {
+                name: lpgNode.label,
+            };
+            for (const [lpgNodePropertyName, lpgNodePropertyValue] of Object.entries(lpgNode.properties)) {
+                if (lpgNodePropertyName === "name") {
+                    continue;
+                }
+                if (!nodeAttributeDeclarations[lpgNodePropertyName]) {
+                    nodeAttributeDeclarations[lpgNodePropertyName] =
+                        attributeDeclaration(lpgNodePropertyValue);
+                }
+                v[lpgNodePropertyName] = lpgNodePropertyValue.value;
+            }
+            nodes.push({
+                id,
+                v,
+            });
+        }
+        for (const lpgRelationship of labeledPropertyGraph.relationships) {
+            let id = edgeIdMap[lpgRelationship.id];
+            if (id === undefined) {
+                id = Object.keys(edgeIdMap).length + 1;
+                edgeIdMap[lpgRelationship.id] = id;
+            }
+            edges.push({
+                id,
+                s: nodeIdMap[lpgRelationship.sourceNodeId],
+                t: nodeIdMap[lpgRelationship.targetNodeId],
+                v: lpgRelationship.label
+                    .map((label) => ({ interaction: label }))
+                    .orDefault({}),
+            });
+        }
+        let visualProperties = this.visualProperties ?? {};
+        visualProperties = {
+            ...visualProperties,
+            default: {
+                edge: {
+                    ...visualProperties?.default?.edge,
+                    EDGE_LABEL: "interaction",
+                },
+            },
+            edgeMapping: {
+                ...visualProperties?.edgeMapping,
+                EDGE_LABEL: {
+                    type: "PASSTHROUGH",
+                    definition: {
+                        attribute: "interaction",
+                        type: "string",
+                    },
+                },
+            },
+        };
+        return JSON.stringify([
+            {
+                CXVersion: "2.0",
+                hasFragments: false,
+            },
+            {
+                metaData: [
+                    {
+                        elementCount: edges.length,
+                        name: "edges",
+                    },
+                    {
+                        elementCount: nodes.length,
+                        name: "nodes",
+                    },
+                ],
+            },
+            {
+                attributeDeclarations: [
+                    {
+                        edges: edgeAttributeDeclarations,
+                        nodes: nodeAttributeDeclarations,
+                    },
+                ],
+            },
+            {
+                nodes,
+            },
+            {
+                edges,
+            },
+            {
+                visualProperties: [visualProperties],
+            },
+            {
+                status: [
+                    {
+                        success: true,
+                    },
+                ],
+            },
+        ], undefined, 2);
+    }
+}
+//# sourceMappingURL=Cx2Generator.js.map

package/dist/generators/LabeledPropertyGraph.d.ts

@@ -0,0 +1,42 @@
+import type { Maybe } from "purify-ts";
+export interface LabeledPropertyGraph {
+    readonly nodes: readonly LabeledPropertyGraph.Node[];
+    readonly relationships: readonly LabeledPropertyGraph.Relationship[];
+}
+export declare namespace LabeledPropertyGraph {
+    export type Id = string;
+    export interface Node {
+        readonly id: Id;
+        readonly label: string;
+        readonly properties: Record<PropertyName, PropertyValue>;
+    }
+    export type PropertyName = string;
+    type PropertyTypeValueMap = {
+        boolean: boolean;
+        "boolean[]": readonly boolean[];
+        double: number;
+        "double[]": readonly number[];
+        integer: bigint;
+        "integer[]": readonly bigint[];
+        long: bigint;
+        "long[]": readonly bigint[];
+        string: string;
+        "string[]": readonly string[];
+    };
+    export type PropertyType = keyof PropertyTypeValueMap;
+    export type PropertyValue = {
+        [K in PropertyType]: {
+            type: K;
+            value: PropertyTypeValueMap[K];
+        };
+    }[PropertyType];
+    export interface Relationship {
+        readonly id: Id;
+        readonly label: Maybe<string>;
+        readonly properties: Record<PropertyName, PropertyValue>;
+        readonly sourceNodeId: Id;
+        readonly targetNodeId: Id;
+    }
+    export {};
+}
+//# sourceMappingURL=LabeledPropertyGraph.d.ts.map

package/dist/generators/LabeledPropertyGraph.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=LabeledPropertyGraph.js.map

package/dist/generators/index.d.ts

@@ -1,4 +1,6 @@
+export * from "./AstJsonGenerator.js";
+export * from "./Cx2Generator.js";
 export * from "./Generator.js";
-export * as json from "./json/index.js";
-export * as ts from "./ts/index.js";
+export { TsGenerator } from "./ts/TsGenerator.js";
+export { ZodGenerator } from "./ts/ZodGenerator.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/generators/index.js

@@ -1,4 +1,6 @@
+export * from "./AstJsonGenerator.js";
+export * from "./Cx2Generator.js";
 export * from "./Generator.js";
-export * as json from "./json/index.js";
-export * as ts from "./ts/index.js";
+export { TsGenerator } from "./ts/TsGenerator.js";
+export { ZodGenerator } from "./ts/ZodGenerator.js";
 //# sourceMappingURL=index.js.map

package/dist/generators/transformAstToLabeledPropertyGraph.d.ts

@@ -0,0 +1,4 @@
+import type * as ast from "../ast/index.js";
+import type { LabeledPropertyGraph } from "./LabeledPropertyGraph.js";
+export declare function transformAstToLabeledPropertyGraph(ast: ast.Ast): LabeledPropertyGraph;
+//# sourceMappingURL=transformAstToLabeledPropertyGraph.d.ts.map

package/dist/generators/transformAstToLabeledPropertyGraph.js

@@ -0,0 +1,75 @@
+import { Maybe } from "purify-ts";
+export function transformAstToLabeledPropertyGraph(ast) {
+    const nodes = [];
+    const relationships = [];
+    for (const namedObjectType of ast.namedObjectTypes) {
+        const id = typeId(namedObjectType);
+        const properties = {
+            name: { type: "string", value: typeName(namedObjectType) },
+        };
+        for (const namedObjectTypeProperty of namedObjectType.properties) {
+            let itemType;
+            switch (namedObjectTypeProperty.type.kind) {
+                case "DefaultValueType":
+                case "ListType":
+                case "OptionType":
+                case "SetType":
+                    itemType = namedObjectTypeProperty.type.itemType;
+                    break;
+                case "LazyObjectType":
+                    itemType = namedObjectTypeProperty.type.resolveType;
+                    break;
+                case "LazyObjectOptionType":
+                case "LazyObjectSetType":
+                    itemType = namedObjectTypeProperty.type.resolveType.itemType;
+                    break;
+                default:
+                    itemType = namedObjectTypeProperty.type;
+                    break;
+            }
+            switch (itemType.kind) {
+                case "IntersectionType":
+                case "ObjectType":
+                case "UnionType":
+                    if (itemType.name.isJust()) {
+                        relationships.push({
+                            id: namedObjectTypeProperty.shapeIdentifier.toString(),
+                            label: Maybe.of(namedObjectTypeProperty.name),
+                            properties: {},
+                            sourceNodeId: id,
+                            targetNodeId: typeId(itemType),
+                        });
+                    }
+                    break;
+                default:
+                    properties[namedObjectTypeProperty.name] = {
+                        type: "string",
+                        value: namedObjectTypeProperty.toString(),
+                    };
+            }
+        }
+        nodes.push({
+            id,
+            label: typeName(namedObjectType),
+            properties: properties,
+        });
+    }
+    for (const namedUnionType of ast.namedUnionTypes) {
+        nodes.push({
+            id: typeId(namedUnionType),
+            label: typeName(namedUnionType),
+            properties: {},
+        });
+    }
+    return {
+        nodes,
+        relationships,
+    };
+}
+function typeId(type) {
+    return type.name.orDefault(type.shapeIdentifier.toString());
+}
+function typeName(type) {
+    return type.name.orDefault(type.shapeIdentifier.toString());
+}
+//# sourceMappingURL=transformAstToLabeledPropertyGraph.js.map

package/dist/generators/ts/AbstractDateType.js

@@ -49,7 +49,7 @@ export class AbstractDateType extends AbstractPrimitiveType {
         return new AbstractPrimitiveType.JsonType(code `string`);
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.date(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractIdentifierType.d.ts

@@ -3,11 +3,11 @@ import type { IdentifierNodeKind } from "@shaclmate/shacl-ast";
 import { AbstractTermType } from "./AbstractTermType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare abstract class AbstractIdentifierType<IdentifierT extends BlankNode | NamedNode> extends AbstractTermType<NamedNode, IdentifierT> {
-    abstract readonly fromStringFunction: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     abstract readonly kind: "BlankNodeType" | "IdentifierType" | "IriType";
     abstract readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
-    readonly toStringFunction: Code;
+    abstract readonly parseFunction: Code;
+    readonly stringifyFunction: Code;
     get conversions(): readonly AbstractTermType.Conversion[];
     graphqlResolveExpression({ variables: { value }, }: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
 }

package/dist/generators/ts/AbstractIdentifierType.js

@@ -10,10 +10,7 @@ import { imports } from "./imports.js";
 import { code } from "./ts-poet-wrapper.js";
 export class AbstractIdentifierType extends AbstractTermType {
     graphqlType = new AbstractTermType.GraphqlType(code `${imports.GraphQLString}`);
-    toStringFunction = // Re-export rdfjsResource.Resource.Identifier.toString
-     code `\
-// biome-ignore lint/suspicious/noShadowRestrictedNames: allow toString
-export const toString = ${imports.Resource}.Identifier.toString`;
+    stringifyFunction = code `${imports.NTriplesTerm}.stringify`;
     get conversions() {
         const conversions = super.conversions.concat();
         if (this.nodeKinds.has("IRI")) {
@@ -29,7 +26,7 @@ export const toString = ${imports.Resource}.Identifier.toString`;
         return conversions;
     }
     graphqlResolveExpression({ variables: { value }, }) {
-        return code `${imports.Resource}.Identifier.toString(${value})`;
+        return code `${imports.NTriplesTerm}.stringify(${value})`;
     }
 }
 __decorate([

package/dist/generators/ts/AbstractNamedUnionType.js

@@ -92,7 +92,7 @@ ${this.jsonTypeAliasDeclaration}
 export namespace ${syntheticNamePrefix}Json {
   ${this.jsonSchemaFunctionDeclaration}
 
-  export function ${syntheticNamePrefix}parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
+  export function parse(json: unknown): ${imports.Either}<Error, ${syntheticNamePrefix}Json> {
     const jsonSafeParseResult = schema().safeParse(json);
     if (!jsonSafeParseResult.success) { return ${imports.Left}(jsonSafeParseResult.error); }
     return ${imports.Right}(jsonSafeParseResult.data);

package/dist/generators/ts/AbstractNumericType.js

@@ -51,7 +51,7 @@ export class AbstractNumericType extends AbstractPrimitiveType {
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.${this.typeofs[0]}(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/AbstractTermType.js

@@ -136,7 +136,7 @@ export class AbstractTermType extends AbstractType {
     fromRdfExpressionChain({ variables, }) {
         let valueToExpression;
         if (this.in_.length > 0) {
-            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_)), { on: ", " })}])`;
+            valueToExpression = code `value.toTerm([${joinCode(this.in_.map((in_) => rdfjsTermExpression(in_, { logger: this.logger })), { on: ", " })}])`;
         }
         else if (this.nodeKinds.size < 3) {
             const eitherTypeParameters = code `<Error, ${this.name}>`;
@@ -152,7 +152,7 @@ export class AbstractTermType extends AbstractType {
         return {
             hasValues: this.hasValues.length > 0
                 ? code `\
-chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map(rdfjsTermExpression), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
+chain(values => ${imports.Either}.sequence([${joinCode(this.hasValues.map((hasValue) => rdfjsTermExpression(hasValue, { logger: this.logger })), { on: ", " })}].map(hasValue => values.find(value => value.term.equals(hasValue)))).map(() => values))`
                 : undefined,
             valueTo: code `chain(values => values.chainMap(value => ${valueToExpression}))`,
         };

package/dist/generators/ts/AbstractType.d.ts

@@ -1,10 +1,12 @@
 import type { Maybe, NonEmptyList } from "purify-ts";
+import type { Logger } from "ts-log";
 import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 /**
  * Abstract base class all types.
  */
 export declare abstract class AbstractType {
+    protected readonly logger: Logger;
     /**
      * Is the type abstract?
      */
@@ -104,9 +106,10 @@ export declare abstract class AbstractType {
      * - variablePrefix: string prefix to use for new variables
      */
     abstract readonly valueSparqlWherePatternsFunction: Code;
-    constructor({ comment, label, }: {
+    constructor({ comment, label, logger, }: {
         comment: Maybe<string>;
         label: Maybe<string>;
+        logger: Logger;
     });
     /**
      * Helper to compose the result of schema along the type hierarchy.
@@ -177,6 +180,19 @@ export declare abstract class AbstractType {
             value: Code;
         };
     }): readonly Code[];
+    /**
+     * Zod schema for the JSON type of this type.
+     *
+     * This method is called in two contexts:
+     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
+     * "type": from another Type e.g., an OptionType or UnionType
+     *
+     * z.lazy() should only be returned for "property".
+     */
+    abstract jsonSchema(parameters: {
+        includeDiscriminantProperty?: boolean;
+        context: "property" | "type";
+    }): Code;
     /**
      * JSON-compatible version of the type.
      */
@@ -191,19 +207,6 @@ export declare abstract class AbstractType {
             scopePrefix: Code;
         };
     }): Maybe<Code>;
-    /**
-     * Zod schema for the JSON type of this type.
-     *
-     * This method is called in two contexts:
-     * "property": from a ShaclProperty, while generating the z.object properties of an NamedObjectType
-     * "type": from another Type e.g., an OptionType or UnionType
-     *
-     * z.lazy() should only be returned for "property".
-     */
-    abstract jsonSchema(parameters: {
-        includeDiscriminantProperty?: boolean;
-        context: "property" | "type";
-    }): Code;
     /**
      * An expression that converts a value of this type to a JSON-LD compatible value. It can assume the presence
      * of the correct JSON-LD context.

package/dist/generators/ts/AbstractType.js

@@ -12,6 +12,7 @@ import { code, literalOf } from "./ts-poet-wrapper.js";
  * Abstract base class all types.
  */
 export class AbstractType {
+    logger;
     /**
      * Comment from rdfs:comment.
      */
@@ -20,9 +21,10 @@ export class AbstractType {
      * Label from rdfs:label.
      */
     label;
-    constructor({ comment, label, }) {
+    constructor({ comment, label, logger, }) {
         this.comment = comment;
         this.label = label;
+        this.logger = logger;
     }
     /**
      * Helper to compose the result of schema along the type hierarchy.

package/dist/generators/ts/BlankNodeType.d.ts

@@ -5,13 +5,13 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class BlankNodeType extends AbstractIdentifierType<BlankNode> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly fromStringFunction: Code;
+    readonly parseFunction: Code;
     readonly kind = "BlankNodeType";
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<"BlankNode">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    constructor(superParameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "comment" | "label">);
+    constructor(superParameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/BlankNodeType.js

@@ -13,7 +13,7 @@ import { code } from "./ts-poet-wrapper.js";
 export class BlankNodeType extends AbstractIdentifierType {
     filterFunction = code `${snippets.filterBlankNode}`;
     filterType = code `${snippets.BlankNodeFilter}`;
-    fromStringFunction = code `export const fromString = ${snippets.blankNodeFromString};`;
+    parseFunction = code `${snippets.parseBlankNode};`;
     kind = "BlankNodeType";
     name = code `${imports.BlankNode}`;
     nodeKinds = nodeKinds;

package/dist/generators/ts/BooleanType.js

@@ -38,7 +38,7 @@ export class BooleanType extends AbstractPrimitiveType {
         return code `${imports.z}.boolean()`;
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype)})]`;
+        return code `[${snippets.literalFactory}.boolean(${variables.value}, ${rdfjsTermExpression(this.datatype, { logger: this.logger })})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {

package/dist/generators/ts/DefaultValueType.js

@@ -114,7 +114,7 @@ export class DefaultValueType extends AbstractContainerType {
         }
     }
     get defaultValueTermExpression() {
-        return rdfjsTermExpression(this.defaultValue);
+        return rdfjsTermExpression(this.defaultValue, { logger: this.logger });
     }
     fromJsonExpression(parameters) {
         return this.itemType.fromJsonExpression(parameters);

package/dist/generators/ts/IdentifierType.d.ts

@@ -6,13 +6,13 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class IdentifierType extends AbstractIdentifierType<BlankNode | NamedNode> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly fromStringFunction: Code;
+    readonly parseFunction: Code;
     readonly kind = "IdentifierType";
     readonly name: Code;
     readonly nodeKinds: ReadonlySet<IdentifierNodeKind>;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    constructor(parameters: Pick<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "comment" | "label">);
+    constructor(parameters: Omit<ConstructorParameters<typeof AbstractIdentifierType<BlankNode | NamedNode>>[0], "hasValues" | "in_">);
     fromJsonExpression({ variables, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["fromJsonExpression"]>[0]): Code;
     jsonType(parameters?: Parameters<AbstractTermType["jsonType"]>[0]): AbstractTermType.JsonType;
     jsonSchema({ includeDiscriminantProperty, }: Parameters<AbstractTermType<NamedNode, BlankNode | NamedNode>["jsonSchema"]>[0]): Code;

package/dist/generators/ts/IdentifierType.js

@@ -14,7 +14,7 @@ import { arrayOf, code } from "./ts-poet-wrapper.js";
 export class IdentifierType extends AbstractIdentifierType {
     filterFunction = code `${snippets.filterIdentifier}`;
     filterType = code `${snippets.IdentifierFilter}`;
-    fromStringFunction = code `export const fromString = ${snippets.identifierFromString};`;
+    parseFunction = code `${snippets.parseIdentifier};`;
     kind = "IdentifierType";
     name = code `(${imports.BlankNode} | ${imports.NamedNode})`;
     nodeKinds = nodeKinds;

package/dist/generators/ts/IriType.d.ts

@@ -9,7 +9,7 @@ export declare class IriType extends AbstractIdentifierType<NamedNode> {
     readonly nodeKinds: ReadonlySet<"IRI">;
     readonly schemaType: Code;
     readonly valueSparqlWherePatternsFunction: Code;
-    get fromStringFunction(): Code;
+    get parseFunction(): Code;
     get name(): Code;
     protected get schemaObject(): {
         in: Code[] | undefined;