@shaclmate/compiler 4.0.94 → 4.0.96

package/dist/generators/ts/_AbstractType/AbstractType_JsonType.js

@@ -4,28 +4,422 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { code } from "../ts-poet-wrapper.js";
-export class AbstractType_JsonType {
-    /**
-     * Is the type optional in JSON? Equivalent to ? in TypeScript or | undefined.
-     */
-    optional;
-    /**
-     * The expression of the type when it's required i.e. -- so it should never include "| undefined".
-     */
-    requiredExpression;
-    constructor(requiredExpression, parameters) {
-        this.optional = !!parameters?.optional;
-        this.requiredExpression = requiredExpression;
+import { arrayOf, code, joinCode, literalOf, } from "../ts-poet-wrapper.js";
+class AbstractJsonType {
+    configuration;
+    reusables;
+    snippet;
+    name;
+    constructor({ configuration, name, snippet, reusables, }) {
+        this.configuration = configuration;
+        this.name = name;
+        this.reusables = reusables;
+        this.snippet = snippet;
+    }
+    moduleDeclarations({ unqualifiedName, }) {
+        const moduleDeclarations = [];
+        if (this.configuration.features.has("Object.JSON.parse")) {
+            moduleDeclarations.push(code `\
+export function parse(json: unknown): ${this.reusables.imports.Either}<Error, ${unqualifiedName}> {
+  const jsonSafeParseResult = schema().safeParse(json);
+  if (!jsonSafeParseResult.success) { return ${this.reusables.imports.Left}(jsonSafeParseResult.error); }
+  return ${this.reusables.imports.Right}(jsonSafeParseResult.data);
+}`);
+        }
+        if (this.configuration.features.has("Object.JSON.schema")) {
+            moduleDeclarations.push(code `export function schema() { return ${this.schemaExpression} satisfies ${this.reusables.imports.z}.ZodType<Json>; }`);
+        }
+        return moduleDeclarations;
+    }
+    get declaration() {
+        if (this.name.isNothing() || this.snippet.isJust()) {
+            return Maybe.empty();
+        }
+        const unqualifiedName = this.name.extract().at(-1);
+        const declarations = [];
+        if (this.configuration.features.has("Object.JSON.type")) {
+            declarations.push(code `export type ${unqualifiedName} = ${this.inlineExpression};`);
+        }
+        const moduleDeclarations = this.moduleDeclarations({ unqualifiedName });
+        if (moduleDeclarations.length > 0) {
+            declarations.push(code `export namespace Json { ${joinCode(moduleDeclarations, { on: "\n\n" })} }`);
+        }
+        if (declarations.length === 0) {
+            return Maybe.empty();
+        }
+        return Maybe.of(joinCode(declarations, { on: "\n\n" }));
     }
     get expression() {
-        return this.optional
-            ? code `(${this.requiredExpression}) | undefined`
-            : this.requiredExpression;
+        return this.snippet
+            .map((snippet) => code `${snippet}`)
+            .alt(this.name.map((name) => code `${name.join(".")}`))
+            .orDefaultLazy(() => this.inlineExpression);
+    }
+    get schema() {
+        return this.snippet
+            .map((snippet) => code `${snippet}.schema()`)
+            .alt(this.name.map((name) => code `${name.join(".")}.schema()`))
+            .orDefaultLazy(() => this.schemaExpression);
+    }
+    uiSchemaElement(_parameters) {
+        return Maybe.empty();
+    }
+}
+__decorate([
+    Memoize()
+], AbstractJsonType.prototype, "declaration", null);
+__decorate([
+    Memoize()
+], AbstractJsonType.prototype, "expression", null);
+__decorate([
+    Memoize()
+], AbstractJsonType.prototype, "schema", null);
+class AbstractJsonPrimitiveType extends AbstractJsonType {
+    inReference;
+    in_;
+    constructor({ in_, inReference, ...superParameters }) {
+        super(superParameters);
+        this.in_ = in_;
+        this.inReference = inReference;
+    }
+    get inlineExpression() {
+        if (this.in_.length > 0) {
+            return joinCode(this.in_.map((value) => code `${literalOf(value)}`), { on: " | " });
+        }
+        return code `${this.typeof}`;
+    }
+    get schemaExpression() {
+        switch (this.in_.length) {
+            case 0: {
+                return code `${this.reusables.imports.z}.${this.typeof}()`;
+            }
+            case 1:
+                return code `${this.reusables.imports.z}.literal(${literalOf(this.in_[0])})`;
+            default:
+                return code `${this.reusables.imports.z}.literal(${this.inReference.orDefault(code `${arrayOf(...this.in_)}`)})`;
+        }
+    }
+}
+__decorate([
+    Memoize()
+], AbstractJsonPrimitiveType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], AbstractJsonPrimitiveType.prototype, "schemaExpression", null);
+class JsonArrayType extends AbstractJsonType {
+    itemType;
+    kind = "JsonArray";
+    minCount;
+    constructor({ itemType, minCount, ...superParameters }) {
+        super(superParameters);
+        this.itemType = itemType;
+        this.minCount = minCount;
+    }
+    get inlineExpression() {
+        return code `(${this.itemType.expression})[]`;
+    }
+    get schemaExpression() {
+        let expression = code `${this.reusables.imports.z}.array(${this.itemType.schema})`;
+        if (this.minCount > 0n) {
+            expression = code `${expression}.min(${this.minCount})`;
+        }
+        return expression;
+    }
+}
+__decorate([
+    Memoize()
+], JsonArrayType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], JsonArrayType.prototype, "schemaExpression", null);
+class JsonBooleanType extends AbstractJsonPrimitiveType {
+    kind = "JsonBoolean";
+    typeof = "boolean";
+}
+class JsonDiscriminatedUnionType extends AbstractJsonType {
+    kind = "JsonDiscriminatedUnion";
+    members;
+    constructor({ members, ...superParameters }) {
+        super(superParameters);
+        this.members = members;
+    }
+    get inlineExpression() {
+        return code `(${joinCode(this.members.map((member) => code `(${member.type.expression} & { ${this.configuration.objectDiscriminantProperty.jsonName}: ${literalOf(member.discriminantValue)} })`), { on: " | " })})`;
+    }
+    get schemaExpression() {
+        return code `${this.reusables.imports.z}.discriminatedUnion(${literalOf(this.configuration.objectDiscriminantProperty.jsonName)}, [${joinCode(this.members.map((member) => {
+            const discriminantPropertyInitializer = code `${this.configuration.objectDiscriminantProperty.jsonName}: ${this.reusables.imports.z}.literal(${literalOf(member.discriminantValue)})`;
+            switch (member.type.kind) {
+                case "JsonIntersection": {
+                    // z.discriminatedUnion can't handle a z.intersection(member, z.object({ discriminant: z.literal("value") })),
+                    // it can only handle z.object's, so flatten the intersection into a z.object and then add the discriminant.
+                    return code `${this.reusables.imports.z}.object({ ${joinCode(member.type.memberTypes
+                        .map((member) => {
+                        invariant(member.kind === "JsonObject", member.kind);
+                        return code `...${member.schema}.shape`;
+                    })
+                        .concat(discriminantPropertyInitializer), { on: "," })} })`;
+                }
+                case "JsonObject":
+                    return code `${member.type.schema}.extend({ ${discriminantPropertyInitializer} })`;
+                default:
+                    member.type;
+                    throw new Error();
+            }
+        }), { on: ", " })}])`;
+    }
+}
+__decorate([
+    Memoize()
+], JsonDiscriminatedUnionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], JsonDiscriminatedUnionType.prototype, "schemaExpression", null);
+class JsonIntersectionType extends AbstractJsonType {
+    kind = "JsonIntersection";
+    memberTypes;
+    constructor({ memberTypes, ...superParameters }) {
+        super(superParameters);
+        this.memberTypes = memberTypes;
+    }
+    get inlineExpression() {
+        return code `(${joinCode(this.memberTypes.map((memberType) => memberType.expression), { on: " & " })})`;
+    }
+    get schemaExpression() {
+        // Use .and chains instead of .intersection. The latter only supports two operands.
+        return joinCode(this.memberTypes.map((memberType, memberI) => memberI === 0 ? memberType.schema : code `.and(${memberType.schema})`));
+    }
+}
+__decorate([
+    Memoize()
+], JsonIntersectionType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], JsonIntersectionType.prototype, "schemaExpression", null);
+class JsonNumberType extends AbstractJsonPrimitiveType {
+    kind = "JsonNumber";
+    typeof = "number";
+}
+class JsonObjectType extends AbstractJsonType {
+    kind = "JsonObject";
+    members;
+    memberTypes;
+    constructor({ members, ...superParameters }) {
+        super(superParameters);
+        this.members = members;
+        this.memberTypes = Array.from({ length: members.length }).map(() => null);
+    }
+    get inlineExpression() {
+        return code `{ ${joinCode(this.members.map((member, memberI) => {
+            return code `"${member.name}"${member.optional ? "?" : ""}: ${this.memberType(memberI).expression}`;
+        }), { on: ", " })} }`;
+    }
+    get schemaExpression() {
+        return code `${this.reusables.imports.z}.object({ ${joinCode(this.members.map((member, memberI) => {
+            const memberType = this.memberType(memberI);
+            let schema = memberType.schema;
+            if (member.recursive) {
+                schema = code `${this.reusables.imports.z}.lazy((): ${this.reusables.imports.z}.ZodType<${memberType.expression}> => ${schema})`;
+            }
+            if (member.optional) {
+                schema = code `${schema}.optional()`;
+            }
+            const meta = {
+            // id: `${this.namedObjectType.name}-${this.name}`, // id's must be unique
+            };
+            member.description.ifJust((description) => {
+                meta["description"] = description;
+            });
+            member.label.ifJust((label) => {
+                meta["title"] = label;
+            });
+            if (Object.keys(meta).length > 0) {
+                schema = code `${schema}.meta(${meta})`;
+            }
+            return code `${literalOf(member.name)}: ${schema}`;
+        }), { on: ", " })} })`;
+    }
+    get uiSchemaFunctionExpression() {
+        const variables = { scopePrefix: code `(_options?.scopePrefix ?? "#")` };
+        const uiSchema = {
+            elements: code `${arrayOf(...this.members.flatMap((member) => member.uiSchemaElement.map((f) => f({ variables })).toList()))}`,
+            type: "Group",
+        };
+        this.name.ifJust((name) => {
+            uiSchema["label"] = code `${literalOf(name[0])}`;
+        });
+        return code `\
+((_options?: { scopePrefix?: string }): any => {
+  return ${uiSchema};
+})`;
+    }
+    memberType(memberI) {
+        if (this.memberTypes[memberI] === null) {
+            this.memberTypes[memberI] =
+                typeof this.members[memberI].type === "function"
+                    ? this.members[memberI].type()
+                    : this.members[memberI].type;
+        }
+        return this.memberTypes[memberI];
+    }
+    moduleDeclarations(parameters) {
+        const moduleDeclarations = super.moduleDeclarations(parameters);
+        if (this.configuration.features.has("Object.JSON.uiSchema")) {
+            moduleDeclarations.push(code `export const uiSchema = ${this.uiSchemaFunctionExpression};`);
+        }
+        return moduleDeclarations;
+    }
+    uiSchemaElement({ variables, }) {
+        return Maybe.of(code `${this.name
+            .map((name) => code `${name.join(".")}.uiSchema`)
+            .orDefaultLazy(() => this.uiSchemaFunctionExpression)}({ scopePrefix: ${variables.scopePrefix} })`);
     }
 }
 __decorate([
     Memoize()
-], AbstractType_JsonType.prototype, "expression", null);
+], JsonObjectType.prototype, "inlineExpression", null);
+__decorate([
+    Memoize()
+], JsonObjectType.prototype, "schemaExpression", null);
+class JsonStringType extends AbstractJsonPrimitiveType {
+    format;
+    minLength;
+    typeof = "string";
+    kind = "JsonString";
+    constructor({ format, minLength, ...superParameters }) {
+        super(superParameters);
+        this.format = format;
+        this.minLength = minLength;
+    }
+    get schemaExpression() {
+        switch (this.in_.length) {
+            case 0: {
+                return this.format
+                    .map((format) => {
+                    invariant(this.minLength.isNothing());
+                    switch (format) {
+                        case "date":
+                            return code `${this.reusables.imports.z}.iso.date()`;
+                        case "datetime":
+                            return code `${this.reusables.imports.z}.iso.datetime()`;
+                        default:
+                            format;
+                            throw new RangeError(format);
+                    }
+                })
+                    .orDefaultLazy(() => {
+                    let schema = code `${this.reusables.imports.z}.string()`;
+                    this.minLength.ifJust((minLength) => {
+                        schema = code `${schema}.min(${minLength})`;
+                    });
+                    return schema;
+                });
+            }
+            case 1:
+                invariant(this.format.isNothing());
+                return code `${this.reusables.imports.z}.literal(${literalOf(this.in_[0])})`;
+            default:
+                invariant(this.format.isNothing());
+                return code `${this.reusables.imports.z}.enum(${this.inReference.orDefault(code `${arrayOf(...this.in_)}`)})`;
+        }
+    }
+}
+__decorate([
+    Memoize()
+], JsonStringType.prototype, "schemaExpression", null);
+class JsonTypeFactory {
+    constructorParameters;
+    constructor(constructorParameters) {
+        this.constructorParameters = constructorParameters;
+    }
+    createJsonArrayType(itemType, options) {
+        return new JsonArrayType({
+            ...this.constructorParameters,
+            itemType,
+            minCount: options?.minCount ?? 0n,
+            name: Maybe.fromNullable(options?.name),
+            snippet: Maybe.fromNullable(options?.snippet),
+        });
+    }
+    createJsonBooleanType(options) {
+        return new JsonBooleanType({
+            ...this.constructorParameters,
+            in_: options?.in_ ?? [],
+            inReference: Maybe.fromNullable(options?.inReference),
+            name: Maybe.fromNullable(options?.name),
+            snippet: Maybe.fromNullable(options?.snippet),
+        });
+    }
+    createJsonDiscriminatedUnionType(members, options) {
+        return new JsonDiscriminatedUnionType({
+            ...this.constructorParameters,
+            members,
+            name: Maybe.fromNullable(options?.name),
+            recursive: !!options?.recursive,
+            snippet: Maybe.fromNullable(options?.snippet),
+        });
+    }
+    createJsonIntersectionType(memberTypes, options) {
+        return new JsonIntersectionType({
+            ...this.constructorParameters,
+            memberTypes,
+            name: Maybe.fromNullable(options?.name),
+            recursive: !!options?.recursive,
+            snippet: Maybe.fromNullable(options?.snippet),
+        });
+    }
+    createJsonNumberType(options) {
+        return new JsonNumberType({
+            ...this.constructorParameters,
+            in_: options?.in_ ?? [],
+            inReference: Maybe.fromNullable(options?.inReference),
+            name: Maybe.fromNullable(options?.name),
+            snippet: Maybe.fromNullable(options?.snippet),
+        });
+    }
+    createJsonObjectType(partialMembers, options) {
+        let partialMembersArray;
+        if (Array.isArray(partialMembers)) {
+            partialMembersArray = partialMembers;
+        }
+        else {
+            partialMembersArray = Object.entries(partialMembers).map(([name, partialMember]) => ({ ...partialMember, name }));
+        }
+        return new JsonObjectType({
+            ...this.constructorParameters,
+            members: partialMembersArray.map((member) => ({
+                description: Maybe.isMaybe(member.description)
+                    ? member.description
+                    : Maybe.fromNullable(member.description),
+                label: Maybe.isMaybe(member.label)
+                    ? member.label
+                    : Maybe.fromNullable(member.label),
+                optional: !!member.optional,
+                recursive: !!member.recursive,
+                name: member.name,
+                type: member.type,
+                uiSchemaElement: Maybe.isMaybe(member.uiSchemaElement)
+                    ? member.uiSchemaElement
+                    : Maybe.fromNullable(member.uiSchemaElement),
+            })),
+            name: Maybe.fromNullable(options?.name),
+            snippet: Maybe.fromNullable(options?.snippet),
+        });
+    }
+    createJsonStringType(options) {
+        return new JsonStringType({
+            ...this.constructorParameters,
+            format: Maybe.fromNullable(options?.format),
+            in_: options?.in_ ?? [],
+            inReference: Maybe.fromNullable(options?.inReference),
+            minLength: Maybe.fromNullable(options?.minLength),
+            name: Maybe.fromNullable(options?.name),
+            snippet: Maybe.fromNullable(options?.snippet),
+        });
+    }
+}
+export const AbstractType_JsonTypeFactory = JsonTypeFactory;
 //# sourceMappingURL=AbstractType_JsonType.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.d.ts → ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction.d.ts}

@@ -1,4 +1,4 @@
+import type { Callable } from "../Callable.js";
 import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
-//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunctionDeclaration.d.ts.map
+export declare function ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction(this: ObjectDiscriminatedUnionType): Callable;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction.js

@@ -0,0 +1,12 @@
+import { pascalCase } from "change-case";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FocusSparqlConstructTriplesFunction}<${this.filterType}>`,
+        unannotatedExpression: code `\
+({ filter, focusIdentifier, variablePrefix }) =>
+  [${joinCode(this.members.map((member) => code `...${member.type.name.unsafeCoerce()}.focusSparqlConstructTriples({ filter: filter?.on?.${member.primaryDiscriminantValue}, focusIdentifier, ignoreRdfType: false, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`), { on: ", " })}]`,
+        unqualifiedName: "focusSparqlConstructTriples",
+    });
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlConstructTriplesFunction.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.d.ts → ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.d.ts}

@@ -1,4 +1,4 @@
+import type { Callable } from "../Callable.js";
 import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
-//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunctionDeclaration.d.ts.map
+export declare function ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction(this: ObjectDiscriminatedUnionType): Callable;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.js

@@ -0,0 +1,32 @@
+import { pascalCase } from "change-case";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FocusSparqlWherePatternsFunction}<${this.filterType}>`,
+        unannotatedExpression: code `\
+({ filter, focusIdentifier, preferredLanguages, variablePrefix }) => {
+${joinCode([
+            code `let patterns: ${this.reusables.snippets.SparqlPattern}[] = [];`,
+            code `\
+if (focusIdentifier.termType === "Variable") {
+  patterns = patterns.concat(${this.identifierType.valueSparqlWherePatternsFunction.unannotatedUsage}({
+      filter: filter?.${this.configuration.syntheticNamePrefix}identifier,
+      ignoreRdfType: false,
+      preferredLanguages,
+      propertyPatterns: [],
+      schema: ${this.identifierType.schema},
+      valueVariable: focusIdentifier,
+      variablePrefix,
+  }));
+}`,
+            code `patterns.push({ patterns: [${joinCode(this.members.map((member) => code `${{
+                patterns: code `${member.type.name.unsafeCoerce()}.focusSparqlWherePatterns({ filter: filter?.on?.${member.primaryDiscriminantValue}, focusIdentifier, ignoreRdfType: false, preferredLanguages, variablePrefix: \`\${variablePrefix}${pascalCase(member.type.name.unsafeCoerce())}\` }).concat()`,
+                type: literalOf("group"),
+            }}`), { on: ", " })}], type: "union" });`,
+            code `return patterns;`,
+        ])}
+}`,
+        unqualifiedName: "focusSparqlWherePatterns",
+    });
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_focusSparqlWherePatternsFunction.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.d.ts → ObjectDiscriminatedUnionType_fromRdfResourceFunction.d.ts}

@@ -1,4 +1,4 @@
+import type { Callable } from "../Callable.js";
 import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
-//# sourceMappingURL=ObjectDiscriminatedUnionType_fromRdfResourceFunctionDeclaration.d.ts.map
+export declare function ObjectDiscriminatedUnionType_fromRdfResourceFunction(this: ObjectDiscriminatedUnionType): Callable;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_fromRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_fromRdfResourceFunction.js

@@ -0,0 +1,16 @@
+import { code } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_fromRdfResourceFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets.FromRdfResourceFunction}<${this.expression}>`,
+        unannotatedExpression: code `\
+(resource, options) => 
+  ${this.members.reduce((expression, member) => {
+            const memberTypeExpression = code `(${member.type.name.unsafeCoerce()}.fromRdfResource(resource, { ...options, ignoreRdfType: false }) as ${this.reusables.imports.Either}<Error, ${this.expression}>)`;
+            return expression !== null
+                ? code `${expression}.altLazy(() => ${memberTypeExpression})`
+                : memberTypeExpression;
+        }, null)};`,
+        unqualifiedName: "fromRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_fromRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.d.ts → ObjectDiscriminatedUnionType_graphqlTypeExpression.d.ts}

@@ -1,4 +1,4 @@
 import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
 import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectDiscriminatedUnionType_graphqlTypeVariableStatement(this: ObjectDiscriminatedUnionType): Record<string, Code>;
-//# sourceMappingURL=ObjectDiscriminatedUnionType_graphqlTypeVariableStatement.d.ts.map
+export declare function ObjectDiscriminatedUnionType_graphqlTypeExpression(this: ObjectDiscriminatedUnionType): Code;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_graphqlTypeExpression.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_graphqlTypeExpression.js

@@ -0,0 +1,11 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_graphqlTypeExpression() {
+    const name = this.name.unsafeCoerce();
+    return code `new ${this.reusables.imports.GraphQLUnionType}(${{
+        description: this.comment.map(JSON.stringify).extract(),
+        name: name,
+        resolveType: code `(value: ${name}) => value.${this.configuration.syntheticNamePrefix}type`,
+        types: code `[${joinCode(this.members.map((member) => member.type.graphqlType.nullableExpression), { on: ", " })}]`,
+    }});`;
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_graphqlTypeExpression.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_schemaExpression.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
+import { type Code } from "../ts-poet-wrapper.js";
+export declare function ObjectDiscriminatedUnionType_schemaExpression(this: ObjectDiscriminatedUnionType): Code;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_schemaExpression.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_schemaVariableStatement.js → ObjectDiscriminatedUnionType_schemaExpression.js}

@@ -1,10 +1,6 @@
 import { PropertyPath } from "@rdfx/resource";
-import { singleEntryRecord } from "../singleEntryRecord.js";
 import { code, joinCode } from "../ts-poet-wrapper.js";
-export function ObjectDiscriminatedUnionType_schemaVariableStatement() {
-    if (!this.configuration.features.has("Object.schema")) {
-        return {};
-    }
+export function ObjectDiscriminatedUnionType_schemaExpression() {
     const commonPropertiesByName = {};
     this.members.forEach((member, memberI) => {
         for (const memberTypeProperty of member.type.properties) {
@@ -36,7 +32,6 @@ export function ObjectDiscriminatedUnionType_schemaVariableStatement() {
             propertiesObject.push(code `${property.name}: ${propertySchema}`);
         });
     }
-    return singleEntryRecord(`schema`, code `\
-export const schema = { ${joinCode(this.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`);
+    return code `{ ${joinCode(this.schemaInitializers.concat(code `properties: { ${joinCode(propertiesObject, { on: ", " })} }`), { on: ", " })} } as const;`;
 }
-//# sourceMappingURL=ObjectDiscriminatedUnionType_schemaVariableStatement.js.map
+//# sourceMappingURL=ObjectDiscriminatedUnionType_schemaExpression.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.d.ts → ObjectDiscriminatedUnionType_toRdfResourceFunction.d.ts}

@@ -1,4 +1,4 @@
+import type { Callable } from "../Callable.js";
 import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
-//# sourceMappingURL=ObjectDiscriminatedUnionType_toRdfResourceFunctionDeclaration.d.ts.map
+export declare function ObjectDiscriminatedUnionType_toRdfResourceFunction(this: ObjectDiscriminatedUnionType): Callable;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_toRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_toRdfResourceFunction.js

@@ -0,0 +1,17 @@
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_toRdfResourceFunction() {
+    const identifierTypeExpression = this.name
+        .map(() => this.identifierTypeAlias)
+        .orDefault(this.identifierType.expression);
+    return this._function({
+        type: code `${this.reusables.snippets.ToRdfResourceFunction}<${identifierTypeExpression}, ${this.expression}>`,
+        unannotatedExpression: code `\
+(object, options) => {
+${joinCode(this.members
+            .map((member) => code `if (${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)) { return ${member.type.name.unsafeCoerce()}.toRdfResource(object, options); }`)
+            .concat(code `throw new Error("unrecognized type");`))}
+};`,
+        unqualifiedName: "toRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_toRdfResourceFunction.js.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/{ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.d.ts → ObjectDiscriminatedUnionType_typeGuardFunction.d.ts}

@@ -1,4 +1,5 @@
+import { Maybe } from "purify-ts";
+import type { Callable } from "../Callable.js";
 import type { ObjectDiscriminatedUnionType } from "../ObjectDiscriminatedUnionType.js";
-import { type Code } from "../ts-poet-wrapper.js";
-export declare function ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration(this: ObjectDiscriminatedUnionType): Record<string, Code>;
-//# sourceMappingURL=ObjectDiscriminatedUnionType_typeGuardFunctionDeclaration.d.ts.map
+export declare function ObjectDiscriminatedUnionType_typeGuardFunction(this: ObjectDiscriminatedUnionType): Maybe<Callable>;
+//# sourceMappingURL=ObjectDiscriminatedUnionType_typeGuardFunction.d.ts.map

package/dist/generators/ts/_ObjectDiscriminatedUnionType/ObjectDiscriminatedUnionType_typeGuardFunction.js

@@ -0,0 +1,14 @@
+import { Maybe } from "purify-ts";
+import { code, joinCode } from "../ts-poet-wrapper.js";
+export function ObjectDiscriminatedUnionType_typeGuardFunction() {
+    const name = this.name.extract();
+    if (!name) {
+        return Maybe.empty();
+    }
+    return Maybe.of(this._function({
+        type: code `${this.reusables.snippets.ObjectTypeGuardFunction}<${this.expression}>`,
+        unannotatedExpression: code `(object): object is ${this.expression} => ${joinCode(this.members.map((member) => code `${member.type.name.unsafeCoerce()}.is${member.type.name.unsafeCoerce()}(object)`), { on: " || " })};`,
+        unqualifiedName: `is${name}`,
+    }));
+}
+//# sourceMappingURL=ObjectDiscriminatedUnionType_typeGuardFunction.js.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType__fromRdfResourceFunction.d.ts

@@ -0,0 +1,4 @@
+import type { Callable } from "../Callable.js";
+import type { ObjectIntersectionType } from "../ObjectIntersectionType.js";
+export declare function ObjectIntersectionType__fromRdfResourceFunction(this: ObjectIntersectionType): Callable;
+//# sourceMappingURL=ObjectIntersectionType__fromRdfResourceFunction.d.ts.map

package/dist/generators/ts/_ObjectIntersectionType/ObjectIntersectionType__fromRdfResourceFunction.js

@@ -0,0 +1,16 @@
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
+function ObjectIntersectionType__fromRdfResourceFunctionExpression() {
+    return code `(resource, options) => ${joinCode(this.members.map((member, memberI) => code `(${member.type.fromRdfResourceFunction.unannotatedUsage})(resource, options).${memberI + 1 < this.members.length ? "chain" : "map"}(member${memberI} =>`))} ({ ${joinCode(this.members
+        .map((_, memberI) => code `...member${memberI}`)
+        .concat(this.discriminatedType
+        .map(({ discriminantProperty }) => code `${discriminantProperty.name}: ${literalOf(discriminantProperty.values[0])} as const`)
+        .toList()), { on: "," })} }) ${")".repeat(this.members.length)}`;
+}
+export function ObjectIntersectionType__fromRdfResourceFunction() {
+    return this._function({
+        type: code `${this.reusables.snippets._FromRdfResourceFunction}<${this.discriminatedType.map((discriminatedType) => discriminatedType.expression).orDefault(this.expression)}>`,
+        unannotatedExpression: () => ObjectIntersectionType__fromRdfResourceFunctionExpression.call(this),
+        unqualifiedName: "_fromRdfResource",
+    });
+}
+//# sourceMappingURL=ObjectIntersectionType__fromRdfResourceFunction.js.map