@intelligentgraphics/ig.gfx.packager 3.0.9 → 3.0.10

package/build/index-a48c5d0a.js

@@ -1,480 +0,0 @@
-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-51916db0.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-17d957b0.js';
-import { l as logPackageMessage, b as buildFolders } from './index-ac2cd050.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-68e35b54.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 '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())
-          //  gitVersionInformation.commitDate
-          // 	? new Date(gitVersionInformation.commitDate)
-          // 	: 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$de;
-        const workspaceManifest = readWorkspaceNpmManifest(workspace);
-        if (!((_workspaceManifest$de = workspaceManifest.dependencies) !== null && _workspaceManifest$de !== void 0 && _workspaceManifest$de["@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-a48c5d0a.js.map