@shaclmate/compiler 4.0.49 → 4.0.50

package/dist/generators/ts/TsGenerator.js

@@ -1,292 +0,0 @@
-import dataFactory from "@rdfx/data-factory";
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { BlankNodeType } from "./BlankNodeType.js";
-import { GraphqlSchema } from "./GraphqlSchema.js";
-import { IdentifierType } from "./IdentifierType.js";
-import { IriType } from "./IriType.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.name.unsafeCoerce().localeCompare(right.name.unsafeCoerce());
-}
-export class TsGenerator {
-    configuration;
-    logger;
-    constructor({ configuration, logger, }) {
-        this.configuration = configuration;
-        this.logger = logger;
-    }
-    generate(ast_) {
-        const configuration = TsGenerator.Configuration.finalize(ast_, this.configuration);
-        const reusables = new Reusables({
-            configuration,
-            logger: this.logger,
-        });
-        const typeFactory = new TypeFactory({
-            configuration,
-            logger: this.logger,
-            reusables,
-        });
-        let declarations = [];
-        const tsNamedTypes = [];
-        const tsNamedObjectTypes = [];
-        const tsNamedObjectUnionTypes = [];
-        for (const astNamedType of ast_.namedTypes) {
-            const tsNamedType = typeFactory.createType(astNamedType);
-            tsNamedTypes.push(tsNamedType);
-            if (astNamedType.kind === "Struct") {
-                for (const tsImport of astNamedType.tsImports) {
-                    declarations.push(code `${tsImport}`);
-                }
-            }
-            switch (tsNamedType.kind) {
-                case "Object":
-                    tsNamedObjectTypes.push(tsNamedType);
-                    break;
-                case "ObjectUnion":
-                    tsNamedObjectUnionTypes.push(tsNamedType);
-                    break;
-            }
-        }
-        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);
-            });
-        }
-        // 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);
-            });
-        }
-        switch (tsNamedObjectTypes.length) {
-            case 0:
-                break;
-            case 1:
-                declarations.push(code `type ${configuration.syntheticNamePrefix}Object = ${tsNamedObjectTypes[0].expression};`);
-                break;
-            default: {
-                const uberObjectUnionType = this.synthesizeUberObjectUnionType({
-                    configuration,
-                    namedObjectTypes: tsNamedObjectTypes,
-                    reusables,
-                });
-                declarations = declarations.concat(uberObjectUnionType.declaration.toList());
-                tsNamedObjectUnionTypes.push(uberObjectUnionType);
-            }
-        }
-        declarations.push(...this.objectSetTypeDeclarations({
-            configuration,
-            namedObjectTypes: tsNamedObjectTypes,
-            namedObjectUnionTypes: tsNamedObjectUnionTypes,
-            reusables,
-        }));
-        if (configuration.features.has("GraphQL")) {
-            const graphqlNamedObjectTypes = tsNamedObjectTypes.filter((tsNamedObjectType) => !tsNamedObjectType.synthetic);
-            const graphqlNamedObjectUnionTypes = tsNamedObjectUnionTypes.filter((tsNamedObjectUnionType) => !tsNamedObjectUnionType.synthetic);
-            if (graphqlNamedObjectTypes.length > 0) {
-                declarations.push(new GraphqlSchema({
-                    configuration,
-                    logger: this.logger,
-                    namedObjectTypes: graphqlNamedObjectTypes,
-                    namedObjectUnionTypes: graphqlNamedObjectUnionTypes,
-                    reusables,
-                }).declaration);
-            }
-        }
-        declarations.splice(0, 0, joinCode(reusables.snippets.ifUsed, { on: "\n\n" }));
-        return joinCode(declarations).toString({});
-    }
-    objectSetTypeDeclarations({ configuration, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
-        const constructorParameters = {
-            configuration,
-            logger: this.logger,
-            namedObjectTypes: namedObjectTypes.filter((namedObjectType) => !namedObjectType.extern && !namedObjectType.synthetic),
-            namedObjectUnionTypes,
-            reusables,
-        };
-        const declarations = [];
-        if (configuration.features.has("ObjectSet")) {
-            declarations.push(new ObjectSetType(constructorParameters).declaration);
-        }
-        if (configuration.features.has("RdfjsDatasetObjectSet")) {
-            declarations.push(new RdfjsDatasetObjectSetType(constructorParameters).declaration);
-        }
-        if (configuration.features.has("SparqlObjectSet")) {
-            declarations.push(new SparqlObjectSetType(constructorParameters).declaration);
-        }
-        return declarations;
-    }
-    /**
-     * Synthesize the $Object union.
-     */
-    synthesizeUberObjectUnionType({ configuration, namedObjectTypes, reusables, }) {
-        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) {
-                nodeKinds.add(nodeKind);
-            }
-            return nodeKinds;
-        }, new Set());
-        let identifierType;
-        if (nodeKinds.size === 2) {
-            identifierType = new IdentifierType({
-                name: Maybe.empty(),
-                comment: Maybe.empty(),
-                configuration,
-                label: Maybe.empty(),
-                logger: this.logger,
-                reusables,
-                shapeIdentifier: dataFactory.blankNode(),
-            });
-        }
-        else {
-            switch ([...nodeKinds][0]) {
-                case "BlankNode":
-                    identifierType = new BlankNodeType({
-                        name: Maybe.empty(),
-                        comment: Maybe.empty(),
-                        configuration,
-                        label: Maybe.empty(),
-                        logger: this.logger,
-                        reusables,
-                        shapeIdentifier: dataFactory.blankNode(),
-                    });
-                    break;
-                case "IRI":
-                    identifierType = new IriType({
-                        name: Maybe.empty(),
-                        comment: Maybe.empty(),
-                        configuration,
-                        hasValues: [],
-                        in_: [],
-                        label: Maybe.empty(),
-                        logger: this.logger,
-                        reusables,
-                        shapeIdentifier: dataFactory.blankNode(),
-                    });
-                    break;
-            }
-        }
-        return new ObjectUnionType({
-            name: Maybe.of(`${configuration.syntheticNamePrefix}Object`),
-            comment: Maybe.empty(),
-            configuration,
-            identifierType: Maybe.of(identifierType),
-            label: Maybe.empty(),
-            logger: this.logger,
-            members: filteredNamedObjectTypes.map((namedObjectType) => ({
-                discriminantValue: Maybe.empty(),
-                type: namedObjectType,
-            })),
-            recursive: false,
-            reusables,
-            shapeIdentifier: dataFactory.blankNode(),
-            synthetic: true,
-        });
-    }
-}
-(function (TsGenerator) {
-    let Configuration;
-    (function (Configuration) {
-        Configuration.default_ = {
-            features: new Set([
-                "Object.create",
-                "Object.equals",
-                "Object.hash",
-                "JSON",
-                "RDF",
-            ]),
-            syntheticNamePrefix: "$",
-        };
-        const featureDependenciesStatic = {
-            GraphQL: ["ObjectSet"],
-            // Alias for other features, not dependencies per se
-            JSON: ["Object.JSON"],
-            "Object.create": ["Object.schema", "Object.toString", "Object.type"],
-            "Object.equals": ["Object.type"],
-            "Object.filter": ["Object.type"],
-            "Object.fromJson": ["Object.create", "Object.JSON.type", "Object.type"],
-            "Object.fromRdf": ["Object.create", "Object.schema"],
-            "Object.hash": [],
-            // Alias for other features, not dependencies per se
-            "Object.JSON": [
-                "Object.fromJson",
-                "Object.JSON.parse",
-                "Object.JSON.schema",
-                "Object.JSON.type",
-                "Object.JSON.uiSchema",
-                "Object.toJson",
-            ],
-            "Object.JSON.parse": ["Object.JSON.schema", "Object.JSON.type"],
-            "Object.JSON.type": [],
-            "Object.JSON.schema": ["Object.JSON.type"],
-            "Object.JSON.uiSchema": [],
-            // Alias for other features, not dependencies per se
-            "Object.RDF": ["Object.fromRdf", "Object.toRdf"],
-            "Object.schema": [],
-            "Object.toJson": ["Object.JSON.type", "Object.type"],
-            "Object.toRdf": ["Object.schema", "Object.type"],
-            "Object.toString": ["Object.type"],
-            "Object.SPARQL": ["Object.schema"],
-            "Object.type": [], // Implies Object.Identifier
-            ObjectSet: ["Object.filter"],
-            // Alias for other features, not dependencies per se
-            RDF: ["Object.RDF", "RdfjsDatasetObjectSet"],
-            RdfjsDatasetObjectSet: ["Object.fromRdf", "ObjectSet"],
-            SPARQL: ["Object.SPARQL", "SparqlObjectSet"],
-            SparqlObjectSet: ["Object.SPARQL", "ObjectSet"],
-        };
-        function finalize(ast, partialConfiguration) {
-            const requestedFeatures = partialConfiguration?.features ?? Configuration.default_.features;
-            const featureDependencies = Object.fromEntries(Object.entries(featureDependenciesStatic).map(([k, v]) => [k, [...v]]));
-            if (ast.lazyTypesCount > 0) {
-                featureDependencies["Object.fromJson"].push("ObjectSet");
-                featureDependencies["Object.fromRdf"].push("ObjectSet", "RdfjsDatasetObjectSet");
-            }
-            const inferredFeatures = new Set(requestedFeatures);
-            {
-                const inferredFeaturesQueue = [...requestedFeatures];
-                while (inferredFeaturesQueue.length > 0) {
-                    const feature = inferredFeaturesQueue.shift();
-                    for (const featureDependency of featureDependencies[feature]) {
-                        if (!inferredFeatures.has(featureDependency)) {
-                            inferredFeatures.add(featureDependency);
-                            inferredFeaturesQueue.push(featureDependency);
-                        }
-                    }
-                }
-            }
-            return {
-                features: inferredFeatures,
-                finalized: true,
-                syntheticNamePrefix: partialConfiguration?.syntheticNamePrefix ??
-                    Configuration.default_.syntheticNamePrefix,
-            };
-        }
-        Configuration.finalize = finalize;
-    })(Configuration = TsGenerator.Configuration || (TsGenerator.Configuration = {}));
-})(TsGenerator || (TsGenerator = {}));
-//# sourceMappingURL=TsGenerator.js.map

package/dist/generators/ts/Type.d.ts

@@ -1,25 +0,0 @@
-import type { BigDecimalType } from "./BigDecimalType.js";
-import type { BigIntType } from "./BigIntType.js";
-import type { BlankNodeType } from "./BlankNodeType.js";
-import type { BooleanType } from "./BooleanType.js";
-import type { DateTimeType } from "./DateTimeType.js";
-import type { DateType } from "./DateType.js";
-import type { DefaultValueType } from "./DefaultValueType.js";
-import type { FloatType } from "./FloatType.js";
-import type { IdentifierType } from "./IdentifierType.js";
-import type { IntType } from "./IntType.js";
-import type { IriType } from "./IriType.js";
-import type { LazyOptionType } from "./LazyOptionType.js";
-import type { LazySetType } from "./LazySetType.js";
-import type { LazyType } from "./LazyType.js";
-import type { ListType } from "./ListType.js";
-import type { LiteralType } from "./LiteralType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { OptionType } from "./OptionType.js";
-import type { SetType } from "./SetType.js";
-import type { StringType } from "./StringType.js";
-import type { TermType } from "./TermType.js";
-import type { UnionType } from "./UnionType.js";
-export type Type = BigDecimalType | BigIntType | BlankNodeType | BooleanType | DateTimeType | DateType | DefaultValueType<DefaultValueType.ItemType> | FloatType | IdentifierType | IntType | IriType | LazyOptionType | LazySetType | LazyType | ListType<ListType.ItemType> | LiteralType | ObjectUnionType | ObjectType | OptionType<OptionType.ItemType> | SetType<SetType.ItemType> | StringType | TermType | UnionType<Type>;
-//# sourceMappingURL=Type.d.ts.map

package/dist/generators/ts/Type.js

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

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

@@ -1,43 +0,0 @@
-import type { Literal, NamedNode } from "@rdfjs/types";
-import type { Logger } from "ts-log";
-import * as ast from "../../ast/index.js";
-import { ObjectType } from "./ObjectType.js";
-import { ObjectUnionType } from "./ObjectUnionType.js";
-import type { Reusables } from "./Reusables.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import type { Type } from "./Type.js";
-import { UnionType } from "./UnionType.js";
-export declare class TypeFactory {
-    private readonly configuration;
-    private readonly logger;
-    private readonly reusables;
-    private cachedObjectUnionTypesByShapeIdentifier;
-    private cachedObjectTypePropertiesByShapeIdentifier;
-    private cachedObjectTypesByShapeIdentifier;
-    constructor({ configuration, logger, reusables, }: {
-        configuration: TsGenerator.Configuration;
-        logger: Logger;
-        reusables: Reusables;
-    });
-    createObjectType(astType: ast.StructType): ObjectType;
-    createObjectUnionType(astType: ast.StructUnionType): ObjectUnionType;
-    createType(astType: ast.Type, parameters?: {
-        defaultValue?: Literal | NamedNode;
-    }): Type;
-    createUnionType(astType: ast.UnionType): ObjectUnionType | UnionType<Type>;
-    private createBlankNodeType;
-    private createDefaultValueType;
-    private createIdentifierType;
-    private createIriType;
-    private createLazyOptionType;
-    private createLazySetType;
-    private createLazyType;
-    private createListType;
-    private createLiteralType;
-    private createObjectTypeProperty;
-    private createOptionType;
-    private createSetType;
-    private createTermType;
-    private tsName;
-}
-//# sourceMappingURL=TypeFactory.d.ts.map