@intelligentgraphics/ig.gfx.packager 3.0.8 → 3.0.10

package/build/index-7a955335.js

@@ -0,0 +1,479 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import { pipeline } from 'stream/promises';
+import { execSync } from 'child_process';
+import { r as readPublishedPackageCreatorIndex, d as determineWorkspaceIGLibraries, a as readPublishedPackageNpmManifest, b as readPublishedPackageCreatorManifest } from './dependencies-2565d80c.js';
+import { P as PACKAGE_FILE, I as INDEX_FILE, p as parseCreatorPackageName, g as getWorkspaceOutputPath, r as readPackageCreatorManifest, w as writePackageCreatorManifest, a as readPackageAnimationList, i as isErrorENOENT, b as readPackageCreatorIndex, c as readWorkspaceNpmManifest, u as uploadPackage, d as getPackageReleasesDirectory, e as getExistingPackages, s as startSession, f as closeSession } from './cli-cb85e4b5.js';
+import { l as logPackageMessage, b as buildFolders } from './index-67a112b8.js';
+import 'write-pkg';
+import 'glob';
+import 'node:path';
+import 'node:fs';
+import axios from 'axios';
+import { g as getVersionFileHandler, p as parseVersionFromString, a as getVersionInformationFromGit, b as getWorkspaceBannerText, c as parseVersionFromNumericVersion, P as PackageVersion } from './versionFile-cf6657c8.js';
+import Ajv from 'ajv';
+import JSZip from 'jszip';
+import * as terser from 'terser';
+import 'resolve';
+import 'update-notifier';
+import 'yargs/yargs';
+import 'url';
+import 'assert';
+import 'events';
+import 'core-js/modules/es.typed-array.set.js';
+import 'util';
+import 'inquirer';
+import 'typescript';
+import 'typedoc';
+import 'simple-git';
+
+const buildArchiveFromPublishedPackage = (location, manifest, creatorPackage)=>{
+    const archive = new JSZip();
+    archive.file(PACKAGE_FILE, JSON.stringify(creatorPackage, null, 2));
+    const index = readPublishedPackageCreatorIndex(location);
+    if (index !== undefined) {
+        archive.file(INDEX_FILE, JSON.stringify(index, null, 2));
+    }
+    archive.file(manifest.main, fs.createReadStream(path.join(location.path, manifest.main)));
+    return archive;
+};
+let validateSchema;
+const runtimeScripts = [
+    "Interactor",
+    "Core",
+    "Mixed"
+];
+const notRuntimeScripts = [
+    "Context",
+    "Evaluator"
+];
+const buildArchiveFromPackage = async (workspaceLocation, packageLocation, data)=>{
+    const { domain , subdomain  } = parseCreatorPackageName(data);
+    const logStep = (step)=>logPackageMessage(data.Package, step);
+    if (validateSchema === undefined) {
+        validateSchema = await axios.get("https://archive.intelligentgraphics.biz/schemas/gfx/animation.json").then(({ data  })=>new Ajv({
+                coerceTypes: true,
+                allErrors: true,
+                removeAdditional: true,
+                useDefaults: "empty",
+                validateSchema: "log"
+            }).compile(data));
+    }
+    const libFilePath = path.join(getWorkspaceOutputPath(workspaceLocation), `${data.Package}.min.js`);
+    const scriptDirectories = [
+        packageLocation.path,
+        packageLocation.scriptsDir
+    ];
+    if (subdomain === "GFX.Standard") {
+        logStep(`Including Images folder`);
+        scriptDirectories.push(path.join(packageLocation.path, "Images"));
+    }
+    const manifest = readPackageCreatorManifest(packageLocation);
+    if (manifest !== undefined) {
+        if (manifest.RunTime && notRuntimeScripts.includes(manifest.Type)) {
+            logStep("Setting script RunTime to false because of script type");
+            writePackageCreatorManifest(packageLocation, {
+                ...manifest,
+                RunTime: false
+            });
+        } else if (!manifest.RunTime && runtimeScripts.includes(manifest.Type)) {
+            logStep("Setting script RunTime to true because of script type");
+            writePackageCreatorManifest(packageLocation, {
+                ...manifest,
+                RunTime: true
+            });
+        }
+    }
+    // if (index === undefined) {
+    // 	throw new Error(
+    // 		`Could not find an "${INDEX_FILE}" file in "${primaryScriptDir}"`,
+    // 	);
+    // }
+    const animations = new Map();
+    for (const scriptFilePath of readPackageAnimationList(packageLocation)){
+        const content = fs.readFileSync(scriptFilePath, {
+            encoding: "utf8"
+        });
+        let data;
+        try {
+            data = JSON.parse(content);
+        } catch (err) {
+            const relativePath = path.relative(workspaceLocation.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
+            });
+        }
+        validateSchema(data);
+        animations.set(data.Id, JSON.stringify(data));
+    }
+    let libFile;
+    try {
+        libFile = fs.readFileSync(libFilePath, {
+            encoding: "utf8"
+        });
+    } catch (err) {
+        if (!isErrorENOENT(err)) {
+            throw err;
+        }
+    }
+    if (libFile === undefined) {
+        if (animations.size === 0) {
+            throw new Error(`Could not find a javascript file at "${libFilePath}".
+Packaging without a javascript file is only allowed when animation json files are available`);
+        }
+    }
+    const archive = new JSZip();
+    let library = "";
+    if (libFile) {
+        library = libFile;
+    }
+    if (!library) {
+        const date = new Date(Date.now());
+        library = `/* This file is part of the ${domain} Data Packages.
+		* Copyright (C) ${date.getFullYear()} intelligentgraphics. All Rights Reserved. */`;
+    }
+    if (animations.size > 0) {
+        const scopeParts = data.Scope.split(".");
+        const scope = data.Scope;
+        library += createNamespace(scopeParts);
+        for (const [name, data] of animations){
+            library += `${scope}.${name} = ` + data + ";";
+            logPackageMessage(manifest.Package, `Added animation ${scope}.${name}`);
+        }
+    }
+    const minifyResult = await terser.minify(library, {
+        ecma: 5
+    });
+    archive.file(`${data.Package}.js`, minifyResult.code);
+    archive.file(PACKAGE_FILE, JSON.stringify(data, null, 2));
+    const creatorIndex = readPackageCreatorIndex(packageLocation);
+    if (creatorIndex !== undefined) {
+        archive.file(INDEX_FILE, JSON.stringify(creatorIndex, null, 2));
+    }
+    for (const directory of scriptDirectories){
+        try {
+            for (const file of fs.readdirSync(directory)){
+                const { ext  } = path.parse(file);
+                switch(ext){
+                    case ".png":
+                    case ".jpeg":
+                    case ".jpg":
+                        break;
+                    default:
+                        continue;
+                }
+                archive.file(file, fs.createReadStream(path.join(directory, file)));
+            }
+        } catch (err) {
+            console.error(`Script directory "${directory}" does not exist`);
+        }
+    }
+    return archive;
+};
+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 releaseFolder = async (options)=>{
+    const workspace = options.workspace;
+    const location = options.directory;
+    const { write: writeVersionFile , reset: resetVersionFile  } = getVersionFileHandler(location);
+    const packageDescription = readPackageCreatorManifest(location);
+    const fullPackageName = packageDescription.Package;
+    const { domain , subdomain  } = parseCreatorPackageName(packageDescription);
+    const publishDomain = options.domain ?? domain;
+    const publishSubdomain = options.subdomain ?? subdomain;
+    const sharedPackageJson = readWorkspaceNpmManifest(workspace);
+    let newVersion;
+    try {
+        newVersion = parseVersionFromString(options.newVersion);
+    } catch (err) {
+        throw new Error(`Please enter a version in this format 1.0.0.100`);
+    }
+    if (newVersion.buildNumber < 100) {
+        newVersion.preRelease = {
+            type: "beta",
+            version: newVersion.buildNumber
+        };
+    } else if (newVersion.buildNumber > 100) {
+        newVersion.preRelease = {
+            type: "patch",
+            version: newVersion.buildNumber - 100
+        };
+    }
+    if (sharedPackageJson !== undefined) {
+        logPackageMessage(packageDescription.Package, `Running npm install to make sure all dependencies are up to date`);
+        execSync(`npm install`, {
+            encoding: "utf-8",
+            cwd: workspace.path
+        });
+    }
+    const binDir = getWorkspaceOutputPath(workspace);
+    fs.mkdirSync(binDir, {
+        recursive: true
+    });
+    let assetServerPackageDetails;
+    let packageNameWithVersion;
+    {
+        const versionWithoutPrelease = newVersion.clone();
+        versionWithoutPrelease.preRelease = undefined;
+        const newVersionString = versionWithoutPrelease.toVersionString({
+            buildNumber: true
+        });
+        packageNameWithVersion = `${packageDescription.Package}_${newVersionString}`;
+        assetServerPackageDetails = {
+            name: packageDescription.Package,
+            version: newVersionString
+        };
+    }
+    const zipFilePath = path.join(binDir, packageNameWithVersion + ".zip");
+    try {
+        if (options.pushOnly) {
+            if (!fs.existsSync(zipFilePath)) {
+                throw new Error(`Expected a zip file to exist at path ${zipFilePath} since pushOnly is specified`);
+            }
+        } else {
+            const gitVersionInformation = await getVersionInformationFromGit(workspace, location);
+            writeVersionFile(fullPackageName, newVersion);
+            const bannerText = sharedPackageJson !== undefined ? getWorkspaceBannerText(sharedPackageJson) : undefined;
+            await buildFolders({
+                ...options,
+                packages: [
+                    location
+                ],
+                skipPackagesWithoutTsFiles: true,
+                banner: options.banner ? {
+                    text: bannerText,
+                    commit: gitVersionInformation.commit,
+                    commitDirty: gitVersionInformation.dirty,
+                    version: newVersion.toVersionString({
+                        buildNumber: true
+                    }),
+                    date: new Date(Date.now())
+                } : undefined
+            });
+            newVersion.preRelease = undefined;
+            try {
+                fs.rmSync(zipFilePath);
+            } catch (err) {
+                if (!isErrorENOENT(err)) {
+                    throw err;
+                }
+            }
+            if (readPackageAnimationList(location).length > 0) {
+                var _workspaceManifest_dependencies;
+                const workspaceManifest = readWorkspaceNpmManifest(workspace);
+                if (!((_workspaceManifest_dependencies = workspaceManifest.dependencies) == null ? void 0 : _workspaceManifest_dependencies["@intelligentgraphics/3d.ig.gfx.standard"])) {
+                    const install = await options.prompter.confirm(`Animation.json files require the library 'IG.GFX.Standard' to be available, but it is not registered as a dependency. Do you want to install it now?`);
+                    if (install) {
+                        execSync(`npm install @intelligentgraphics/3d.ig.gfx.standard`, {
+                            encoding: "utf-8",
+                            cwd: workspace.path,
+                            stdio: "inherit"
+                        });
+                        execSync(`npm run postinstall`, {
+                            cwd: workspace.path
+                        });
+                    }
+                }
+            }
+            const archive = await buildArchiveFromPackage(workspace, location, packageDescription);
+            const zipOutputStream = fs.createWriteStream(zipFilePath);
+            await pipeline(archive.generateNodeStream(), zipOutputStream);
+        }
+        if (!options.noUpload) {
+            if (!options.authentication) {
+                throw new Error(`Expected authentication to be available`);
+            }
+            logPackageMessage(packageDescription.Package, `Opening connection to IG.Asset.Server`);
+            const sessionManager = await createSessionManager({
+                url: options.service,
+                address: options.address,
+                domain: publishDomain,
+                subDomain: publishSubdomain,
+                authentication: options.authentication
+            });
+            try {
+                if (!options.skipDependencies) {
+                    await ensureRequiredVersions(workspace, packageDescription, sessionManager, options.prompter);
+                }
+                logPackageMessage(packageDescription.Package, `Uploading package to ${publishDomain}.${publishSubdomain}`);
+                await uploadPackage(sessionManager.getTargetSession(), assetServerPackageDetails, zipFilePath);
+            } finally{
+                await sessionManager.destroy().catch((err)=>{
+                    logPackageMessage(packageDescription.Package, `Failed to close IG.Asset.Server session(s): ${err}`);
+                });
+            }
+        }
+    } catch (err) {
+        resetVersionFile();
+        throw err;
+    }
+    if (newVersion.buildNumber >= 100 && !options.pushOnly) {
+        logPackageMessage(fullPackageName, "Copying zip to releases folder");
+        const zipFileName = `${packageNameWithVersion}.zip`;
+        const releasesPath = getPackageReleasesDirectory(location);
+        fs.mkdirSync(releasesPath, {
+            recursive: true
+        });
+        fs.copyFileSync(zipFilePath, path.join(releasesPath, zipFileName));
+    }
+};
+const ensureRequiredVersions = async (workspaceLocation, creatorPackage, sessionManager, prompter)=>{
+    const libraries = determineWorkspaceIGLibraries(workspaceLocation);
+    // If there are no libraries, we don't need to check for required versions
+    if (libraries.length === 0) {
+        return true;
+    }
+    const targetSession = sessionManager.getTargetSession();
+    const rawUploadedPackages = await getExistingPackages(targetSession);
+    const uploadedPackages = rawUploadedPackages.map((entry)=>{
+        let version;
+        try {
+            version = parseVersionFromNumericVersion(entry.numericVersion);
+        } catch (err) {
+            throw new Error(`Encountered invalid format for version ${entry.numericVersion}`);
+        }
+        if (version.buildNumber < 100) {
+            version.preRelease = {
+                type: "beta",
+                version: version.buildNumber
+            };
+        } else if (version.buildNumber > 100) {
+            version.preRelease = {
+                type: "patch",
+                version: version.buildNumber - 100
+            };
+        }
+        return {
+            ...entry,
+            version
+        };
+    });
+    for (const libraryLocation of libraries){
+        const libraryManifest = readPublishedPackageNpmManifest(libraryLocation);
+        const libraryCreatorPackage = readPublishedPackageCreatorManifest(libraryLocation);
+        if (libraryCreatorPackage === undefined || libraryManifest.main === undefined || libraryCreatorPackage.Package === creatorPackage.Package) {
+            continue;
+        }
+        const libraryVersion = PackageVersion.extractFromLine(libraryManifest.version);
+        if (libraryVersion.preRelease) {
+            libraryVersion.buildNumber = libraryVersion.preRelease.version;
+            libraryVersion.preRelease = undefined;
+        } else {
+            libraryVersion.buildNumber = 100;
+        }
+        let uploadedPackageInBasics;
+        let uploadedPackageInTarget;
+        for (const uploadedPackage of uploadedPackages){
+            if (uploadedPackage.scope === libraryCreatorPackage.Package) {
+                if (uploadedPackage.support) {
+                    uploadedPackageInBasics = uploadedPackage;
+                } else {
+                    uploadedPackageInTarget = uploadedPackage;
+                }
+            }
+        }
+        const validInBasics = uploadedPackageInBasics !== undefined && !uploadedPackageInBasics.version.isLesserThan(libraryVersion);
+        const validInTarget = uploadedPackageInTarget !== undefined && !uploadedPackageInTarget.version.isLesserThan(libraryVersion);
+        if (validInBasics || validInTarget) {
+            if (targetSession.subDomain !== "Basics" && uploadedPackageInBasics !== undefined && uploadedPackageInTarget !== undefined) {
+                logPackageMessage(creatorPackage.Package, `Package ${libraryCreatorPackage.Package} is uploaded both for Basics and ${targetSession.subDomain}. The package within ${targetSession.subDomain} will be used.`);
+            }
+            continue;
+        }
+        logPackageMessage(creatorPackage.Package, `Requested at least version ${libraryVersion.toVersionString({
+            buildNumber: true
+        })} for package ${libraryCreatorPackage.Package}`);
+        if (targetSession.subDomain !== "Basics" && uploadedPackageInTarget) {
+            const version = uploadedPackageInTarget.version.toVersionString({
+                buildNumber: true
+            });
+            logPackageMessage(creatorPackage.Package, `Found invalid version ${version} for package ${libraryCreatorPackage.Package} in ${targetSession.subDomain}`);
+        }
+        if (uploadedPackageInBasics) {
+            const version = uploadedPackageInBasics.version.toVersionString({
+                buildNumber: true
+            });
+            let message = `Found invalid version ${version} for package ${libraryCreatorPackage.Package} in Basics`;
+            if (targetSession.subDomain !== "Basics" && uploadedPackageInTarget) {
+                message += `. This version will not be used since the package also exists in ${targetSession.subDomain}`;
+            }
+            logPackageMessage(creatorPackage.Package, message);
+        }
+        const possibleTargets = [
+            "Basics"
+        ];
+        if (targetSession.subDomain !== "Basics") {
+            possibleTargets.push(targetSession.subDomain);
+        }
+        const uploadTargetScope = await prompter.ask({
+            message: `Select the scope to upload the required version of ${libraryCreatorPackage.Package} to or select "skip" to skip the upload.`,
+            options: [
+                ...possibleTargets,
+                "Skip"
+            ],
+            default: possibleTargets[0]
+        });
+        if (uploadTargetScope === "Skip") {
+            continue;
+        }
+        const archive = buildArchiveFromPublishedPackage(libraryLocation, libraryManifest, libraryCreatorPackage);
+        const newVersionString = libraryVersion.toVersionString({
+            buildNumber: true
+        });
+        const packageNameWithVersion = `${libraryCreatorPackage.Package}_${newVersionString}`;
+        const zipFilePath = path.join(getWorkspaceOutputPath(workspaceLocation), `${packageNameWithVersion}.zip`);
+        try {
+            fs.rmSync(zipFilePath);
+        } catch (err) {
+            if (!isErrorENOENT(err)) {
+                throw err;
+            }
+        }
+        const zipOutputStream = fs.createWriteStream(zipFilePath);
+        await pipeline(archive.generateNodeStream(), zipOutputStream);
+        const session = uploadTargetScope === "Basics" ? await sessionManager.getBasicsSession() : targetSession;
+        logPackageMessage(creatorPackage.Package, `Uploading package ${libraryCreatorPackage.Package} with version ${newVersionString} to ${session.domain}.${session.subDomain}`);
+        await uploadPackage(session, {
+            name: libraryCreatorPackage.Package,
+            version: newVersionString
+        }, zipFilePath);
+    }
+};
+const createSessionManager = async (params)=>{
+    const targetSession = await startSession(params);
+    let basicsSession;
+    return {
+        getBasicsSession: async ()=>{
+            if (targetSession.subDomain === "Basics") {
+                return targetSession;
+            }
+            if (basicsSession === undefined) {
+                basicsSession = await startSession({
+                    ...params,
+                    subDomain: "Basics"
+                });
+            }
+            return basicsSession;
+        },
+        getTargetSession: ()=>targetSession,
+        destroy: async ()=>{
+            await closeSession(targetSession);
+            if (basicsSession !== undefined) {
+                await closeSession(basicsSession);
+            }
+        }
+    };
+};
+
+export { releaseFolder };
+//# sourceMappingURL=index-7a955335.js.map