@shaclmate/compiler 2.0.22 → 2.0.24

package/dist/generators/ts/_ObjectType/fromJsonFunctionDeclarations.js

@@ -1,78 +0,0 @@
-import { StructureKind } from "ts-morph";
-const variables = {
-    jsonObject: "_jsonObject",
-};
-export function fromJsonFunctionDeclarations() {
-    if (!this.features.has("fromJson")) {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    const initializers = [];
-    const propertyReturnTypeSignatures = [];
-    const propertiesFromJsonFunctionReturnType = [];
-    const propertiesFromJsonFunctionStatements = [];
-    propertiesFromJsonFunctionStatements.push(`const _jsonSafeParseResult = ${this.jsonZodSchemaFunctionName}().safeParse(_json);`, "if (!_jsonSafeParseResult.success) { return purify.Left(_jsonSafeParseResult.error); }", `const ${variables.jsonObject} = _jsonSafeParseResult.data;`);
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromJsonFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}._propertiesFromJson(${variables.jsonObject});`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
-        initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromJsonFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}._propertiesFromJson>>`);
-    });
-    for (const property of this.properties) {
-        const propertyFromJsonStatements = property.fromJsonStatements({
-            variables,
-        });
-        if (propertyFromJsonStatements.length > 0) {
-            propertiesFromJsonFunctionStatements.push(...propertyFromJsonStatements);
-            initializers.push(property.name);
-            propertyReturnTypeSignatures.push(`${property.name}: ${property.type.name};`);
-        }
-    }
-    propertiesFromJsonFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
-    if (propertyReturnTypeSignatures.length > 0) {
-        propertiesFromJsonFunctionReturnType.splice(0, 0, `{ ${propertyReturnTypeSignatures.join(" ")} }`);
-    }
-    const fromJsonFunctionDeclarations = [];
-    fromJsonFunctionDeclarations.push({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: "_propertiesFromJson",
-        parameters: [
-            {
-                name: "_json",
-                type: "unknown",
-            },
-        ],
-        returnType: `purify.Either<zod.ZodError, ${propertiesFromJsonFunctionReturnType.join(" & ")}>`,
-        statements: propertiesFromJsonFunctionStatements,
-    });
-    if (!this.abstract) {
-        let fromJsonStatements;
-        switch (this.declarationType) {
-            case "class":
-                fromJsonStatements = [
-                    `return ${this.name}._propertiesFromJson(json).map(properties => new ${this.name}(properties));`,
-                ];
-                break;
-            case "interface":
-                fromJsonStatements = [`return ${this.name}._propertiesFromJson(json);`];
-                break;
-        }
-        fromJsonFunctionDeclarations.push({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "fromJson",
-            parameters: [
-                {
-                    name: "json",
-                    type: "unknown",
-                },
-            ],
-            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
-            statements: fromJsonStatements,
-        });
-    }
-    return fromJsonFunctionDeclarations;
-}
-//# sourceMappingURL=fromJsonFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/fromRdfFunctionDeclarations.d.ts

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function fromRdfFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=fromRdfFunctionDeclarations.d.ts.map

package/dist/generators/ts/_ObjectType/fromRdfFunctionDeclarations.js

@@ -1,91 +0,0 @@
-import { StructureKind } from "ts-morph";
-import { objectInitializer } from "../objectInitializer.js";
-const variables = {
-    context: "_context",
-    ignoreRdfType: "_ignoreRdfType",
-    languageIn: "_languageIn",
-    resource: "_resource",
-};
-export function fromRdfFunctionDeclarations() {
-    if (!this.features.has("fromRdf")) {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    const initializers = [];
-    const propertySignatures = [];
-    const propertiesFromRdfFunctionReturnType = [];
-    const propertiesFromRdfFunctionStatements = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromRdfFunctionStatements.push(`const _super${parentObjectTypeI}Either = ${parentObjectType.name}._propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, languageIn: ${variables.languageIn}, resource: ${variables.resource} });`, `if (_super${parentObjectTypeI}Either.isLeft()) { return _super${parentObjectTypeI}Either; }`, `const _super${parentObjectTypeI} = _super${parentObjectTypeI}Either.unsafeCoerce()`);
-        initializers.push(`..._super${parentObjectTypeI}`);
-        propertiesFromRdfFunctionReturnType.push(`UnwrapR<ReturnType<typeof ${parentObjectType.name}._propertiesFromRdf>>`);
-    });
-    this.fromRdfType.ifJust((rdfType) => {
-        propertiesFromRdfFunctionStatements.push(`if (!${variables.ignoreRdfType} && !${variables.resource}.isInstanceOf(${this.rdfjsTermExpression(rdfType)})) { return purify.Left(new rdfjsResource.Resource.ValueError(${objectInitializer({ focusResource: variables.resource, message: `\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type\``, predicate: this.rdfjsTermExpression(rdfType) })})); }`);
-    });
-    const propertyFromRdfVariables = {
-        context: variables.context,
-        languageIn: variables.languageIn,
-        resource: variables.resource,
-    };
-    for (const property of this.properties) {
-        const propertyFromRdfStatements = property.fromRdfStatements({
-            variables: propertyFromRdfVariables,
-        });
-        if (propertyFromRdfStatements.length > 0) {
-            propertiesFromRdfFunctionStatements.push(...propertyFromRdfStatements);
-            initializers.push(property.name);
-            propertySignatures.push(`${property.name}: ${property.type.name};`);
-        }
-    }
-    propertiesFromRdfFunctionStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
-    if (propertySignatures.length > 0) {
-        propertiesFromRdfFunctionReturnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
-    }
-    const fromRdfFunctionDeclarations = [];
-    fromRdfFunctionDeclarations.push({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: "_propertiesFromRdf",
-        parameters: [
-            {
-                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, languageIn: ${variables.languageIn}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
-                type: `{ [_index: string]: any; ignoreRdfType?: boolean; languageIn?: readonly string[]; resource: ${this.rdfjsResourceType().name}; }`,
-            },
-        ],
-        returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${propertiesFromRdfFunctionReturnType.join(" & ")}>`,
-        statements: propertiesFromRdfFunctionStatements,
-    });
-    if (!this.abstract) {
-        let fromRdfStatements;
-        switch (this.declarationType) {
-            case "class":
-                fromRdfStatements = [
-                    `return ${this.name}._propertiesFromRdf(parameters).map(properties => new ${this.name}(properties));`,
-                ];
-                break;
-            case "interface":
-                fromRdfStatements = [
-                    `return ${this.name}._propertiesFromRdf(parameters);`,
-                ];
-                break;
-        }
-        fromRdfFunctionDeclarations.push({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: "fromRdf",
-            parameters: [
-                {
-                    name: "parameters",
-                    type: `Parameters<typeof ${this.name}._propertiesFromRdf>[0]`,
-                },
-            ],
-            returnType: `purify.Either<rdfjsResource.Resource.ValueError, ${this.name}>`,
-            statements: fromRdfStatements,
-        });
-    }
-    return fromRdfFunctionDeclarations;
-}
-//# sourceMappingURL=fromRdfFunctionDeclarations.js.map

package/dist/generators/ts/_ObjectType/jsonSchemaFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonSchemaFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=jsonSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/jsonSchemaFunctionDeclaration.js

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function jsonSchemaFunctionDeclaration() {
-    if (!this.features.has("jsonSchema")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: "jsonSchema",
-        statements: [
-            `return zodToJsonSchema(${this.jsonZodSchemaFunctionName}());`,
-        ],
-    });
-}
-//# sourceMappingURL=jsonSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/jsonUiSchemaFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonUiSchemaFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=jsonUiSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/jsonUiSchemaFunctionDeclaration.js

@@ -1,31 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function jsonUiSchemaFunctionDeclaration() {
-    if (!this.features.has("jsonUiSchema")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    const variables = { scopePrefix: "scopePrefix" };
-    const elements = this.parentObjectTypes
-        .map((parentObjectType) => `${parentObjectType.name}.${parentObjectType.jsonUiSchemaFunctionName}({ scopePrefix })`)
-        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: this.jsonUiSchemaFunctionName,
-        parameters: [
-            {
-                hasQuestionToken: true,
-                name: "parameters",
-                type: "{ scopePrefix?: string }",
-            },
-        ],
-        statements: [
-            'const scopePrefix = parameters?.scopePrefix ?? "#";',
-            `return { "elements": [ ${elements.join(", ")} ], label: "${this.label.orDefault(this.name)}", type: "Group" }`,
-        ],
-    });
-}
-//# sourceMappingURL=jsonUiSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonZodSchemaFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=jsonZodSchemaFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/jsonZodSchemaFunctionDeclaration.js

@@ -1,37 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-export function jsonZodSchemaFunctionDeclaration() {
-    if (!this.features.has("fromJson") && !this.features.has("jsonSchema")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    const variables = { zod: "zod" };
-    const mergeZodObjectSchemas = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(`${parentObjectType.jsonZodSchema({ variables })}`);
-    }
-    if (this.properties.length > 0) {
-        mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
-            .flatMap((property) => property.jsonZodSchema({ variables }).toList())
-            .map(({ key, schema }) => `"${key}": ${schema}`)
-            .join(",")} })`);
-    }
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: this.jsonZodSchemaFunctionName,
-        statements: [
-            `return ${mergeZodObjectSchemas.length > 0
-                ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
-                    if (merged.length === 0) {
-                        return zodObjectSchema;
-                    }
-                    return `${merged}.merge(${zodObjectSchema})`;
-                }, "")
-                : `${variables.zod}.object()`};`,
-        ],
-    });
-}
-//# sourceMappingURL=jsonZodSchemaFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/rdfjsTermExpression.d.ts

@@ -1,6 +0,0 @@
-import type { BlankNode, Literal, NamedNode, Variable } from "@rdfjs/types";
-export declare function rdfjsTermExpression({ dataFactoryVariable, rdfjsTerm, }: {
-    dataFactoryVariable: string;
-    rdfjsTerm: Omit<BlankNode, "equals"> | Omit<Literal, "equals"> | Omit<NamedNode, "equals"> | Omit<Variable, "equals">;
-}): string;
-//# sourceMappingURL=rdfjsTermExpression.d.ts.map

package/dist/generators/ts/_ObjectType/rdfjsTermExpression.js

@@ -1,17 +0,0 @@
-import { xsd } from "@tpluscode/rdf-ns-builders";
-export function rdfjsTermExpression({ dataFactoryVariable, rdfjsTerm, }) {
-    switch (rdfjsTerm.termType) {
-        case "BlankNode":
-            return `${dataFactoryVariable}.blankNode("${rdfjsTerm.value}")`;
-        case "Literal":
-            if (rdfjsTerm.datatype.equals(xsd.string)) {
-                return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", "${rdfjsTerm.language}")`;
-            }
-            return `${dataFactoryVariable}.literal("${rdfjsTerm.value}", ${dataFactoryVariable}.namedNode("${rdfjsTerm.datatype.value}"))`;
-        case "NamedNode":
-            return `${dataFactoryVariable}.namedNode("${rdfjsTerm.value}")`;
-        case "Variable":
-            return `${dataFactoryVariable}.variable!("${rdfjsTerm.value}")`;
-    }
-}
-//# sourceMappingURL=rdfjsTermExpression.js.map

package/dist/generators/ts/_ObjectType/toJsonFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function toJsonFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=toJsonFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/toJsonFunctionDeclaration.js

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
-export function toJsonFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    return toJsonFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toJsonFunctionOrMethodDeclaration) => ({
-        ...toJsonFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-    }));
-}
-//# sourceMappingURL=toJsonFunctionDeclaration.js.map

package/dist/generators/ts/_ObjectType/toJsonReturnType.d.ts

@@ -1,3 +0,0 @@
-import type { ObjectType } from "../ObjectType.js";
-export declare function toJsonReturnType(this: ObjectType): string;
-//# sourceMappingURL=toJsonReturnType.d.ts.map

package/dist/generators/ts/_ObjectType/toJsonReturnType.js

@@ -1,17 +0,0 @@
-export function toJsonReturnType() {
-    const typeMembers = [];
-    if (this.ownProperties.length > 0) {
-        typeMembers.push(`{ ${this.ownProperties
-            .flatMap((property) => property.jsonPropertySignature.toList())
-            .map((propertySignature) => `readonly "${propertySignature.name}": ${propertySignature.type}`)
-            .join("; ")} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        typeMembers.push(parentObjectType.jsonName);
-    }
-    if (typeMembers.length === 0) {
-        return "object";
-    }
-    return typeMembers.join(" & ");
-}
-//# sourceMappingURL=toJsonReturnType.js.map

package/dist/generators/ts/_ObjectType/toRdfFunctionDeclaration.d.ts

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function toRdfFunctionDeclaration(this: ObjectType): Maybe<FunctionDeclarationStructure>;
-//# sourceMappingURL=toRdfFunctionDeclaration.d.ts.map

package/dist/generators/ts/_ObjectType/toRdfFunctionDeclaration.js

@@ -1,19 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
-export function toRdfFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    return toRdfFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toRdfFunctionOrMethodDeclaration) => ({
-        ...toRdfFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-    }));
-}
-//# sourceMappingURL=toRdfFunctionDeclaration.js.map