@shaclmate/compiler 4.0.28 → 4.0.30

package/dist/generators/ts/StringType.d.ts

@@ -4,11 +4,11 @@ import { type Code } from "./ts-poet-wrapper.js";
 export declare class StringType extends AbstractPrimitiveType<string> {
     readonly filterFunction: Code;
     readonly filterType: Code;
-    readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly kind = "StringType";
     readonly schemaType: Code;
-    readonly valueSparqlWherePatternsFunction: Code;
     readonly typeofs: NonEmptyList<"string">;
+    readonly valueSparqlWherePatternsFunction: Code;
+    get graphqlType(): import("./AbstractType.js").AbstractType.GraphqlType;
     get name(): string;
     protected get schemaObject(): {
         in: import("ts-poet/build/Node.js").Node[] | undefined;

package/dist/generators/ts/StringType.js

@@ -8,18 +8,17 @@ import { xsd } from "@tpluscode/rdf-ns-builders";
 import { NonEmptyList } from "purify-ts";
 import { Memoize } from "typescript-memoize";
 import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { arrayOf, code, literalOf } from "./ts-poet-wrapper.js";
 export class StringType extends AbstractPrimitiveType {
-    filterFunction = code `${snippets.filterString}`;
-    filterType = code `${snippets.StringFilter}`;
-    graphqlType = new AbstractPrimitiveType.GraphqlType(code `${imports.GraphQLString}`);
+    filterFunction = code `${this.reusables.snippets.filterString}`;
+    filterType = code `${this.reusables.snippets.StringFilter}`;
     kind = "StringType";
-    schemaType = code `${snippets.StringSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.stringSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.StringSchema}`;
     typeofs = NonEmptyList(["string"]);
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
+    get graphqlType() {
+        return new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
+    }
     get name() {
         if (this.primitiveIn.length > 0) {
             return `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
@@ -40,15 +39,15 @@ export class StringType extends AbstractPrimitiveType {
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
             case 0:
-                return code `${imports.z}.string()`;
+                return code `${this.reusables.imports.z}.string()`;
             case 1:
-                return code `${imports.z}.literal(${this.primitiveIn[0]})`;
+                return code `${this.reusables.imports.z}.literal(${this.primitiveIn[0]})`;
             default:
-                return code `${imports.z}.enum(${arrayOf(...this.primitiveIn)})`;
+                return code `${this.reusables.imports.z}.enum(${arrayOf(...this.primitiveIn)})`;
         }
     }
     toRdfResourceValuesExpression({ variables, }) {
-        return code `[${snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${rdfjsTermExpression(this.datatype, { logger: this.logger })}` : ""})]`;
+        return code `[${this.reusables.snippets.literalFactory}.string(${variables.value}${!this.datatype.equals(xsd.string) ? `, ${this.rdfjsTermExpression(this.datatype)}` : ""})]`;
     }
     fromRdfExpressionChain({ variables, }) {
         return {
@@ -57,6 +56,9 @@ export class StringType extends AbstractPrimitiveType {
         };
     }
 }
+__decorate([
+    Memoize()
+], StringType.prototype, "graphqlType", null);
 __decorate([
     Memoize()
 ], StringType.prototype, "name", null);

package/dist/generators/ts/TermType.js

@@ -9,17 +9,14 @@ import { xsd } from "@tpluscode/rdf-ns-builders";
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractTermType } from "./AbstractTermType.js";
-import { imports } from "./imports.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression.js";
-import { snippets } from "./snippets.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TermType extends AbstractTermType {
-    filterFunction = code `${snippets.filterTerm}`;
-    filterType = code `${snippets.TermFilter}`;
+    filterFunction = code `${this.reusables.snippets.filterTerm}`;
+    filterType = code `${this.reusables.snippets.TermFilter}`;
     kind = "TermType";
     nodeKinds;
-    schemaType = code `${snippets.TermSchema}`;
-    valueSparqlWherePatternsFunction = code `${snippets.termSparqlWherePatterns}`;
+    schemaType = code `${this.reusables.snippets.TermSchema}`;
+    valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
         this.nodeKinds = nodeKinds;
@@ -34,11 +31,11 @@ export class TermType extends AbstractTermType {
             .map((nodeKind) => {
             switch (nodeKind) {
                 case "BlankNode":
-                    return imports.BlankNode;
+                    return this.reusables.imports.BlankNode;
                 case "IRI":
-                    return imports.NamedNode;
+                    return this.reusables.imports.NamedNode;
                 case "Literal":
-                    return imports.Literal;
+                    return this.reusables.imports.Literal;
                 default:
                     nodeKind;
                     throw new RangeError(nodeKind);
@@ -50,7 +47,7 @@ export class TermType extends AbstractTermType {
         return {
             ...super.schemaObject,
             in: this.in_.length > 0
-                ? this.in_.map((in_) => rdfjsTermExpression(in_, { logger: this.logger }))
+                ? this.in_.map((in_) => this.rdfjsTermExpression(in_))
                 : undefined,
         };
     }
@@ -59,13 +56,13 @@ export class TermType extends AbstractTermType {
             let valueToNodeKind;
             switch (nodeKind) {
                 case "BlankNode":
-                    valueToNodeKind = code `${imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
+                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.blankNode(${variables.value}["@id"].substring(2))`;
                     break;
                 case "IRI":
-                    valueToNodeKind = code `${imports.dataFactory}.namedNode(${variables.value}["@id"])`;
+                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@id"])`;
                     break;
                 case "Literal":
-                    valueToNodeKind = code `${imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
+                    valueToNodeKind = code `${this.reusables.imports.dataFactory}.literal(${variables.value}["@value"], ${variables.value}["@language"] !== undefined ? ${variables.value}["@language"] : (${variables.value}["@type"] !== undefined ? ${this.reusables.imports.dataFactory}.namedNode(${variables.value}["@type"]!) : undefined))`;
                     break;
                 default:
                     throw new RangeError(nodeKind);
@@ -85,13 +82,13 @@ export class TermType extends AbstractTermType {
             .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
     }
     jsonSchema(_parameters) {
-        return code `${imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
+        return code `${this.reusables.imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
             switch (nodeKind) {
                 case "BlankNode":
                 case "IRI":
-                    return code `${imports.z}.object({ "@id": ${imports.z}.string().min(1), termType: ${imports.z}.literal("${NodeKind.toTermType(nodeKind)}") })`;
+                    return code `${this.reusables.imports.z}.object({ "@id": ${this.reusables.imports.z}.string().min(1), termType: ${this.reusables.imports.z}.literal("${NodeKind.toTermType(nodeKind)}") })`;
                 case "Literal":
-                    return code `${imports.z}.object({ "@language": ${imports.z}.string().optional(), "@type": ${imports.z}.string().optional(), "@value": ${imports.z}.string(), termType: ${imports.z}.literal("Literal") })`;
+                    return code `${this.reusables.imports.z}.object({ "@language": ${this.reusables.imports.z}.string().optional(), "@type": ${this.reusables.imports.z}.string().optional(), "@value": ${this.reusables.imports.z}.string(), termType: ${this.reusables.imports.z}.literal("Literal") })`;
                 default:
                     throw new RangeError(nodeKind);
             }

package/dist/generators/ts/TsGenerator.d.ts

@@ -1,12 +1,18 @@
 import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
+import { Reusables } from "./Reusables.js";
 export declare class TsGenerator implements Generator {
-    private readonly logger;
     private readonly typeFactory;
+    protected readonly logger: Logger;
+    protected readonly reusables: Reusables;
     constructor({ logger }: {
         logger: Logger;
     });
     generate(ast_: ast.Ast): string;
+    /**
+     * Synthesize the $Object union.
+     */
+    private synthesizeUberObjectUnionType;
 }
 //# sourceMappingURL=TsGenerator.d.ts.map

package/dist/generators/ts/TsGenerator.js

@@ -1,20 +1,35 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
+import { BlankNodeType } from "./BlankNodeType.js";
 import { graphqlSchemaVariableStatement } from "./graphqlSchemaVariableStatement.js";
+import { IdentifierType } from "./IdentifierType.js";
+import { IriType } from "./IriType.js";
+import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { objectSetDeclarations } from "./objectSetDeclarations.js";
-import { snippets } from "./snippets.js";
-import { synthesizeUberObjectUnionType } from "./synthesizeUberObjectUnionType.js";
+import { Reusables } from "./Reusables.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class TsGenerator {
-    logger;
     typeFactory;
+    logger;
+    reusables;
     constructor({ logger }) {
         this.logger = logger;
-        this.typeFactory = new TypeFactory({ logger });
+        this.reusables = new Reusables({ logger });
+        this.typeFactory = new TypeFactory({
+            logger,
+            reusables: this.reusables,
+        });
     }
     generate(ast_) {
         let declarations = [];
+        for (const namedObjectType of ast_.namedObjectTypes) {
+            for (const tsImport of namedObjectType.tsImports) {
+                declarations.push(code `${tsImport}`);
+            }
+        }
         for (const astNamedUnionType of ast_.namedUnionTypes) {
             if (astNamedUnionType.isObjectUnionType()) {
                 continue;
@@ -40,26 +55,87 @@ export class TsGenerator {
                 declarations.push(code `type ${syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
                 break;
             default: {
-                const uberObjectUnionType = synthesizeUberObjectUnionType({
-                    logger: this.logger,
-                    namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
-                });
+                const uberObjectUnionType = this.synthesizeUberObjectUnionType(namedObjectTypesToposorted.toReversed());
                 declarations = declarations.concat(uberObjectUnionType.declaration.toList());
                 namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
             }
         }
-        declarations.push(...objectSetDeclarations({
+        declarations.push(...objectSetDeclarations.call(this, {
             namedObjectTypes: namedObjectTypesNameSorted,
             namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
         }));
-        declarations.push(...graphqlSchemaVariableStatement({
+        declarations.push(...graphqlSchemaVariableStatement
+            .call(this, {
             namedObjectTypes: namedObjectTypesNameSorted,
             namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
-        }).toList());
-        declarations.splice(0, 0, joinCode(Object.values(snippets)
-            .sort((left, right) => left.usageSiteName.localeCompare(right.usageSiteName))
-            .map((snippet) => code `${snippet.ifUsed}`), { on: "\n\n" }));
+        })
+            .toList());
+        declarations.splice(0, 0, joinCode(this.reusables.snippets.ifUsed, { on: "\n\n" }));
         return joinCode(declarations).toString({});
     }
+    /**
+     * Synthesize the $Object union.
+     */
+    synthesizeUberObjectUnionType(namedObjectTypes) {
+        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
+        invariant(filteredNamedObjectTypes.length > 0);
+        const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
+            for (const nodeKind of namedObjectType.identifierType.nodeKinds) {
+                nodeKinds.add(nodeKind);
+            }
+            return nodeKinds;
+        }, new Set());
+        let identifierType;
+        if (nodeKinds.size === 2) {
+            identifierType = new IdentifierType({
+                comment: Maybe.empty(),
+                label: Maybe.empty(),
+                logger: this.logger,
+                reusables: this.reusables,
+            });
+        }
+        else {
+            switch ([...nodeKinds][0]) {
+                case "BlankNode":
+                    identifierType = new BlankNodeType({
+                        comment: Maybe.empty(),
+                        label: Maybe.empty(),
+                        logger: this.logger,
+                        reusables: this.reusables,
+                    });
+                    break;
+                case "IRI":
+                    identifierType = new IriType({
+                        comment: Maybe.empty(),
+                        hasValues: [],
+                        in_: [],
+                        label: Maybe.empty(),
+                        logger: this.logger,
+                        reusables: this.reusables,
+                    });
+                    break;
+            }
+        }
+        return new NamedObjectUnionType({
+            comment: Maybe.empty(),
+            features: filteredNamedObjectTypes.reduce((features, namedObjectType) => {
+                for (const feature of namedObjectType.features) {
+                    features.add(feature);
+                }
+                features.delete("graphql");
+                return features;
+            }, new Set()),
+            identifierType,
+            label: Maybe.empty(),
+            logger: this.logger,
+            members: filteredNamedObjectTypes.map((namedObjectType) => ({
+                discriminantValue: Maybe.empty(),
+                type: namedObjectType,
+            })),
+            name: `${syntheticNamePrefix}Object`,
+            recursive: false,
+            reusables: this.reusables,
+        });
+    }
 }
 //# sourceMappingURL=TsGenerator.js.map

package/dist/generators/ts/TypeFactory.d.ts

@@ -5,14 +5,17 @@ import { AnonymousUnionType } from "./AnonymousUnionType.js";
 import { NamedObjectType } from "./NamedObjectType.js";
 import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { NamedUnionType } from "./NamedUnionType.js";
+import type { Reusables } from "./Reusables.js";
 import type { Type } from "./Type.js";
 export declare class TypeFactory {
     private cachedNamedObjectUnionTypesByShapeIdentifier;
     private cachedObjectTypePropertiesByShapeIdentifier;
     private cachedObjectTypesByShapeIdentifier;
     private readonly logger;
-    constructor({ logger }: {
+    private readonly reusables;
+    constructor({ logger, reusables }: {
         logger: Logger;
+        reusables: Reusables;
     });
     createNamedObjectUnionType(astType: ast.ObjectUnionType): NamedObjectUnionType;
     createNamedObjectType(astType: ast.ObjectType): NamedObjectType;

package/dist/generators/ts/TypeFactory.js

@@ -38,8 +38,10 @@ export class TypeFactory {
     cachedObjectTypePropertiesByShapeIdentifier = new TermMap();
     cachedObjectTypesByShapeIdentifier = new TermMap();
     logger;
-    constructor({ logger }) {
+    reusables;
+    constructor({ logger, reusables }) {
         this.logger = logger;
+        this.reusables = reusables;
     }
     createNamedObjectUnionType(astType) {
         {
@@ -60,6 +62,7 @@ export class TypeFactory {
             })),
             name: tsName(astType.name.unsafeCoerce()),
             recursive: astType.recursive,
+            reusables: this.reusables,
         });
         this.cachedNamedObjectUnionTypesByShapeIdentifier.set(astType.shapeIdentifier, namedObjectUnionType);
         return namedObjectUnionType;
@@ -81,7 +84,6 @@ export class TypeFactory {
             features: astType.tsFeatures,
             fromRdfType: astType.fromRdfType,
             identifierType,
-            imports: astType.tsImports,
             label: astType.label,
             lazyAncestorObjectTypes: () => astType.ancestorObjectTypes.map((astType) => this.createNamedObjectType(astType)),
             lazyChildObjectTypes: () => astType.childObjectTypes.map((astType) => this.createNamedObjectType(astType)),
@@ -96,6 +98,7 @@ export class TypeFactory {
                     logger: this.logger,
                     name: `${syntheticNamePrefix}type`,
                     namedObjectType,
+                    reusables: this.reusables,
                     type: new NamedObjectType.DiscriminantProperty.Type({
                         descendantValues: [...discriminantDescendantValues].sort(),
                         mutable: false,
@@ -124,14 +127,16 @@ export class TypeFactory {
                     logger: this.logger,
                     name: `${syntheticNamePrefix}identifier`,
                     namedObjectType,
+                    reusables: this.reusables,
                     type: identifierType,
-                    typeAlias: code `${name}.${syntheticNamePrefix}Identifier`,
+                    typeAlias: code `${name}.Identifier`,
                 }));
                 return properties;
             },
             logger: this.logger,
             name,
             recursive: astType.recursive,
+            reusables: this.reusables,
             synthetic: astType.synthetic,
             toRdfTypes: astType.toRdfTypes,
         });
@@ -189,6 +194,7 @@ export class TypeFactory {
             })),
             name,
             recursive: astType.recursive,
+            reusables: this.reusables,
         }))
             .orDefaultLazy(() => new AnonymousUnionType({
             comment: astType.comment,
@@ -200,6 +206,7 @@ export class TypeFactory {
                 type: this.createType(member.type),
             })),
             recursive: astType.recursive,
+            reusables: this.reusables,
         }));
     }
     createBlankNodeType(astType) {
@@ -207,6 +214,7 @@ export class TypeFactory {
             comment: astType.comment,
             label: astType.label,
             logger: this.logger,
+            reusables: this.reusables,
         });
     }
     createDefaultValueType(astType) {
@@ -220,6 +228,7 @@ export class TypeFactory {
             itemType,
             label: astType.label,
             logger: this.logger,
+            reusables: this.reusables,
         });
     }
     createIdentifierType(astType) {
@@ -231,6 +240,7 @@ export class TypeFactory {
                     comment: astType.comment,
                     label: astType.label,
                     logger: this.logger,
+                    reusables: this.reusables,
                 });
             case "IriType":
                 return this.createIriType(astType);
@@ -243,6 +253,7 @@ export class TypeFactory {
             in_: astType.in_,
             label: astType.label,
             logger: this.logger,
+            reusables: this.reusables,
         });
     }
     createLazyObjectOptionType(astType) {
@@ -252,6 +263,7 @@ export class TypeFactory {
             logger: this.logger,
             partialType: this.createOptionType(astType.partialType),
             resolveType: this.createOptionType(astType.resolveType),
+            reusables: this.reusables,
         });
     }
     createLazyObjectSetType(astType) {
@@ -261,6 +273,7 @@ export class TypeFactory {
             logger: this.logger,
             partialType: this.createSetType(astType.partialType),
             resolveType: this.createSetType(astType.resolveType),
+            reusables: this.reusables,
         });
     }
     createLazyObjectType(astType) {
@@ -270,6 +283,7 @@ export class TypeFactory {
             logger: this.logger,
             partialType: this.createType(astType.partialType),
             resolveType: this.createType(astType.resolveType),
+            reusables: this.reusables,
         });
     }
     createListType(astType) {
@@ -283,6 +297,7 @@ export class TypeFactory {
             logger: this.logger,
             minCount: 0n,
             mutable: astType.mutable,
+            reusables: this.reusables,
             toRdfTypes: astType.toRdfTypes,
         });
     }
@@ -317,6 +332,7 @@ export class TypeFactory {
                             label: astType.label,
                             languageIn: [],
                             logger: this.logger,
+                            reusables: this.reusables,
                         });
                     case "bigint":
                         return new BigIntType({
@@ -328,6 +344,7 @@ export class TypeFactory {
                             languageIn: [],
                             logger: this.logger,
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBigIntLiteral(value).unsafeCoerce()),
+                            reusables: this.reusables,
                         });
                     case "boolean":
                         return new BooleanType({
@@ -339,6 +356,7 @@ export class TypeFactory {
                             in_: astType.in_,
                             logger: this.logger,
                             primitiveIn: astType.in_.map((value) => LiteralDecoder.decodeBooleanLiteral(value).unsafeCoerce()),
+                            reusables: this.reusables,
                         });
                     case "date":
                     case "datetime":
@@ -353,6 +371,7 @@ export class TypeFactory {
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "date"
                                 ? LiteralDecoder.decodeDateLiteral
                                 : LiteralDecoder.decodeDateTimeLiteral)(value).unsafeCoerce()),
+                            reusables: this.reusables,
                         });
                     case "float":
                     case "int":
@@ -367,6 +386,7 @@ export class TypeFactory {
                             primitiveIn: astType.in_.map((value) => (datatypeDefinition.kind === "float"
                                 ? LiteralDecoder.decodeFloatLiteral
                                 : LiteralDecoder.decodeIntLiteral)(value).unsafeCoerce()),
+                            reusables: this.reusables,
                         });
                     case "string":
                         if (!datatype.equals(rdf.langString)) {
@@ -379,6 +399,7 @@ export class TypeFactory {
                                 languageIn: astType.languageIn,
                                 logger: this.logger,
                                 primitiveIn: astType.in_.map((value) => value.value),
+                                reusables: this.reusables,
                             });
                         }
                         break;
@@ -404,6 +425,7 @@ export class TypeFactory {
             label: astType.label,
             languageIn: astType.languageIn,
             logger: this.logger,
+            reusables: this.reusables,
         });
     }
     createObjectTypeProperty({ astObjectTypeProperty, namedObjectType, }) {
@@ -424,6 +446,7 @@ export class TypeFactory {
             name: tsName(astObjectTypeProperty.name),
             path: astObjectTypeProperty.path,
             recursive: !!astObjectTypeProperty.recursive,
+            reusables: this.reusables,
             type: this.createType(astObjectTypeProperty.type),
         });
         this.cachedObjectTypePropertiesByShapeIdentifier.set(astObjectTypeProperty.shapeIdentifier, property);
@@ -437,6 +460,7 @@ export class TypeFactory {
             itemType,
             label: astType.label,
             logger: this.logger,
+            reusables: this.reusables,
         });
     }
     createSetType(astType) {
@@ -449,6 +473,7 @@ export class TypeFactory {
             logger: this.logger,
             mutable: astType.mutable,
             minCount: astType.minCount,
+            reusables: this.reusables,
         });
     }
     createTermType(astType) {
@@ -459,6 +484,7 @@ export class TypeFactory {
             label: astType.label,
             logger: this.logger,
             nodeKinds: astType.nodeKinds,
+            reusables: this.reusables,
         });
     }
 }

package/dist/generators/ts/ZodGenerator.d.ts

@@ -2,6 +2,7 @@ import type { Logger } from "ts-log";
 import * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 export declare class ZodGenerator implements Generator {
+    private readonly reusables;
     private readonly typeFactory;
     constructor({ logger }: {
         logger: Logger;

package/dist/generators/ts/ZodGenerator.js

@@ -2,14 +2,18 @@ import { invariant } from "ts-invariant";
 import * as ast from "../../ast/index.js";
 import { NamedObjectType_jsonSchemaFunctionDeclaration } from "./_NamedObjectType/NamedObjectType_jsonSchemaFunctionDeclaration.js";
 import { NamedObjectType_jsonTypeAliasDeclaration } from "./_NamedObjectType/NamedObjectType_jsonTypeAliasDeclaration.js";
-import { snippets } from "./snippets.js";
-import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
+import { Reusables } from "./Reusables.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
 export class ZodGenerator {
+    reusables;
     typeFactory;
     constructor({ logger }) {
-        this.typeFactory = new TypeFactory({ logger });
+        this.reusables = new Reusables({ logger });
+        this.typeFactory = new TypeFactory({
+            logger,
+            reusables: this.reusables,
+        });
     }
     generate(ast_) {
         const declarations = [];
@@ -18,7 +22,7 @@ export class ZodGenerator {
 export namespace ${namedObjectType.name} {
   ${joinCode(NamedObjectType_jsonTypeAliasDeclaration.bind(namedObjectType)().toList())}
 
-  export namespace ${syntheticNamePrefix}Json {
+  export namespace Json {
     ${joinCode(NamedObjectType_jsonSchemaFunctionDeclaration.bind(namedObjectType)().toList())}
   }
 }`);
@@ -28,14 +32,12 @@ export namespace ${namedObjectType.name} {
             declarations.push(code `\
 export namespace ${astNamedUnionType.name} {
   ${astNamedUnionType.jsonTypeAliasDeclaration}
-  export namespace ${syntheticNamePrefix}Json {
+  export namespace Json {
     ${astNamedUnionType.jsonSchemaFunctionDeclaration}
   }
 }`);
         }
-        declarations.splice(0, 0, joinCode(Object.values(snippets)
-            .sort((left, right) => left.usageSiteName.localeCompare(right.usageSiteName))
-            .map((snippet) => code `${snippet.ifUsed}`), { on: "\n\n" }));
+        declarations.splice(0, 0, joinCode(this.reusables.snippets.ifUsed, { on: "\n\n" }));
         return joinCode(declarations, { on: "\n\n" }).toString({});
     }
 }

package/dist/generators/ts/_NamedObjectType/AbstractProperty.d.ts

@@ -1,11 +1,15 @@
 import type { Maybe } from "purify-ts";
 import type { Logger } from "ts-log";
 import type { NamedObjectType } from "../NamedObjectType.js";
+import type { Reusables } from "../Reusables.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import type { Type } from "../Type.js";
 import { type Code } from "../ts-poet-wrapper.js";
 export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterFunction" | "mutable" | "name" | "schema">> {
     protected readonly logger: Logger;
     protected readonly namedObjectType: NamedObjectType;
+    protected readonly reusables: Reusables;
+    protected readonly rdfjsTermExpression: (parameters: Parameters<typeof rdfjsTermExpression>[0]) => Code;
     /**
      * Optional property to include in the parameters object of a class constructor.
      */
@@ -64,10 +68,11 @@ export declare abstract class AbstractProperty<TypeT extends Pick<Type, "filterF
      * Property type
   .   */
     readonly type: TypeT;
-    constructor({ logger, name, namedObjectType, type, }: {
+    constructor({ logger, name, namedObjectType, reusables, type, }: {
         logger: Logger;
         name: string;
         namedObjectType: NamedObjectType;
+        reusables: Reusables;
         type: TypeT;
     });
     /**

package/dist/generators/ts/_NamedObjectType/AbstractProperty.js

@@ -6,11 +6,14 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { removeUndefined } from "../removeUndefined.js";
 import { code, literalOf } from "../ts-poet-wrapper.js";
 export class AbstractProperty {
     logger;
     namedObjectType;
+    reusables;
+    rdfjsTermExpression;
     /**
      * TypeScript identifier-safe name of the property.
      */
@@ -19,11 +22,17 @@ export class AbstractProperty {
      * Property type
   .   */
     type;
-    constructor({ logger, name, namedObjectType, type, }) {
+    constructor({ logger, name, namedObjectType, reusables, type, }) {
         this.logger = logger;
         this.name = name;
         this.namedObjectType = namedObjectType;
+        this.reusables = reusables;
         this.type = type;
+        this.rdfjsTermExpression = rdfjsTermExpression.bind({
+            imports: this.reusables.imports,
+            logger: this.logger,
+            snippets: this.reusables.snippets,
+        });
     }
     /**
      * TypeScript object describing this type, for runtime use.