@shaclmate/compiler 4.0.39 → 4.0.41

package/dist/generators/ts/RdfjsDatasetObjectSetType.js

@@ -56,7 +56,7 @@ async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${
 }`,
                     // objectSync
                     code `\
-${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${this.reusables.imports.Either}<Error, ${namedObjectType.name}> {
+${methodSignatures.object.name}Sync(${methodSignatures.object.parameters}): ${this.reusables.imports.Either}<Error, ${namedObjectType.expression}> {
   return this.${methodSignatures.objects.name}Sync({ identifiers: [identifier], preferredLanguages: options?.preferredLanguages }).map(objects => objects[0]);
 }`,
                     // objectCount
@@ -87,22 +87,19 @@ async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}):
                     // objectsSync has per-object type logic, not just forwarding
                 ];
                 const runtimeObjectType = (filterFunction, namedObjectType) => {
-                    const fromRdfTypes = namedObjectType.fromRdfTypeVariable
-                        .toList()
-                        .concat(namedObjectType.descendantFromRdfTypeVariables);
-                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.name}.fromRdfResource, fromRdfTypes: ${fromRdfTypes.length > 0 ? code `[${joinCode(fromRdfTypes, { on: ", " })}]` : "[]"} }`;
+                    return code `{ filter: ${filterFunction}, fromRdfResource: ${namedObjectType.expression}.fromRdfResource, fromRdfTypes: ${namedObjectType.fromRdfTypeVariable.map((fromRdfTypeVariable) => code `[${fromRdfTypeVariable}]`).orDefault(code `[]`)} }`;
                 };
                 switch (namedObjectType.kind) {
-                    case "NamedObjectType": {
+                    case "Object": {
                         return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.#objectsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
+  return this.#objectsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType(namedObjectType.filterFunction, namedObjectType)}, query);
 }`);
                     }
-                    case "NamedObjectUnion":
+                    case "ObjectUnion":
                         return delegatingMethods.concat(code `\
-${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name}[]> {
-  return this.#objectUnionsSync<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
+${methodSignatures.objects.name}Sync(${methodSignatures.objects.parameters}): ${this.reusables.imports.Either}<Error, readonly ${namedObjectType.expression}[]> {
+  return this.#objectUnionsSync<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>([
     ${joinCode(namedObjectType.members.map((member) => runtimeObjectType(namedObjectType.filterFunction, member.type)), { on: ", " })}
   ], query);
 }`);

package/dist/generators/ts/SetType.d.ts

@@ -1,17 +1,32 @@
+import { Maybe } from "purify-ts";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { AbstractContainerType } from "./AbstractContainerType.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class SetType<ItemTypeT extends SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
     readonly graphqlArgs: AbstractCollectionType<ItemTypeT>["graphqlArgs"];
     readonly kind = "Set";
+    readonly minCount: bigint;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
+    }];
+    constructor({ minCount, ...superParameters }: {
+        minCount: bigint;
+    } & ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0]);
+    get conversionFunction(): Maybe<AbstractCollectionType.ConversionFunction>;
+    get toRdfResourceValueTypes(): AbstractCollectionType<ItemTypeT>["toRdfResourceValueTypes"];
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
+    protected get schemaInitializers(): readonly Code[];
+    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
     fromRdfResourceValuesExpression(parameters: Parameters<AbstractCollectionType<ItemTypeT>["fromRdfResourceValuesExpression"]>[0]): Code;
+    jsonSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonSchema"]>[0]): Code;
     jsonType(): AbstractCollectionType.JsonType;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toRdfResourceValuesExpression"]>[0]): Code;
     toStringExpression({ variables, }: Parameters<AbstractCollectionType<ItemTypeT>["toStringExpression"]>[0]): Code;
 }
 export declare namespace SetType {
     type ItemType = AbstractCollectionType.ItemType;
-    const isItemType: typeof import("./AbstractContainerType.js").AbstractContainerType.isItemType;
+    const isItemType: typeof AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=SetType.d.ts.map

package/dist/generators/ts/SetType.js

@@ -5,18 +5,80 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
 import { AbstractCollectionType } from "./AbstractCollectionType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
+import { code, joinCode, literalOf } from "./ts-poet-wrapper.js";
 export class SetType extends AbstractCollectionType {
     graphqlArgs = Maybe.empty();
     kind = "Set";
+    minCount;
+    jsTypes = [
+        { instanceof: "Array", typeof: "object" },
+    ];
+    constructor({ minCount, ...superParameters }) {
+        super(superParameters);
+        this.minCount = minCount;
+        invariant(this.minCount >= 0n);
+        if (this._mutable) {
+            invariant(this.minCount === 0n);
+        }
+    }
+    get conversionFunction() {
+        const itemConversionFunction = this.itemType.conversionFunction.orDefault(this.itemConversionFunctionDefault);
+        let conversionFunction;
+        const sourceTypes = [];
+        if (itemConversionFunction.sourceTypes.some((sourceType) => sourceType.jsType.typeof === "object" &&
+            sourceType.jsType.instanceof === "Array")) {
+            conversionFunction = this.reusables.snippets.convertToArraySet;
+        }
+        else {
+            conversionFunction = this.reusables.snippets.convertToScalarSet;
+            // Convert from a single item
+            sourceTypes.push(...itemConversionFunction.sourceTypes);
+        }
+        // Convert from an array of items
+        sourceTypes.push({
+            expression: code `readonly (${joinCode(itemConversionFunction.sourceTypes.map((itemSourceType) => code `${itemSourceType.expression}`), { on: " | " })})[]`,
+            jsType: { instanceof: "Array", typeof: "object" },
+        });
+        // Convert from undefined to an empty array
+        if (this.minCount === 0n) {
+            sourceTypes.push({
+                expression: code `undefined`,
+                jsType: { typeof: "undefined" },
+            });
+        }
+        return Maybe.of({
+            code: code `${conversionFunction}(${itemConversionFunction.code}, ${literalOf(!this._mutable)})`,
+            sourceTypes,
+        });
+    }
+    get toRdfResourceValueTypes() {
+        return this.itemType.toRdfResourceValueTypes;
+    }
     get valueSparqlConstructTriplesFunction() {
         return code `${this.reusables.snippets.setSparqlConstructTriples}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlConstructTriplesFunction})`;
     }
     get valueSparqlWherePatternsFunction() {
         return code `${this.reusables.snippets.setSparqlWherePatterns}<${this.itemType.filterType}, ${this.itemType.schemaType}>(${this.itemType.valueSparqlWherePatternsFunction})`;
     }
+    get schemaInitializers() {
+        let schemaInitializers = super.schemaInitializers;
+        if (this.minCount > 0n) {
+            schemaInitializers = schemaInitializers.concat(code `minCount: ${Number(this.minCount)}`);
+        }
+        return schemaInitializers;
+    }
+    fromJsonExpression({ variables, }) {
+        let expression = variables.value;
+        if (this.minCount === 0n) {
+            expression = code `(${expression} ?? [])`;
+        }
+        return code `${this.reusables.imports.Either}.sequence<Error, ${this.itemType.expression}>(${expression}.map(item => (${this.itemType.fromJsonExpression({
+            variables: { value: code `item` },
+        })})))`;
+    }
     fromRdfResourceValuesExpression(parameters) {
         const { variables } = parameters;
         return joinCode([
@@ -25,8 +87,21 @@ export class SetType extends AbstractCollectionType {
             code `map(valuesArray => ${this.reusables.imports.Resource}.Values.fromValue({ focusResource: ${variables.resource}, propertyPath: ${variables.propertyPath}, value: valuesArray }))`,
         ], { on: "." });
     }
+    jsonSchema(parameters) {
+        let schema = code `${this.itemType.jsonSchema(parameters)}.array()`;
+        if (this.minCount > 0n) {
+            schema = code `${schema}.nonempty().min(${this.minCount})`;
+        }
+        else {
+            schema = code `${schema}.optional()`;
+        }
+        if (!this._mutable) {
+            schema = code `${schema}.readonly()`;
+        }
+        return schema;
+    }
     jsonType() {
-        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().name})[]`;
+        const name = code `${!this.mutable ? "readonly " : ""}(${this.itemType.jsonType().expression})[]`;
         if (this.minCount === 0n) {
             return new AbstractCollectionType.JsonType(name, { optional: true });
         }
@@ -41,6 +116,9 @@ export class SetType extends AbstractCollectionType {
         return code `(${variables.value}.length > 0 ? \`[\${${variables.value}.map(item => (${this.itemType.toStringExpression({ variables: { value: code `item` } })}))}]\` : undefined)`;
     }
 }
+__decorate([
+    Memoize()
+], SetType.prototype, "conversionFunction", null);
 __decorate([
     Memoize()
 ], SetType.prototype, "valueSparqlConstructTriplesFunction", null);

package/dist/generators/ts/Snippets.d.ts

@@ -69,7 +69,7 @@ export declare class Snippets {
     get booleanEquals(): Snippet;
     get booleanSparqlWherePatterns(): Snippet;
     get compactRecord(): Snippet;
-    get convertToArray(): Snippet;
+    get convertToArraySet(): Snippet;
     get convertToBlankNode(): Snippet;
     get convertToBlankNodeIdentifierProperty(): Snippet;
     get convertToIdentifier(): Snippet;
@@ -79,8 +79,10 @@ export declare class Snippets {
     get convertToLazyObject(): Snippet;
     get convertToLazyObjectOption(): Snippet;
     get convertToLazyObjectSet(): Snippet;
+    get convertToList(): Snippet;
     get convertToLiteral(): Snippet;
     get convertToMaybe(): Snippet;
+    get convertToScalarSet(): Snippet;
     get convertWithDefaultValue(): Snippet;
     get dateEquals(): Snippet;
     get dateSparqlWherePatterns(): Snippet;

package/dist/generators/ts/Snippets.js

@@ -23,7 +23,7 @@ import { snippets_CollectionFilter } from "./_snippets/snippets_CollectionFilter
 import { snippets_CollectionSchema } from "./_snippets/snippets_CollectionSchema.js";
 import { snippets_ConversionFunction } from "./_snippets/snippets_ConversionFunction.js";
 import { snippets_compactRecord } from "./_snippets/snippets_compactRecord.js";
-import { snippets_convertToArray } from "./_snippets/snippets_convertToArray.js";
+import { snippets_convertToArraySet } from "./_snippets/snippets_convertToArraySet.js";
 import { snippets_convertToBlankNode } from "./_snippets/snippets_convertToBlankNode.js";
 import { snippets_convertToBlankNodeIdentifierProperty } from "./_snippets/snippets_convertToBlankNodeIdentifierProperty.js";
 import { snippets_convertToIdentifier } from "./_snippets/snippets_convertToIdentifier.js";
@@ -33,8 +33,10 @@ import { snippets_convertToIriIdentifierProperty } from "./_snippets/snippets_co
 import { snippets_convertToLazyObject } from "./_snippets/snippets_convertToLazyObject.js";
 import { snippets_convertToLazyObjectOption } from "./_snippets/snippets_convertToLazyObjectOption.js";
 import { snippets_convertToLazyObjectSet } from "./_snippets/snippets_convertToLazyObjectSet.js";
+import { snippets_convertToList } from "./_snippets/snippets_convertToList.js";
 import { snippets_convertToLiteral } from "./_snippets/snippets_convertToLiteral.js";
 import { snippets_convertToMaybe } from "./_snippets/snippets_convertToMaybe.js";
+import { snippets_convertToScalarSet } from "./_snippets/snippets_convertToScalarSet.js";
 import { snippets_convertWithDefaultValue } from "./_snippets/snippets_convertWithDefaultValue.js";
 import { snippets_DateFilter } from "./_snippets/snippets_DateFilter.js";
 import { snippets_DateSchema } from "./_snippets/snippets_DateSchema.js";
@@ -326,8 +328,8 @@ export class Snippets {
     get compactRecord() {
         return this.snippet(snippets_compactRecord);
     }
-    get convertToArray() {
-        return this.snippet(snippets_convertToArray);
+    get convertToArraySet() {
+        return this.snippet(snippets_convertToArraySet);
     }
     get convertToBlankNode() {
         return this.snippet(snippets_convertToBlankNode);
@@ -356,12 +358,18 @@ export class Snippets {
     get convertToLazyObjectSet() {
         return this.snippet(snippets_convertToLazyObjectSet);
     }
+    get convertToList() {
+        return this.snippet(snippets_convertToList);
+    }
     get convertToLiteral() {
         return this.snippet(snippets_convertToLiteral);
     }
     get convertToMaybe() {
         return this.snippet(snippets_convertToMaybe);
     }
+    get convertToScalarSet() {
+        return this.snippet(snippets_convertToScalarSet);
+    }
     get convertWithDefaultValue() {
         return this.snippet(snippets_convertWithDefaultValue);
     }
@@ -779,7 +787,7 @@ __decorate([
 ], Snippets.prototype, "compactRecord", null);
 __decorate([
     Memoize()
-], Snippets.prototype, "convertToArray", null);
+], Snippets.prototype, "convertToArraySet", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToBlankNode", null);
@@ -807,12 +815,18 @@ __decorate([
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToLazyObjectSet", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToList", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToLiteral", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertToMaybe", null);
+__decorate([
+    Memoize()
+], Snippets.prototype, "convertToScalarSet", null);
 __decorate([
     Memoize()
 ], Snippets.prototype, "convertWithDefaultValue", null);

package/dist/generators/ts/SparqlObjectSetType.js

@@ -42,7 +42,7 @@ ${joinCode([...this.namedObjectTypes, ...this.namedObjectUnionTypes].flatMap((na
             const methodSignatures = this.methodSignatures(namedObjectType, {
                 queryT: `${syntheticNamePrefix}SparqlObjectSet.Query`,
             });
-            const runtimeObjectType = namedObjectType.name;
+            const runtimeObjectType = namedObjectType.expression;
             return [
                 code `\
 async ${methodSignatures.object.name}(${methodSignatures.object.parameters}): ${methodSignatures.object.returnType} {
@@ -58,7 +58,7 @@ async ${methodSignatures.objectIdentifiers.name}(${methodSignatures.objectIdenti
 }`,
                 code `\
 async ${methodSignatures.objects.name}(${methodSignatures.objects.parameters}): ${methodSignatures.objects.returnType} {
-  return this.#objects<${namedObjectType.name}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
+  return this.#objects<${namedObjectType.expression}, ${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>(${runtimeObjectType}, query);
 }`,
             ];
         }), { on: "\n\n" })}

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

@@ -6,11 +6,13 @@ export declare class StringType extends AbstractPrimitiveType<string> {
     readonly filterType: Code;
     readonly graphqlType: import("./AbstractType.js").AbstractType.GraphqlType;
     readonly hashFunction: Code;
+    readonly jsTypes: readonly [{
+        readonly typeof: "string";
+    }];
     readonly kind = "String";
-    readonly schemaType: Code;
-    readonly typeofs: "string"[];
     readonly valueSparqlWherePatternsFunction: Code;
-    get name(): string;
+    get expression(): Code;
+    get schemaType(): Code;
     jsonSchema(_parameters: Parameters<AbstractPrimitiveType<string>["jsonSchema"]>[0]): Code;
     literalExpression(literal: Literal | string): Code;
     toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;

package/dist/generators/ts/StringType.js

@@ -13,15 +13,21 @@ export class StringType extends AbstractPrimitiveType {
     filterType = code `${this.reusables.snippets.StringFilter}`;
     graphqlType = new AbstractPrimitiveType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
     hashFunction = code `${this.reusables.snippets.hashString}`;
+    jsTypes = [
+        {
+            typeof: "string",
+        },
+    ];
     kind = "String";
-    schemaType = code `${this.reusables.snippets.StringSchema}<${this.name}>`;
-    typeofs = ["string"];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.stringSparqlWherePatterns}`;
-    get name() {
+    get expression() {
         if (this.primitiveIn.length > 0) {
-            return `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
+            return code `${this.primitiveIn.map((value) => `"${value}"`).join(" | ")}`;
         }
-        return `string`;
+        return code `string`;
+    }
+    get schemaType() {
+        return code `${this.reusables.snippets.StringSchema}<${this.expression}>`;
     }
     jsonSchema(_parameters) {
         switch (this.primitiveIn.length) {
@@ -48,5 +54,8 @@ export class StringType extends AbstractPrimitiveType {
 }
 __decorate([
     Memoize()
-], StringType.prototype, "name", null);
+], StringType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], StringType.prototype, "schemaType", null);
 //# sourceMappingURL=StringType.js.map

package/dist/generators/ts/TermType.d.ts

@@ -10,16 +10,20 @@ export declare class TermType<ConstantTermT extends Literal | NamedNode = Litera
     readonly kind = "Term";
     readonly nodeKinds: ReadonlySet<NodeKind>;
     readonly schemaType: Code;
+    readonly jsTypes: readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
+    }];
     readonly valueSparqlWherePatternsFunction: Code;
     constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<ConstantTermT, RuntimeTermT>>[0] & {
         nodeKinds: ReadonlySet<NodeKind>;
     });
+    get expression(): Code;
     get graphqlType(): AbstractTermType.GraphqlType;
-    get name(): Code;
     fromJsonExpression({ variables, }: Parameters<AbstractTermType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression(_parameters: Parameters<AbstractTermType["graphqlResolveExpression"]>[0]): Code;
-    jsonType(): AbstractTermType.JsonType;
     jsonSchema(_parameters: Parameters<AbstractTermType["jsonSchema"]>[0]): Code;
+    jsonType(): AbstractTermType.JsonType;
     toJsonExpression({ variables, }: Parameters<AbstractTermType["toJsonExpression"]>[0]): Code;
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/generators/ts/TermType.js

@@ -18,6 +18,9 @@ export class TermType extends AbstractTermType {
     kind = "Term";
     nodeKinds;
     schemaType = code `${this.reusables.snippets.TermSchema}`;
+    jsTypes = [
+        { instanceof: "Object", typeof: "object" },
+    ];
     valueSparqlWherePatternsFunction = code `${this.reusables.snippets.termSparqlWherePatterns}`;
     constructor({ nodeKinds, ...superParameters }) {
         super(superParameters);
@@ -25,10 +28,7 @@ export class TermType extends AbstractTermType {
         invariant(this.nodeKinds.has("Literal") &&
             (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
     }
-    get graphqlType() {
-        throw new Error("not implemented");
-    }
-    get name() {
+    get expression() {
         return code `(${joinCode([...this.nodeKinds]
             .map((nodeKind) => {
             switch (nodeKind) {
@@ -45,8 +45,11 @@ export class TermType extends AbstractTermType {
         })
             .map((import_) => code `${import_}`), { on: " | " })})`;
     }
+    get graphqlType() {
+        throw new Error("not implemented");
+    }
     fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.name}>(${[
+        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${[
             ...this.nodeKinds,
         ].reduce((expression, nodeKind) => {
             let valueToNodeKind;
@@ -71,12 +74,6 @@ export class TermType extends AbstractTermType {
     graphqlResolveExpression(_parameters) {
         throw new Error("not implemented");
     }
-    jsonType() {
-        return new AbstractTermType.JsonType(code `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
-            .filter((nodeKind) => nodeKind !== "Literal")
-            .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
-            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
-    }
     jsonSchema(_parameters) {
         return code `${this.reusables.imports.z}.discriminatedUnion("termType", [${joinCode([...this.nodeKinds].map((nodeKind) => {
             switch (nodeKind) {
@@ -90,6 +87,12 @@ export class TermType extends AbstractTermType {
             }
         }), { on: "," })}])`;
     }
+    jsonType() {
+        return new AbstractTermType.JsonType(code `{ readonly "@id": string, readonly termType: ${[...this.nodeKinds]
+            .filter((nodeKind) => nodeKind !== "Literal")
+            .map((nodeKind) => `"${NodeKind.toTermType(nodeKind)}"`)
+            .join(" | ")} } | { readonly "@language"?: string, readonly "@type"?: string, readonly "@value": string, readonly termType: "Literal" }`);
+    }
     toJsonExpression({ variables, }) {
         return [...this.nodeKinds].reduce((expression, nodeKind) => {
             let valueToNodeKind;
@@ -114,7 +117,7 @@ export class TermType extends AbstractTermType {
 }
 __decorate([
     Memoize()
-], TermType.prototype, "name", null);
+], TermType.prototype, "expression", null);
 __decorate([
     Memoize()
 ], TermType.prototype, "jsonType", null);

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

@@ -1,5 +1,5 @@
 import type { Logger } from "ts-log";
-import * as ast from "../../ast/index.js";
+import type * as ast from "../../ast/index.js";
 import type { Generator } from "../Generator.js";
 import type { TsFeature } from "./TsFeature.js";
 export declare class TsGenerator implements Generator {

package/dist/generators/ts/TsGenerator.js

@@ -1,17 +1,19 @@
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
-import * as ast from "../../ast/index.js";
 import { BlankNodeType } from "./BlankNodeType.js";
 import { GraphqlSchema } from "./GraphqlSchema.js";
 import { IdentifierType } from "./IdentifierType.js";
 import { IriType } from "./IriType.js";
-import { NamedObjectUnionType } from "./NamedObjectUnionType.js";
 import { ObjectSetType } from "./ObjectSetType.js";
+import { ObjectUnionType } from "./ObjectUnionType.js";
 import { RdfjsDatasetObjectSetType } from "./RdfjsDatasetObjectSetType.js";
 import { Reusables } from "./Reusables.js";
 import { SparqlObjectSetType } from "./SparqlObjectSetType.js";
 import { TypeFactory } from "./TypeFactory.js";
 import { code, joinCode } from "./ts-poet-wrapper.js";
+function compareTsNamedType(left, right) {
+    return left.alias.unsafeCoerce().localeCompare(right.alias.unsafeCoerce());
+}
 export class TsGenerator {
     configuration;
     logger;
@@ -31,54 +33,77 @@ export class TsGenerator {
             reusables,
         });
         let declarations = [];
-        for (const namedObjectType of ast_.namedObjectTypes) {
-            for (const tsImport of namedObjectType.tsImports) {
-                declarations.push(code `${tsImport}`);
+        const tsNamedTypes = [];
+        const tsNamedObjectTypes = [];
+        const tsNamedObjectUnionTypes = [];
+        for (const astNamedType of ast_.namedTypes) {
+            const tsNamedType = typeFactory.createType(astNamedType);
+            tsNamedTypes.push(tsNamedType);
+            if (astNamedType.kind === "Object") {
+                for (const tsImport of astNamedType.tsImports) {
+                    declarations.push(code `${tsImport}`);
+                }
             }
-        }
-        for (const astNamedUnionType of ast_.namedUnionTypes) {
-            if (astNamedUnionType.isObjectUnionType()) {
-                continue;
+            switch (tsNamedType.kind) {
+                case "Object":
+                    tsNamedObjectTypes.push(tsNamedType);
+                    break;
+                case "ObjectUnion":
+                    tsNamedObjectUnionTypes.push(tsNamedType);
+                    break;
             }
-            declarations = declarations.concat(typeFactory.createType(astNamedUnionType).declaration.toList());
         }
-        const namedObjectTypesToposorted = ast.ObjectType.toposort(ast_.namedObjectTypes).map((astObjectType) => typeFactory.createNamedObjectType(astObjectType));
-        const namedObjectUnionTypesToposorted = ast_.namedUnionTypes
-            .filter((_) => _.isObjectUnionType())
-            .map((astObjectUnionType) => typeFactory.createNamedObjectUnionType(astObjectUnionType));
-        for (const namedObjectType of namedObjectTypesToposorted) {
-            declarations = declarations.concat(namedObjectType.declaration.toList());
+        tsNamedTypes.sort(compareTsNamedType);
+        tsNamedObjectTypes.sort(compareTsNamedType);
+        tsNamedObjectUnionTypes.sort(compareTsNamedType);
+        for (const tsNamedType of tsNamedTypes) {
+            switch (tsNamedType.kind) {
+                case "ObjectUnion":
+                case "Union":
+                    continue; // Declare compound types last.
+            }
+            tsNamedType.declaration.ifJust((declaration) => {
+                declarations.push(declaration);
+            });
         }
-        for (const namedObjectUnionType of namedObjectUnionTypesToposorted) {
-            declarations = declarations.concat(namedObjectUnionType.declaration.toList());
+        // Declare compound types last.
+        for (const tsNamedType of tsNamedTypes) {
+            switch (tsNamedType.kind) {
+                case "ObjectUnion":
+                case "Union":
+                    break;
+                default:
+                    continue;
+            }
+            tsNamedType.declaration.ifJust((declaration) => {
+                declarations.push(declaration);
+            });
         }
-        const namedObjectTypesNameSorted = namedObjectTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        const namedObjectUnionTypesNameSorted = namedObjectUnionTypesToposorted.toSorted((left, right) => left.name.localeCompare(right.name));
-        switch (namedObjectTypesNameSorted.length) {
+        switch (tsNamedObjectTypes.length) {
             case 0:
                 break;
             case 1:
-                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${namedObjectTypesNameSorted[0].name};`);
+                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${tsNamedObjectTypes[0].expression};`);
                 break;
             default: {
                 const uberObjectUnionType = this.synthesizeUberObjectUnionType({
                     configuration,
-                    namedObjectTypes: namedObjectTypesToposorted.toReversed(), // Reverse topological order so children ane before parents
+                    namedObjectTypes: tsNamedObjectTypes,
                     reusables,
                 });
                 declarations = declarations.concat(uberObjectUnionType.declaration.toList());
-                namedObjectUnionTypesNameSorted.push(uberObjectUnionType);
+                tsNamedObjectUnionTypes.push(uberObjectUnionType);
             }
         }
         declarations.push(...this.objectSetTypeDeclarations({
             configuration,
-            namedObjectTypes: namedObjectTypesNameSorted,
-            namedObjectUnionTypes: namedObjectUnionTypesNameSorted,
+            namedObjectTypes: tsNamedObjectTypes,
+            namedObjectUnionTypes: tsNamedObjectUnionTypes,
             reusables,
         }));
         if (configuration.features.has("GraphQL")) {
-            const graphqlNamedObjectTypes = namedObjectTypesNameSorted.filter((namedObjectType) => !namedObjectType.synthetic);
-            const graphqlNamedObjectUnionTypes = namedObjectUnionTypesNameSorted.filter((namedObjectUnionType) => !namedObjectUnionType.synthetic);
+            const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.synthetic);
+            const graphqlNamedObjectUnionTypes = tsNamedObjectUnionTypes.filter((tsNamedObjectUnionType) => !tsNamedObjectUnionType.synthetic);
             if (graphqlNamedObjectTypes.length > 0) {
                 declarations.push(new GraphqlSchema({
                     configuration,
@@ -116,7 +141,7 @@ export class TsGenerator {
      * Synthesize the $Object union.
      */
     synthesizeUberObjectUnionType({ configuration, namedObjectTypes, reusables, }) {
-        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern);
+        const filteredNamedObjectTypes = namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic);
         invariant(filteredNamedObjectTypes.length > 0);
         const nodeKinds = filteredNamedObjectTypes.reduce((nodeKinds, namedObjectType) => {
             for (const nodeKind of namedObjectType.identifierType.nodeKinds) {
@@ -127,6 +152,7 @@ export class TsGenerator {
         let identifierType;
         if (nodeKinds.size === 2) {
             identifierType = new IdentifierType({
+                alias: Maybe.empty(),
                 comment: Maybe.empty(),
                 configuration,
                 label: Maybe.empty(),
@@ -138,6 +164,7 @@ export class TsGenerator {
             switch ([...nodeKinds][0]) {
                 case "BlankNode":
                     identifierType = new BlankNodeType({
+                        alias: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         label: Maybe.empty(),
@@ -147,6 +174,7 @@ export class TsGenerator {
                     break;
                 case "IRI":
                     identifierType = new IriType({
+                        alias: Maybe.empty(),
                         comment: Maybe.empty(),
                         configuration,
                         hasValues: [],
@@ -158,17 +186,17 @@ export class TsGenerator {
                     break;
             }
         }
-        return new NamedObjectUnionType({
+        return new ObjectUnionType({
+            alias: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
             comment: Maybe.empty(),
             configuration,
-            identifierType,
+            identifierType: Maybe.of(identifierType),
             label: Maybe.empty(),
             logger: this.logger,
             members: filteredNamedObjectTypes.map((namedObjectType) => ({
                 discriminantValue: Maybe.empty(),
                 type: namedObjectType,
             })),
-            name: `${configuration.syntheticNamePrefix}Object`,
             recursive: false,
             reusables,
             synthetic: true,