@intelligentgraphics/ig.gfx.packager 3.0.20 → 3.0.22

package/build/index-7d81fa31.mjs

@@ -1,706 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as terser from 'terser';
-import 'resolve';
-import 'write-pkg';
-import { r as readPackageCreatorManifest, c as readPackageAnimationList, q as readPackageNpmManifest } from './cli-c7da3faf.mjs';
-import { g as getPackageTypescriptFiles } from './scripts-7ed8dff6.mjs';
-import 'node:path';
-import 'node:fs';
-import 'axios';
-import ts from 'typescript';
-import typedoc from 'typedoc';
-import glob from 'glob';
-import Ajv from 'ajv';
-
-const logPackageMessage = (name, step, index, total)=>{
-    const numLength = total === undefined ? undefined : total.toString().length;
-    const indexString = total === undefined || total < 2 ? "" : `${index.toString().padStart(numLength, "0")}/${total} `;
-    const identifierString = `${indexString}${name.padEnd(15)}`;
-    console.log(`${identifierString} >> ${step}`);
-};
-
-const tryReadTsConfig = (location)=>{
-    const { config  } = ts.readConfigFile(path.join(location.scriptsDir, "tsconfig.json"), (path)=>{
-        try {
-            return fs.readFileSync(path, "utf8");
-        } catch  {
-            return undefined;
-        }
-    });
-    return config;
-};
-const build = async (location, outputDir)=>{
-    const config = tryReadTsConfig(location);
-    config.compilerOptions.lib = [
-        "es5",
-        "dom"
-    ];
-    const result = ts.convertCompilerOptionsFromJson(config.compilerOptions, location.scriptsDir);
-    const compilerOptions = {
-        ...result.options,
-        removeComments: false,
-        declaration: true,
-        sourceMap: false,
-        // We don't use tsc to actually emit the files, but we still need to set the correct
-        // output directory so the compiler can rewrite the `reference path` directives.
-        outFile: path.join(outputDir, "out.js"),
-        target: ts.ScriptTarget.ES5,
-        noEmitOnError: true
-    };
-    const host = ts.createCompilerHost(compilerOptions);
-    host.getCurrentDirectory = ()=>location.scriptsDir;
-    let js;
-    let definitions;
-    host.writeFile = (fileName, data, writeByteOrderMark)=>{
-        if (fileName.endsWith(".js")) {
-            js = data;
-        } else if (fileName.endsWith(".d.ts")) {
-            definitions = data;
-        }
-    };
-    const files = getPackageTypescriptFiles(location);
-    if (files.length === 0) {
-        throw new Error(`Expected typescript files to exist when building a package. Packages only consisting of animation jsons do not need to be built.`);
-    }
-    const programOptions = {
-        rootNames: files,
-        options: compilerOptions,
-        host
-    };
-    const program = ts.createProgram(programOptions);
-    const emitResult = program.emit();
-    const allDiagnostics = ts.getPreEmitDiagnostics(program);
-    if (!emitResult.emitSkipped) {
-        if (allDiagnostics.length > 0) {
-            console.log(allDiagnostics.map(createErrorMessage).join("\n"));
-        }
-        if (js === undefined || definitions === undefined) {
-            throw new Error(`Unexpected: no js or definitions were created`);
-        }
-        return {
-            js,
-            definitions
-        };
-    }
-    const error = allDiagnostics.map(createErrorMessage).join("\n");
-    throw new Error(error);
-};
-const createErrorMessage = (diagnostic)=>{
-    if (!diagnostic.file) {
-        return `${ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n")}`;
-    }
-    const { line , character  } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
-    return `${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`;
-};
-
-const generateDocs = async (location, declarationFile, outFolder, name)=>{
-    const app = new typedoc.Application();
-    const mediaDir = path.join(location.manifestDir, "Media");
-    app.bootstrap({
-        entryPoints: [
-            declarationFile
-        ],
-        media: mediaDir,
-        out: outFolder,
-        tsconfig: path.join(location.scriptsDir, "tsconfig.json"),
-        skipErrorChecking: true
-    });
-    app.options.setCompilerOptions([
-        declarationFile
-    ], {
-        target: ts.ScriptTarget.ES5
-    }, undefined);
-    app.options.setValue("name", name);
-    const [readmePath] = glob.sync("**/readme.md", {
-        absolute: true,
-        cwd: location.manifestDir
-    });
-    if (readmePath) {
-        app.options.setValue("readme", readmePath);
-    }
-    const project = app.convert();
-    if (project) {
-        await app.generateDocs(project, outFolder);
-    }
-};
-
-// Stolen from ig.tools.core
-const toposort = (packages)=>{
-    const queue = Object.getOwnPropertyNames(packages);
-    const result = [];
-    let index = 0;
-    while(queue.length > 0){
-        if (index >= queue.length) {
-            throw new Error("Packages can not have cyclic dependencies");
-        }
-        const queueEntry = queue[index];
-        const dependencies = packages[queueEntry];
-        const dependencyQueued = dependencies.some((dependency)=>queue.includes(dependency));
-        if (dependencyQueued) {
-            index++;
-            continue;
-        }
-        queue.splice(index, 1);
-        index = 0;
-        result.push(queueEntry);
-    }
-    return result;
-};
-
-var animationSchema = {
-    $schema: "http://json-schema.org/draft-07/schema",
-    $id: "https://archive.intelligentgraphics.biz/schemas/gfx/animation.json",
-    $comment: "Version 2023-02-17, Source: ig.data.gfx/Specs/animation.json",
-    title: "Animation description format",
-    additionalProperties: false,
-    type: "object",
-    properties: {
-        $schema: {
-            type: "string"
-        },
-        Id: {
-            type: "string",
-            description: "Animation id, to be unique in the project scope. Needs to be a valid JavaScript identifier."
-        },
-        Animations: {
-            type: "array",
-            description: "Declaration of animation states for gfx objects",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                properties: {
-                    _: {
-                        type: "string",
-                        description: "Comment"
-                    },
-                    Path: {
-                        $ref: "#/definitions/igxcPath"
-                    },
-                    States: {
-                        type: "object",
-                        additionalProperties: {
-                            type: "object",
-                            additionalProperties: false,
-                            properties: {
-                                Position: {
-                                    $ref: "#/definitions/vec3"
-                                },
-                                Rotation: {
-                                    $ref: "#/definitions/rotation"
-                                },
-                                Scaling: {
-                                    $ref: "#/definitions/vec3"
-                                },
-                                Visibility: {
-                                    type: "boolean"
-                                },
-                                Deformation: {
-                                    anyOf: [
-                                        {
-                                            type: "number"
-                                        },
-                                        {
-                                            type: "string"
-                                        }
-                                    ]
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        },
-        Kinematics: {
-            oneOf: [
-                {
-                    $ref: "#/definitions/kinematicChain"
-                },
-                {
-                    type: "array",
-                    items: {
-                        $ref: "#/definitions/kinematicChain"
-                    }
-                }
-            ]
-        },
-        LinkedPoints: {
-            type: "object",
-            additionalProperties: {
-                type: "array",
-                items: {
-                    type: "string"
-                }
-            }
-        },
-        _: {
-            type: "string",
-            description: "Comment"
-        }
-    },
-    definitions: {
-        vec3: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                X: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Y: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Z: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                _: {
-                    type: "string",
-                    description: "Comment"
-                }
-            }
-        },
-        rotation: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                Q: {
-                    description: "If true, the rotation is considered to be a Quaternion. Otherwise, it's interpreted as Euler arcs and W will be ignored.",
-                    type: "boolean"
-                },
-                X: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Y: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                Z: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                W: {
-                    anyOf: [
-                        {
-                            type: "number"
-                        },
-                        {
-                            type: "string"
-                        }
-                    ]
-                },
-                _: {
-                    type: "string",
-                    description: "Comment"
-                }
-            }
-        },
-        igxcPath: {
-            type: "string",
-            description: "Relative path of the target object",
-            pattern: "^((o|e)\\d+(\\.(o|e)\\d+)*|\\.)$"
-        },
-        param: {
-            type: "string",
-            pattern: "^Param\\d+$"
-        },
-        kinematicChain: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                GeometryBase: {
-                    type: "string"
-                },
-                Joints: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        properties: {
-                            Name: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        type: "string"
-                                    }
-                                ]
-                            },
-                            HeadX: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            HeadY: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            HeadZ: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            Tail: {
-                                oneOf: [
-                                    {
-                                        $ref: "#/definitions/param"
-                                    },
-                                    {
-                                        $ref: "#/definitions/igxcPath"
-                                    }
-                                ]
-                            },
-                            LimitLeft: {
-                                type: "number"
-                            },
-                            LimitRight: {
-                                type: "number"
-                            },
-                            LimitUp: {
-                                type: "number"
-                            },
-                            LimitDown: {
-                                type: "number"
-                            },
-                            FollowJointNode: {
-                                $ref: "#/definitions/igxcPath"
-                            },
-                            _TargetNodeForFollow: {
-                                type: "string"
-                            }
-                        }
-                    }
-                },
-                Target: {
-                    oneOf: [
-                        {
-                            $ref: "#/definitions/igxcPath"
-                        },
-                        {
-                            $ref: "#/definitions/param"
-                        },
-                        {
-                            type: "string",
-                            enum: [
-                                "subbase"
-                            ]
-                        }
-                    ]
-                },
-                Parent: {
-                    oneOf: [
-                        {
-                            $ref: "#/definitions/igxcPath"
-                        },
-                        {
-                            type: "string",
-                            enum: [
-                                "root"
-                            ]
-                        }
-                    ]
-                },
-                Tolerance: {
-                    type: "number"
-                },
-                MaxIterations: {
-                    type: "integer"
-                },
-                _: {
-                    type: "string",
-                    description: "Comment"
-                },
-                __: {
-                    type: "string",
-                    description: "Super Comment"
-                }
-            }
-        }
-    }
-};
-
-let validateAnimationJson;
-const getAnimationJsonValidation = async ()=>{
-    if (validateAnimationJson === undefined) {
-        validateAnimationJson = new Ajv({
-            coerceTypes: true,
-            allErrors: true,
-            removeAdditional: true,
-            useDefaults: "empty",
-            validateSchema: "log"
-        }).compile(animationSchema);
-    }
-    return validateAnimationJson;
-};
-const buildFolders = async (options)=>{
-    if (options.outDir !== undefined && options.clean) {
-        fs.rmSync(options.outDir, {
-            recursive: true
-        });
-    }
-    const workspace = options.workspace;
-    const folders = options.packages;
-    let sortedPackages = sortPackagesByBuildOrder(folders);
-    let index = 1;
-    for (const location of sortedPackages){
-        const hasTypescript = getPackageTypescriptFiles(location).length > 0;
-        ensureTsConfig(location);
-        const data = readPackageCreatorManifest(location);
-        const logStep = (step)=>logPackageMessage(data.Package, step, index, folders.length);
-        const outputDirectory = options.outDir || location.scriptsDir;
-        fs.mkdirSync(outputDirectory, {
-            recursive: true
-        });
-        let buildResult;
-        if (hasTypescript) {
-            logStep("Compiling typescript to javascript");
-            buildResult = await build(location, outputDirectory);
-        } else {
-            buildResult = {
-                js: ""
-            };
-        }
-        const banner = options.banner ? createBannerComment(options.banner) : undefined;
-        if (banner) {
-            buildResult.js = banner + "\n" + buildResult.js;
-            if (buildResult.definitions !== undefined) {
-                buildResult.definitions = banner + "\n" + buildResult.definitions;
-            }
-        }
-        const animations = new Map();
-        for (const scriptFilePath of readPackageAnimationList(location)){
-            const content = fs.readFileSync(scriptFilePath, {
-                encoding: "utf8"
-            });
-            let data;
-            try {
-                data = JSON.parse(content);
-            } catch (err) {
-                const relativePath = path.relative(options.workspace.path, scriptFilePath);
-                if (err instanceof SyntaxError) {
-                    throw new Error(`Encountered invalid syntax in file "${relativePath}": ${String(err)}`);
-                }
-                throw new Error(`Encountered an unexpected error while parsing animation json file at path "${relativePath}"`, {
-                    cause: err
-                });
-            }
-            if (!data.Id) {
-                const fileName = path.basename(scriptFilePath, ".animation.json");
-                data.Id = fileName;
-            }
-            (await getAnimationJsonValidation())(data);
-            delete data.$schema;
-            animations.set(data.Id, JSON.stringify(data));
-        }
-        if (animations.size > 0) {
-            const scope = data.Scope ?? data.Package;
-            const scopeParts = scope.split(".");
-            buildResult.js += createNamespace(scopeParts);
-            for (const [name, content] of animations){
-                buildResult.js += `${scope}["${name}"] = ` + content + ";";
-                logPackageMessage(data.Package, `Adding animation ${scope}.${name}`);
-            }
-        } else if (!hasTypescript) {
-            throw new Error(`Expected package to have a least one ts file or one animation.json file`);
-        }
-        fs.writeFileSync(path.join(outputDirectory, `${data.Package}.js`), buildResult.js, {
-            encoding: "utf8"
-        });
-        if (buildResult.definitions !== undefined) {
-            fs.writeFileSync(path.join(outputDirectory, `${data.Package}.d.ts`), buildResult.definitions, {
-                encoding: "utf8"
-            });
-        }
-        if (options.minimize) {
-            const minifyResult = await terser.minify(buildResult.js, {
-                ecma: 5
-            });
-            const minifiedPath = path.join(outputDirectory, `${data.Package}.min.js`);
-            fs.writeFileSync(minifiedPath, minifyResult.code, {
-                encoding: "utf8"
-            });
-        }
-        if (location.path.includes("Basics") && buildResult.definitions !== undefined) {
-            fs.mkdirSync(path.join(workspace.path, "lib"), {
-                recursive: true
-            });
-            logStep("Copying basics definition file to the lib folder");
-            fs.writeFileSync(path.join(workspace.path, "lib", `${data.Package}.d.ts`), buildResult.definitions, {
-                encoding: "utf8"
-            });
-        }
-        if (options.docs) {
-            logStep("Generating typedoc documentation");
-            await generateDocs(location, path.join(outputDirectory, `${data.Package}.d.ts`), path.join(workspace.path, "docs", data.Package), data.Package);
-        }
-        index++;
-    }
-};
-const createNamespace = (parts)=>{
-    let code = `var ${parts[0]};`;
-    for(let index = 0; index < parts.length; index++){
-        const path = parts.slice(0, index + 1).join(".");
-        code += `\n(${path} = ${path} || {});`;
-    }
-    return code;
-};
-const ensureTsConfig = (location)=>{
-    const tsconfigPath = path.join(location.scriptsDir, "tsconfig.json");
-    if (!fs.existsSync(tsconfigPath)) {
-        const content = {};
-        applyTsConfigOption(content);
-        fs.writeFileSync(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
-    } else {
-        const content = JSON.parse(fs.readFileSync(tsconfigPath, "utf8"));
-        applyTsConfigOption(content);
-        fs.writeFileSync(tsconfigPath, JSON.stringify(content, undefined, "\t"), "utf8");
-    }
-};
-const applyTsConfigOption = (data)=>{
-    data.compilerOptions = data.compilerOptions ?? {};
-    data.compilerOptions.target = "es5";
-    data.compilerOptions.lib = [
-        "es5",
-        "dom"
-    ];
-};
-const sortPackagesByBuildOrder = (folders)=>{
-    const packages = Array.from(folders).reduce((acc, location)=>{
-        const data = readPackageNpmManifest(location);
-        if (data !== undefined) {
-            acc[data.name] = {
-                data,
-                location
-            };
-        } else {
-            acc[location.path] = {
-                data: undefined,
-                location
-            };
-        }
-        return acc;
-    }, {});
-    const packageDependencies = Object.getOwnPropertyNames(packages).reduce((acc, packageName)=>{
-        const packageData = packages[packageName];
-        if (packageData.data === undefined) {
-            acc[packageName] = [];
-        } else {
-            acc[packageName] = Object.getOwnPropertyNames({
-                ...packageData.data.devDependencies,
-                ...packageData.data.dependencies,
-                ...packageData.data.peerDependencies
-            }).filter((packageName)=>packages[packageName] !== undefined);
-        }
-        return acc;
-    }, {});
-    const sortedPackages = toposort(packageDependencies);
-    const result = [];
-    for (const packageName of sortedPackages){
-        const location = packages[packageName].location;
-        if (readPackageCreatorManifest(location).Package.endsWith(".Basics")) {
-            result.unshift(location);
-        } else {
-            result.push(location);
-        }
-    }
-    return result;
-};
-const createBannerComment = (banner)=>{
-    const bannerParts = [];
-    if (banner.text) {
-        bannerParts.push(" * " + banner.text);
-    }
-    {
-        const details = [];
-        if (banner.version) {
-            details.push(`Version: ${banner.version}`);
-        }
-        if (banner.commit) {
-            if (banner.commitDirty) {
-                details.push(`Commit: ${banner.commit} (dirty)`);
-            } else {
-                details.push(`Commit: ${banner.commit}`);
-            }
-        }
-        if (banner.date) {
-            details.push(`Date: ${banner.date.toISOString()}`);
-        }
-        const detailsText = details.map((line)=>` * ${line}`).join("\n");
-        if (detailsText) {
-            bannerParts.push(detailsText);
-        }
-    }
-    const bannerText = bannerParts.join("\n\n");
-    if (bannerText) {
-        return `/*
-${bannerText}
-*
-* @preserve			
-*/`;
-    }
-    return undefined;
-};
-
-var index = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    buildFolders: buildFolders
-});
-
-export { buildFolders as b, index as i, logPackageMessage as l };
-//# sourceMappingURL=index-7d81fa31.mjs.map