@atls/raijin 0.2.1 → 0.2.3

package/dist/initializer/index.js

@@ -14,5 +14,5 @@ export const runRaijinInitializer = async ({ argv = [], cwd = process.cwd(), fet
     await ensureYarnLock(cwd);
     await runCommand(['add', '-D', CODE_RUNTIME_PACKAGE], cwd);
     await runCommand(['generate', 'project'], cwd);
-    await runCommand(['tools', 'sync'], cwd);
+    await runCommand(['raijin', 'sync'], cwd);
 };

package/dist/yarn/command.d.ts

@@ -1,3 +1,3 @@
 import type { YarnCommandRunner } from './runner.js';
-export declare const createYarnCommandEnvironment: (environment?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
+export declare const createYarnCommandEnvironment: (cwd: string, environment?: NodeJS.ProcessEnv) => NodeJS.ProcessEnv;
 export declare const runYarnCommand: YarnCommandRunner;

package/dist/yarn/command.js

@@ -1,14 +1,121 @@
 import { spawn } from 'node:child_process';
+import { delimiter } from 'node:path';
 import { RaijinYarnCommandException } from './exceptions/command.js';
-export const createYarnCommandEnvironment = (environment = process.env) => {
+const PATH_ENVIRONMENT_NAME = /^path$/i;
+const TEMPORARY_YARN_BIN_PATH = /[\\/]xfs-[^\\/]*(?:[\\/]|$)/;
+const PNP_NODE_OPTION = /(?:^|[\\/])\.pnp\.(?:cjs|loader\.mjs)$/;
+const NODE_OPTIONS_WITH_VALUE = new Set(['--experimental-loader', '--loader', '--require', '-r']);
+const isPnPNodeOptionValue = (value) => PNP_NODE_OPTION.test(value);
+const splitNodeOptions = (nodeOptions) => {
+    const tokens = [];
+    let raw = '';
+    let value = '';
+    let quote;
+    for (let index = 0; index < nodeOptions.length; index += 1) {
+        const char = nodeOptions[index];
+        if (quote) {
+            raw += char;
+            if (char === '\\' && nodeOptions[index + 1] === quote) {
+                index += 1;
+                raw += nodeOptions[index];
+                value += nodeOptions[index];
+                continue;
+            }
+            if (char === quote) {
+                quote = undefined;
+                continue;
+            }
+            value += char;
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            raw += char;
+            quote = char;
+            continue;
+        }
+        if (/\s/.test(char)) {
+            if (raw) {
+                tokens.push({ raw, value });
+                raw = '';
+                value = '';
+            }
+            continue;
+        }
+        raw += char;
+        value += char;
+    }
+    if (raw) {
+        tokens.push({ raw, value });
+    }
+    return tokens;
+};
+const removePnPNodeOptions = (nodeOptions) => {
+    const options = splitNodeOptions(nodeOptions);
+    const filtered = [];
+    for (let index = 0; index < options.length; index += 1) {
+        const option = options[index];
+        const [name, value] = option.value.split('=', 2);
+        if (value && NODE_OPTIONS_WITH_VALUE.has(name) && isPnPNodeOptionValue(value)) {
+            continue;
+        }
+        if (NODE_OPTIONS_WITH_VALUE.has(option.value)) {
+            const next = options.at(index + 1);
+            if (next && isPnPNodeOptionValue(next.value)) {
+                index += 1;
+                continue;
+            }
+        }
+        filtered.push(option.raw);
+    }
+    return filtered.join(' ');
+};
+const isTemporaryYarnBinPath = (value) => TEMPORARY_YARN_BIN_PATH.test(value);
+const sanitizePathEnvironment = (value) => value
+    .split(delimiter)
+    .filter((item) => item && !isTemporaryYarnBinPath(item))
+    .join(delimiter);
+const setPathEnvironment = (environment) => {
+    const pathName = Object.keys(environment).find((name) => PATH_ENVIRONMENT_NAME.test(name));
+    if (!pathName) {
+        return;
+    }
+    const pathValue = environment[pathName];
+    if (!pathValue) {
+        return;
+    }
+    const sanitizedPathValue = sanitizePathEnvironment(pathValue);
+    if (sanitizedPathValue) {
+        environment[pathName] = sanitizedPathValue;
+    }
+    else {
+        Reflect.deleteProperty(environment, pathName);
+    }
+};
+export const createYarnCommandEnvironment = (cwd, environment = process.env) => {
     const yarnEnvironment = { ...environment };
+    const nodeOptions = yarnEnvironment.NODE_OPTIONS;
+    delete yarnEnvironment.BERRY_BIN_FOLDER;
+    delete yarnEnvironment.npm_config_user_agent;
+    delete yarnEnvironment.npm_execpath;
     delete yarnEnvironment.YARN_IGNORE_PATH;
+    if (nodeOptions) {
+        const sanitizedNodeOptions = removePnPNodeOptions(nodeOptions);
+        if (sanitizedNodeOptions) {
+            yarnEnvironment.NODE_OPTIONS = sanitizedNodeOptions;
+        }
+        else {
+            delete yarnEnvironment.NODE_OPTIONS;
+        }
+    }
+    setPathEnvironment(yarnEnvironment);
+    yarnEnvironment.INIT_CWD = cwd;
+    yarnEnvironment.PROJECT_CWD = cwd;
     return yarnEnvironment;
 };
 export const runYarnCommand = async (args, cwd) => {
     const child = spawn('yarn', args, {
         cwd,
-        env: createYarnCommandEnvironment(),
+        env: createYarnCommandEnvironment(cwd),
         shell: process.platform === 'win32',
         stdio: 'inherit',
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atls/raijin",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "license": "BSD-3-Clause",
   "type": "module",
   "exports": {