oneportal-scripts 3.7.5

package/bin/oneportal-scripts.js

@@ -0,0 +1,44 @@
+"use strict";
+
+process.on("unhandledRejection", (err) => {
+  throw err;
+});
+
+const spawn = require("react-dev-utils/crossSpawn");
+const args = process.argv.slice(2);
+
+const scriptIndex = args.findIndex(
+  (x) => x === "build" || x === "eject" || x === "start" || x === "test",
+);
+const script = scriptIndex === -1 ? args[0] : args[scriptIndex];
+const nodeArgs = scriptIndex > 0 ? args.slice(0, scriptIndex) : [];
+
+if (["build", "eject", "start", "test"].includes(script)) {
+  const result = spawn.sync(
+    process.execPath,
+    nodeArgs
+      .concat(require.resolve("../scripts/" + script))
+      .concat(args.slice(scriptIndex + 1)),
+    { stdio: "inherit" },
+  );
+  if (result.signal) {
+    if (result.signal === "SIGKILL") {
+      console.log(
+        "The build failed because the process exited too early. " +
+          "This probably means the system ran out of memory or someone called " +
+          "`kill -9` on the process.",
+      );
+    } else if (result.signal === "SIGTERM") {
+      console.log(
+        "The build failed because the process exited too early. " +
+          "Someone might have called `kill` or `killall`, or the system could " +
+          "be shutting down.",
+      );
+    }
+    process.exit(1);
+  }
+  process.exit(result.status);
+} else {
+  console.log('Unknown script "' + script + '".');
+  console.log("Perhaps you need to update react-scripts?");
+}

package/config/createTypeFolder.js

@@ -0,0 +1,27 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const paths = require("./paths");
+
+const plugin = { name: "CreateFolderPlugin" };
+
+class CreateFolderPlugin {
+  constructor(opts = {}) {
+    this.folderPaths = opts.folderPaths;
+  }
+
+  apply(compiler) {
+    compiler.hooks.emit.tap(plugin, () => {
+      if (!fs.existsSync(paths.appBuild)) {
+        fs.mkdirSync(paths.appBuild);
+      }
+      for (const folderPath of this.folderPaths) {
+        const fullPath = path.join(paths.appBuild, folderPath);
+        if (!fs.existsSync(fullPath)) {
+          fs.mkdirSync(fullPath);
+        }
+      }
+    });
+  }
+}
+
+exports.CreateFolderPlugin = CreateFolderPlugin;

package/config/downloadAndExtract.js

@@ -0,0 +1,48 @@
+const axios = require("axios");
+const tar = require("tar");
+const fs = require("node:fs");
+const path = require("node:path");
+const paths = require("./paths");
+const { promisify } = require("node:util");
+const { pipeline: streamPipeline } = require("node:stream");
+
+const pipeline = promisify(streamPipeline);
+
+class DownloadAndExtractPlugin {
+  constructor(opts) {
+    this.options = opts;
+  }
+
+  async downloadAndExtractLib(lib, destDir) {
+    const { fontdoorUrl, oneenv } = this.options;
+    const libPath = lib.lib ? lib.name : `apps/${lib.name}`;
+    const url = `${fontdoorUrl}/${oneenv}/${libPath}/${lib.name}-ts.tgz?v=${Math.random()}`;
+
+    try {
+      const response = await axios({ method: "get", url, responseType: "stream" });
+      await pipeline(response.data, tar.x({ C: destDir }));
+    } catch (err) {
+      console.error("Error downloading or extracting file:", err);
+    }
+  }
+
+  async processLibs(libs, destDir) {
+    await Promise.all(libs.map((lib) => this.downloadAndExtractLib(lib, destDir)));
+  }
+
+  apply(compiler) {
+    compiler.hooks.beforeRun.tapAsync(
+      "DownloadAndExtractPlugin",
+      async (compilation, callback) => {
+        try {
+          await this.processLibs(this.options.libs, paths.appPath);
+          callback();
+        } catch (err) {
+          callback(err);
+        }
+      },
+    );
+  }
+}
+
+exports.DownloadAndExtractPlugin = DownloadAndExtractPlugin;

package/config/dynamicPublicPath.js

@@ -0,0 +1,58 @@
+function buildPublicPath(moduleName, publicPath, fontdoorUrl) {
+  const localURL = localStorage.getItem(moduleName);
+  if (
+    localURL &&
+    (!window["oneportalextension"] || window["oneportalextension"]["debug"])
+  ) {
+    return localURL + "/";
+  }
+  if (moduleName === "oneportalshellapp") {
+    return "/";
+  }
+  if (publicPath !== "/") {
+    return publicPath;
+  }
+  const temp = window["oneportalextension"];
+  if (temp) {
+    const oneenv = temp.env;
+    const version = temp[moduleName];
+    const subapps = version ? "" : "/apps";
+    return fontdoorUrl + "/" + oneenv + subapps + "/" + moduleName + "/";
+  }
+  return "/";
+}
+
+class DynamicPublicPathPlugin {
+  defaultPublicPath = "";
+
+  constructor(opts = {}) {
+    this.moduleName = opts.moduleName;
+    this.publicPath = opts.publicPath;
+    this.fontdoorUrl = opts.fontdoorUrl;
+    this.port = opts.port;
+  }
+
+  apply(compiler) {
+    compiler.hooks.make.tap("MutateRuntime", (compilation) => {
+      compilation.hooks.runtimeModule.tap("MutateRuntime", (runtimeModule) => {
+        if (runtimeModule.constructor.name !== "PublicPathRuntimeModule")
+          return;
+
+        const [prefix] = runtimeModule.getGeneratedCode().split("=");
+        this.defaultPublicPath = compiler.options.output.publicPath;
+
+        const args = [
+          JSON.stringify(this.moduleName),
+          JSON.stringify(this.publicPath),
+          JSON.stringify(this.fontdoorUrl),
+        ].join(", ");
+
+        runtimeModule._cachedGeneratedCode = `${prefix} = (${buildPublicPath.toString()})(${args});`;
+
+        return runtimeModule;
+      });
+    });
+  }
+}
+
+exports.DynamicPublicPathPlugin = DynamicPublicPathPlugin;

package/config/env.js

@@ -0,0 +1,67 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const paths = require("./paths");
+const dotenv = require("dotenv");
+const dotenvExpand = require("dotenv-expand");
+
+delete require.cache[require.resolve("./paths")];
+
+const NODE_ENV = process.env.NODE_ENV;
+if (!NODE_ENV) {
+  throw new Error(
+    "The NODE_ENV environment variable is required but was not specified.",
+  );
+}
+
+const dotenvFiles = [
+  `${paths.dotenv}.${NODE_ENV}.local`,
+  NODE_ENV !== "test" && `${paths.dotenv}.local`,
+  `${paths.dotenv}.${NODE_ENV}`,
+  paths.dotenv,
+].filter(Boolean);
+
+dotenvFiles.forEach((dotenvFile) => {
+  if (fs.existsSync(dotenvFile)) {
+    dotenvExpand.expand(dotenv.config({ path: dotenvFile }));
+  }
+});
+
+const appDirectory = fs.realpathSync(process.cwd());
+
+process.env.NODE_PATH = (process.env.NODE_PATH || "")
+  .split(path.delimiter)
+  .filter((p) => p && !path.isAbsolute(p))
+  .map((p) => path.resolve(appDirectory, p))
+  .join(path.delimiter);
+
+const REACT_APP = /^REACT_APP_/i;
+
+function getClientEnvironment(publicUrl) {
+  const raw = Object.keys(process.env)
+    .filter((key) => REACT_APP.test(key))
+    .reduce(
+      (acc, key) => {
+        acc[key] = process.env[key];
+        return acc;
+      },
+      {
+        NODE_ENV: process.env.NODE_ENV || "development",
+        PUBLIC_URL: publicUrl,
+        WDS_SOCKET_HOST: process.env.WDS_SOCKET_HOST,
+        WDS_SOCKET_PATH: process.env.WDS_SOCKET_PATH,
+        WDS_SOCKET_PORT: process.env.WDS_SOCKET_PORT,
+        FAST_REFRESH: process.env.FAST_REFRESH !== "false",
+      },
+    );
+
+  const stringified = {
+    "process.env": Object.keys(raw).reduce((acc, key) => {
+      acc[key] = JSON.stringify(raw[key]);
+      return acc;
+    }, {}),
+  };
+
+  return { raw, stringified };
+}
+
+module.exports = getClientEnvironment;

package/config/getCopyPatterns.js

@@ -0,0 +1,32 @@
+let fs = require("node:fs"),
+  path = require("node:path"),
+  paths = require("./paths"),
+  foldersToCheck = [
+    {
+      from: "extension.json",
+      to: paths.appBuild,
+      parentPath: paths.appPath,
+    },
+    {
+      from: "src/i18n",
+      to: paths.appBuild + "/i18n",
+      parentPath: paths.appPath,
+    },
+    {
+      from: "static",
+      to: "" + paths.appBuild,
+      parentPath: paths.appPath,
+    },
+  ];
+
+function getCopyPatterns() {
+  return foldersToCheck
+    .filter((folder) =>
+      fs.existsSync(path.resolve(folder.parentPath, folder.from)),
+    )
+    .map((folder) => ({
+      from: folder.from,
+      to: folder.to,
+    }));
+}
+module.exports = getCopyPatterns;

package/config/getHttpsConfig.js

@@ -0,0 +1,50 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+const chalk = require("react-dev-utils/chalk");
+const paths = require("./paths");
+
+function validateKeyAndCerts({ cert, key, keyFile, crtFile }) {
+  let encrypted;
+  try {
+    encrypted = crypto.publicEncrypt(cert, Buffer.from("test"));
+  } catch (err) {
+    throw new Error(`The certificate "${chalk.yellow(crtFile)}" is invalid.\n${err.message}`);
+  }
+  try {
+    crypto.privateDecrypt(key, encrypted);
+  } catch (err) {
+    throw new Error(`The certificate key "${chalk.yellow(keyFile)}" is invalid.\n${err.message}`);
+  }
+}
+
+function readEnvFile(filePath, envVarName) {
+  if (fs.existsSync(filePath)) {
+    return fs.readFileSync(filePath);
+  }
+  throw new Error(
+    `You specified ${chalk.cyan(envVarName)} in your env, but the file "${chalk.yellow(filePath)}" can't be found.`,
+  );
+}
+
+function getHttpsConfig() {
+  const { SSL_CRT_FILE, SSL_KEY_FILE, HTTPS } = process.env;
+  const httpsEnabled = HTTPS === "true";
+
+  let result = httpsEnabled;
+
+  if (httpsEnabled && SSL_CRT_FILE && SSL_KEY_FILE) {
+    const crtFile = path.resolve(paths.appPath, SSL_CRT_FILE);
+    const keyFile = path.resolve(paths.appPath, SSL_KEY_FILE);
+    const certConfig = {
+      cert: readEnvFile(crtFile, "SSL_CRT_FILE"),
+      key: readEnvFile(keyFile, "SSL_KEY_FILE"),
+    };
+    validateKeyAndCerts({ ...certConfig, keyFile, crtFile });
+    result = certConfig;
+  }
+
+  return result;
+}
+
+module.exports = getHttpsConfig;

package/config/glasses.json

@@ -0,0 +1,52 @@
+{
+  "name": "oneportal-app",
+  "version": "1.0.0",
+  "publicPath": "/",
+  "port": 3000,
+  "libs": [],
+  "remotelibs": [],
+  "activeshared": true,
+  "eager": false,
+  "contenthash": true,
+  "enabledts": false,
+  "exposes": {
+    "./App": "./src/App"
+  },
+  "environmentVariables": {
+    "ONEPORTAL_FRONT_DOOR": "https://localhost:3000",
+    "ONEPORTAL_ENV": "dev"
+  },
+  "sharedlibrary": {
+    "development": {
+      "href": "https://sharenet.blob.core.windows.net/sharedlibrary"
+    },
+    "staging": {
+      "href": "https://sharenet.blob.core.windows.net/sharedlibrary"
+    },
+    "production": {
+      "href": "https://sharenet.blob.core.windows.net/sharedlibrary"
+    }
+  },
+  "oneportalutilities": {
+    "development": {
+      "href": "https://sharenet.blob.core.windows.net/oneportalutilities"
+    },
+    "staging": {
+      "href": "https://sharenet.blob.core.windows.net/oneportalutilities"
+    },
+    "production": {
+      "href": "https://sharenet.blob.core.windows.net/oneportalutilities"
+    }
+  },
+  "oneportalcore": {
+    "development": {
+      "href": "https://sharenet.blob.core.windows.net/oneportalcore"
+    },
+    "staging": {
+      "href": "https://sharenet.blob.core.windows.net/oneportalcore"
+    },
+    "production": {
+      "href": "https://sharenet.blob.core.windows.net/oneportalcore"
+    }
+  }
+}

package/config/paths.js

@@ -0,0 +1,68 @@
+const path = require("node:path");
+const fs = require("node:fs");
+const getPublicUrlOrPath = require("react-dev-utils/getPublicUrlOrPath");
+
+const appDirectory = fs.realpathSync(process.cwd());
+
+const resolveApp = (relativePath) => path.resolve(appDirectory, relativePath);
+
+const publicUrlOrPath = getPublicUrlOrPath(
+  process.env.NODE_ENV === "development",
+  require(resolveApp("package.json")).homepage,
+  process.env.PUBLIC_URL,
+);
+
+const buildPath = process.env.BUILD_PATH || "build";
+
+const moduleFileExtensions = [
+  "web.mjs",
+  "mjs",
+  "web.js",
+  "js",
+  "web.ts",
+  "ts",
+  "web.tsx",
+  "tsx",
+  "json",
+  "web.jsx",
+  "jsx",
+];
+
+const resolveModule = (resolveFn, filePath, useTypeScript = true) => {
+  const ext = moduleFileExtensions.find((extension) =>
+    fs.existsSync(resolveFn(`${filePath}.${extension}`)),
+  );
+  const fallbackExt = useTypeScript ? "ts" : "js";
+  return resolveFn(ext ? `${filePath}.${ext}` : `${filePath}.${fallbackExt}`);
+};
+
+const resolveOwn = (relativePath) =>
+  path.resolve(__dirname, "..", relativePath);
+
+module.exports = {
+  dotenv: resolveApp(".env"),
+  appPath: resolveApp("."),
+  appBuild: resolveApp(buildPath),
+  appPublic: resolveApp("public"),
+  appHtml: resolveApp("public/index.html"),
+  appIndexJs: resolveModule(resolveApp, "src/index"),
+  extension: resolveApp("config/glasses.json"),
+  appPackageJson: resolveApp("package.json"),
+  appSrc: resolveApp("src"),
+  appTsConfig: resolveApp("tsconfig.json"),
+  appJsConfig: resolveApp("jsconfig.json"),
+  yarnLockFile: resolveApp("yarn.lock"),
+  testsSetup: resolveModule(resolveApp, "src/setupTests"),
+  proxySetup: resolveApp("src/setupProxy.js"),
+  appNodeModules: resolveApp("node_modules"),
+  appWebpackCache: resolveApp("node_modules/.cache"),
+  appTsBuildInfoFile: resolveApp("node_modules/.cache/tsconfig.tsbuildinfo"),
+  swSrc: resolveModule(resolveApp, "src/service-worker"),
+  publicUrlOrPath,
+  ownPath: resolveOwn("."),
+  ownNodeModules: resolveOwn("node_modules"),
+  appTypeDeclarations: resolveApp("src/react-app-env.d.ts"),
+  ownTypeDeclarations: resolveOwn("lib/react-app.d.ts"),
+};
+
+module.exports.moduleFileExtensions = moduleFileExtensions;