lucid-package 0.0.128 → 0.0.129

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-package",
-    "version": "0.0.128",
+    "version": "0.0.129",
     "description": "",
     "main": "index.js",
     "bin": {
@@ -14,8 +14,8 @@
         "@types/express": "^4.17.13",
         "@types/node": "^16.11.11",
         "@types/webpack": "^5.28.5",
-        "prettier": "file:../../cake/node_modules/prettier",
-        "prettier-plugin-organize-imports": "file:../../cake/node_modules/prettier-plugin-organize-imports"
+        "prettier": "catalog:",
+        "prettier-plugin-organize-imports": "catalog:"
     },
     "publishConfig": {
         "access": "public"

package/src/angularframeworkutils.d.ts

@@ -1 +1,2 @@
-export declare function createAngularEditorExtension(name: string, isInternal: boolean, skipSDKDependency: boolean): Promise<void>;
+import { PackageManagerOptions } from './installationutil';
+export declare function createAngularEditorExtension(name: string, isInternal: boolean, packageManagerOptions: PackageManagerOptions, skipSDKDependency: boolean): Promise<void>;

package/src/angularframeworkutils.js

@@ -8,14 +8,17 @@ const installationutil_1 = require("./installationutil");
 const package_1 = require("./package");
 const theme_1 = require("./theme");
 const ANGULAR_PROJECT_NAME = 'angular-app';
-async function createAngularEditorExtension(name, isInternal, skipSDKDependency) {
-    await (0, editorextension_1.createEditorExtension)(name, isInternal, skipSDKDependency, path.join('angular', 'skeleton'), [
+async function createAngularEditorExtension(name, isInternal, packageManagerOptions, skipSDKDependency) {
+    await (0, editorextension_1.createEditorExtension)(name, isInternal, packageManagerOptions, skipSDKDependency, path.join('angular', 'skeleton'), [
         'webpack-shell-plugin-next',
     ]);
     const angularEditorExtensionTargetFolder = path.join(process.cwd(), ANGULAR_PROJECT_NAME);
     console.log((0, theme_1.success)('Creating Angular project in ' + angularEditorExtensionTargetFolder));
-    (0, installationutil_1.installAngularProject)(ANGULAR_PROJECT_NAME);
-    const webpackConfig = (await fs.readFile('webpack.config.js', 'utf8')).replace('<<dynamicname>>', ANGULAR_PROJECT_NAME);
+    (0, installationutil_1.installAngularProject)(ANGULAR_PROJECT_NAME, packageManagerOptions);
+    const angularBuildCommand = `${packageManagerOptions.packageManagerPath} exec -- ./node_modules/@angular/cli build`;
+    const webpackConfig = (await fs.readFile('webpack.config.js', 'utf8'))
+        .replace('<<dynamicname>>', ANGULAR_PROJECT_NAME)
+        .replace('<<angularbuildcommand>>', angularBuildCommand);
     const extensionTemplateCode = (await fs.readFile(path.join('src', 'extension.ts'), 'utf8')).replace('<<dynamicname>>', ANGULAR_PROJECT_NAME);
     await fs.writeFile(path.join(process.cwd(), 'webpack.config.js'), webpackConfig);
     await fs.writeFile(path.join('src', 'extension.ts'), extensionTemplateCode);
@@ -24,5 +27,5 @@ async function createAngularEditorExtension(name, isInternal, skipSDKDependency)
     packageJson.name = ANGULAR_PROJECT_NAME;
     await fs.writeFile('package.json', JSON.stringify(packageJson, null, 4));
     console.log('Installing Angular dependencies');
-    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, skipSDKDependency);
+    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, packageManagerOptions, skipSDKDependency);
 }

package/src/dataconnector.d.ts

@@ -1 +1,2 @@
-export declare function createDataConnector(name: string, isInternal: boolean, skipSDKDependency: boolean): Promise<void>;
+import { PackageManagerOptions } from './installationutil';
+export declare function createDataConnector(name: string, isInternal: boolean, packageManagerOptions: PackageManagerOptions, skipSDKDependency: boolean): Promise<void>;

package/src/dataconnector.js

@@ -6,11 +6,11 @@ const filesystemutil_1 = require("./filesystemutil");
 const installationutil_1 = require("./installationutil");
 const package_1 = require("./package");
 const theme_1 = require("./theme");
-async function createDataConnector(name, isInternal, skipSDKDependency) {
+async function createDataConnector(name, isInternal, packageManagerOptions, skipSDKDependency) {
     console.log((0, theme_1.success)('Creating data connector in dataconnectors/' + name));
     const source = path.join(__dirname, '..', 'templates', 'dataconnector');
     const targetFolder = path.join('dataconnectors', name);
-    (0, filesystemutil_1.copyFolderRecursiveSync)(source, targetFolder);
+    (0, filesystemutil_1.copyFolderRecursiveSync)(source, targetFolder, (0, filesystemutil_1.getPackageManagerExcludePaths)(source, packageManagerOptions.mode));
     await (0, package_1.modifyManifest)((manifest) => {
         if (!manifest['dataConnectors']) {
             manifest['dataConnectors'] = [];
@@ -24,5 +24,5 @@ async function createDataConnector(name, isInternal, skipSDKDependency) {
     });
     console.log(`Installing dependencies`);
     process.chdir(targetFolder);
-    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, skipSDKDependency);
+    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, packageManagerOptions, skipSDKDependency);
 }

package/src/editorextension.d.ts

@@ -1,14 +1,15 @@
 import { Compiler } from 'webpack';
-export declare function createEditorExtension(name: string, isInternal: boolean, skipSDKDependency: boolean, source?: string, deps?: string[]): Promise<void>;
-export declare function buildEditorExtension(name: string, isInternal: boolean, quiet?: boolean, skipSdkDependency?: boolean): Promise<void>;
-export declare function updateExtensionSDK(name: string): Promise<void>;
+import { PackageManagerOptions } from './installationutil';
+export declare function createEditorExtension(name: string, isInternal: boolean, packageManagerOptions: PackageManagerOptions, skipSDKDependency: boolean, source?: string, deps?: string[]): Promise<void>;
+export declare function buildEditorExtension(name: string, isInternal: boolean, packageManagerOptions: PackageManagerOptions, quiet?: boolean, skipSdkDependency?: boolean): Promise<void>;
+export declare function updateExtensionSDK(name: string, packageManagerOptions: PackageManagerOptions): Promise<void>;
 /**
  * Uses webpack to watch for changes in the editor extension
  * @param name The editor extension name
  * @param quiet If true, will only show errors in output
  * @param ignoreNodeModules If true, while serving, will not autoreload on changes to node_modules files
  */
-export declare function watchEditorExtension(name: string, isInternal: boolean, quiet?: boolean, ignoreNodeModules?: boolean): Promise<{
+export declare function watchEditorExtension(name: string, isInternal: boolean, packageManagerOptions: PackageManagerOptions, quiet?: boolean, ignoreNodeModules?: boolean): Promise<{
     name: string;
     compiler: Compiler;
 }>;
@@ -18,5 +19,5 @@ export declare function watchEditorExtension(name: string, isInternal: boolean,
  * @param quiet If true, will only show errors in output
  * @param watchIgnoreNodeModules If true, while serving, will not autoreload on changes to node_modules files
  */
-export declare function debugEditorExtension(extensionNames: string[], isInternal: boolean, quiet?: boolean, pickAnyPort?: boolean, watchIgnoreNodeModules?: boolean): Promise<void>;
+export declare function debugEditorExtension(extensionNames: string[], isInternal: boolean, packageManagerOptions: PackageManagerOptions, quiet?: boolean, pickAnyPort?: boolean, watchIgnoreNodeModules?: boolean): Promise<void>;
 export declare function getAllExtensionNames(): Promise<string[]>;

package/src/editorextension.js

@@ -24,12 +24,12 @@ const webpack = require('webpack');
 const WebPackCLI = require('webpack-cli');
 const ws = require('ws');
 const chokidar = require('chokidar');
-async function createEditorExtension(name, isInternal, skipSDKDependency, source = 'vanilla', deps = []) {
+async function createEditorExtension(name, isInternal, packageManagerOptions, skipSDKDependency, source = 'vanilla', deps = []) {
     const editorExtensionSource = path.join(__dirname, '..', 'templates', 'editorextension', source);
     const editorExtensionTargetFolder = path.join('editorextensions', name);
-    const codePath = path.join('editorextensions', name, 'bin', 'extension.js');
+    const codePath = path.posix.join('editorextensions', name, 'bin', 'extension.js');
     console.log((0, theme_1.success)('Creating empty editor extension in ' + editorExtensionTargetFolder));
-    (0, filesystemutil_1.copyFolderRecursiveSync)(editorExtensionSource, editorExtensionTargetFolder);
+    (0, filesystemutil_1.copyFolderRecursiveSync)(editorExtensionSource, editorExtensionTargetFolder, (0, filesystemutil_1.getPackageManagerExcludePaths)(editorExtensionSource, packageManagerOptions.mode));
     // Angular and React extensions will automatically create the `public` folder,
     // during the webpack build
     if (source === 'vanilla') {
@@ -51,20 +51,20 @@ async function createEditorExtension(name, isInternal, skipSDKDependency, source
     });
     console.log(`Installing dependencies`);
     process.chdir(editorExtensionTargetFolder);
-    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, skipSDKDependency, deps);
+    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, packageManagerOptions, skipSDKDependency, deps);
 }
-async function buildEditorExtension(name, isInternal, quiet = false, skipSdkDependency = false) {
+async function buildEditorExtension(name, isInternal, packageManagerOptions, quiet = false, skipSdkDependency = false) {
     const extensionCodePath = path.join('editorextensions', await getExtensionCodeDirectoryName(name));
     process.chdir(extensionCodePath);
-    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, skipSdkDependency);
+    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, packageManagerOptions, skipSdkDependency);
     const cli = new WebPackCLI();
     await cli.run(['node', 'webpack', '--mode', 'production', ...(quiet ? ['--stats', 'errors-only'] : [])]);
 }
-async function updateExtensionSDK(name) {
+async function updateExtensionSDK(name, packageManagerOptions) {
     const extensionCodePath = path.join('editorextensions', await getExtensionCodeDirectoryName(name));
     process.chdir(extensionCodePath);
     console.log((0, theme_1.success)('Installing latest SDK in extension ' + name));
-    console.log((0, shellutil_1.execSyncLoggingOutputOnError)('npm install lucid-extension-sdk@latest').toString());
+    console.log((0, shellutil_1.execSyncLoggingOutputOnError)(`"${packageManagerOptions.packageManagerPath}" add lucid-extension-sdk@latest`).toString());
 }
 /**
  * Uses webpack to watch for changes in the editor extension
@@ -72,11 +72,11 @@ async function updateExtensionSDK(name) {
  * @param quiet If true, will only show errors in output
  * @param ignoreNodeModules If true, while serving, will not autoreload on changes to node_modules files
  */
-async function watchEditorExtension(name, isInternal, quiet = false, ignoreNodeModules = false) {
+async function watchEditorExtension(name, isInternal, packageManagerOptions, quiet = false, ignoreNodeModules = false) {
     const originalDirectory = process.cwd();
     const extensionCodePath = path.join('editorextensions', await getExtensionCodeDirectoryName(name));
     process.chdir(extensionCodePath);
-    (0, installationutil_1.installDependenciesIfNeeded)(isInternal);
+    (0, installationutil_1.installDependenciesIfNeeded)(isInternal, packageManagerOptions);
     const webpackConfigExport = require(path.resolve('webpack.config.js'));
     // For backwards compatibility, we need to support extensions where the webpack config is a fuction or an object
     const webpackConfig = typeof webpackConfigExport == 'function' ? webpackConfigExport({ environment: 'dev' }) : webpackConfigExport;
@@ -115,8 +115,8 @@ async function watchEditorExtension(name, isInternal, quiet = false, ignoreNodeM
  * @param quiet If true, will only show errors in output
  * @param watchIgnoreNodeModules If true, while serving, will not autoreload on changes to node_modules files
  */
-async function debugEditorExtension(extensionNames, isInternal, quiet = false, pickAnyPort = false, watchIgnoreNodeModules = false) {
-    const watchers = await Promise.all(extensionNames.map(async (name) => watchEditorExtension(name, isInternal, quiet, watchIgnoreNodeModules)));
+async function debugEditorExtension(extensionNames, isInternal, packageManagerOptions, quiet = false, pickAnyPort = false, watchIgnoreNodeModules = false) {
+    const watchers = await Promise.all(extensionNames.map(async (name) => watchEditorExtension(name, isInternal, packageManagerOptions, quiet, watchIgnoreNodeModules)));
     const app = express();
     const initialPortToTry = 9900;
     // The actual port number (that the server serves from)can change, depending on anyport behavior.
@@ -307,7 +307,8 @@ async function getExtensionCodeDirectoryName(name) {
  * extensionName.
  */
 async function getExtensionCodeDirectoryNameFromCodePath(codePath) {
-    const parts = codePath.split(path.sep) ?? [];
+    const normalizedPath = (0, filesystemutil_1.getNormalizedZipPath)(codePath);
+    const parts = normalizedPath.split(path.posix.sep) ?? [];
     if (parts[0] === 'editorextensions' && parts[1]) {
         return `${parts[1]}`;
     }

package/src/filesystemutil.d.ts

@@ -1,7 +1,20 @@
+import { PackageManagerMode } from './installationutil';
+/**
+ * Returns the paths of package manager files to exclude when copying templates.
+ * @param sourceDir The source directory containing the template files
+ * @param mode Which package manager is being used
+ */
+export declare function getPackageManagerExcludePaths(sourceDir: string, mode: PackageManagerMode): string[];
 export declare function copyFileSync(source: string, target: string): void;
-export declare function copyFolderRecursiveSync(source: string, targetFolder: string): void;
 /**
- * On Windows machines '\' is used as the file separator. To ensure that we correctly zip files on Windows
- * machines we replace '\' with '/'.
+ * Copies a folder recursively, optionally excluding specified paths.
+ * @param source Source directory path
+ * @param targetFolder Target directory path
+ * @param excludePaths Array of paths to exclude (will be resolved to absolute paths)
+ */
+export declare function copyFolderRecursiveSync(source: string, targetFolder: string, excludePaths?: string[]): void;
+/**
+ * On Windows machines '\' is used as the file separator. To ensure that we correctly zip files
+ * and handle manifests generated on Windows, we always replace '\' with '/'.
  */
 export declare function getNormalizedZipPath(rawPath: string): string;

package/src/filesystemutil.js

@@ -1,10 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageManagerExcludePaths = getPackageManagerExcludePaths;
 exports.copyFileSync = copyFileSync;
 exports.copyFolderRecursiveSync = copyFolderRecursiveSync;
 exports.getNormalizedZipPath = getNormalizedZipPath;
 const fs = require("fs");
 const path = require("path");
+const installationutil_1 = require("./installationutil");
+/**
+ * Returns the paths of package manager files to exclude when copying templates.
+ * @param sourceDir The source directory containing the template files
+ * @param mode Which package manager is being used
+ */
+function getPackageManagerExcludePaths(sourceDir, mode) {
+    if (mode === installationutil_1.PackageManagerMode.Pnpm) {
+        return [path.join(sourceDir, 'package-lock.json')];
+    }
+    else {
+        // npm mode
+        return [path.join(sourceDir, 'pnpm-lock.yaml'), path.join(sourceDir, 'pnpm-workspace.yaml')];
+    }
+}
 function copyFileSync(source, target) {
     var targetFile = target;
     // If target is a directory, a new file with the same name will be created
@@ -15,19 +31,24 @@ function copyFileSync(source, target) {
     }
     fs.writeFileSync(targetFile, fs.readFileSync(source));
 }
-function copyFolderRecursiveSync(source, targetFolder) {
-    var files = [];
+/**
+ * Internal implementation that uses a pre-resolved Set of exclude paths.
+ */
+function copyFolderRecursiveSyncImpl(source, targetFolder, excludePaths) {
     // Check if folder needs to be created or integrated
     if (!fs.existsSync(targetFolder)) {
         fs.mkdirSync(targetFolder, { recursive: true });
     }
     // Copy
     if (fs.lstatSync(source).isDirectory()) {
-        files = fs.readdirSync(source);
+        const files = fs.readdirSync(source);
         files.forEach((file) => {
-            var curSource = path.join(source, file);
+            const curSource = path.join(source, file);
+            if (excludePaths.has(fs.realpathSync(curSource))) {
+                return;
+            }
             if (fs.lstatSync(curSource).isDirectory()) {
-                copyFolderRecursiveSync(curSource, path.join(targetFolder, file));
+                copyFolderRecursiveSyncImpl(curSource, path.join(targetFolder, file), excludePaths);
             }
             else {
                 copyFileSync(curSource, targetFolder);
@@ -36,9 +57,20 @@ function copyFolderRecursiveSync(source, targetFolder) {
     }
 }
 /**
- * On Windows machines '\' is used as the file separator. To ensure that we correctly zip files on Windows
- * machines we replace '\' with '/'.
+ * Copies a folder recursively, optionally excluding specified paths.
+ * @param source Source directory path
+ * @param targetFolder Target directory path
+ * @param excludePaths Array of paths to exclude (will be resolved to absolute paths)
+ */
+function copyFolderRecursiveSync(source, targetFolder, excludePaths = []) {
+    // Resolve all exclude paths once upfront, filtering out paths that don't exist
+    const resolvedExcludes = new Set(excludePaths.filter((p) => fs.existsSync(p)).map((p) => fs.realpathSync(p)));
+    copyFolderRecursiveSyncImpl(source, targetFolder, resolvedExcludes);
+}
+/**
+ * On Windows machines '\' is used as the file separator. To ensure that we correctly zip files
+ * and handle manifests generated on Windows, we always replace '\' with '/'.
  */
 function getNormalizedZipPath(rawPath) {
-    return path.sep === '\\' ? rawPath.replace(/\\/g, '/') : rawPath;
+    return rawPath.replace(/\\/g, '/');
 }

package/src/index.js

@@ -6,6 +6,7 @@ const angularframeworkutils_1 = require("./angularframeworkutils");
 const dataconnector_1 = require("./dataconnector");
 const editorextension_1 = require("./editorextension");
 const interactive = require("./interactibilityutil");
+const installationutil_1 = require("./installationutil");
 const package_1 = require("./package");
 const reactframeworkutils_1 = require("./reactframeworkutils");
 const shapelibrary_1 = require("./shapelibrary");
@@ -28,6 +29,17 @@ class LucidSuiteExtensionCLI {
             type: 'str',
             help: argparse_1.SUPPRESS,
         });
+        parser.add_argument('--mode', {
+            type: 'str',
+            choices: ['pnpm', 'npm'],
+            default: 'npm',
+            help: 'Package manager to use (default: npm)',
+        });
+        parser.add_argument('--package-manager-path', {
+            type: 'str',
+            metavar: 'PATH',
+            help: 'Explicit path to the package manager binary. If not provided, assumes the package manager is available on the PATH.',
+        });
         const subparsers = parser.add_subparsers({ dest: 'command' });
         const createParser = subparsers.add_parser('create', {
             help: 'Create a new Lucid extension package in a new directory',
@@ -148,6 +160,23 @@ class LucidSuiteExtensionCLI {
             // If we've spawned a child process recursively calling a new lucid-package target,
             // as long as it's originally triggered by Bazel then we're still using Bazel flows.
             process.env['BAZEL_TARGET'];
+        // Convert mode string to enum
+        let mode;
+        if (parsed['mode'] === 'pnpm') {
+            mode = installationutil_1.PackageManagerMode.Pnpm;
+        }
+        else if (parsed['mode'] === 'npm') {
+            mode = installationutil_1.PackageManagerMode.Npm;
+        }
+        else {
+            throw new Error(`Unknown package manager mode: ${parsed['mode']}`);
+        }
+        // If --package-manager-path is set, use it as the package manager command.
+        // Otherwise, use the mode string (pnpm or npm) and assume it's available on the PATH.
+        const packageManagerOptions = {
+            mode,
+            packageManagerPath: parsed['package_manager_path'] ?? parsed['mode'],
+        };
         let isChdir = !!parsed['chdir'];
         if (isChdir) {
             if (parsed['project']) {
@@ -165,7 +194,7 @@ class LucidSuiteExtensionCLI {
                 if (parsed['name'] == null) {
                     parsed['name'] = await interactive.inputPrompt('Please enter the name of the Lucid Package');
                 }
-                await (0, package_1.createEmptyPackage)(parsed['name']);
+                await (0, package_1.createEmptyPackage)(parsed['name'], packageManagerOptions);
                 const options = ['Editor Extension', 'Shape Library', 'Data Connector'];
                 const choices = await interactive.multiSelect('Select components to add to package (can select none or more than one)', options);
                 const packagePath = path.join(process.cwd(), parsed['name']);
@@ -180,17 +209,17 @@ class LucidSuiteExtensionCLI {
                                 const choice = await interactive.selectPrompt('Please select a framework', options);
                                 switch (choice) {
                                     case 0:
-                                        await (0, angularframeworkutils_1.createAngularEditorExtension)(editorExtensionName, isInternal, false);
+                                        await (0, angularframeworkutils_1.createAngularEditorExtension)(editorExtensionName, isInternal, packageManagerOptions, false);
                                         break;
                                     case 1:
                                         const options = ['Javascript', 'Typescript'];
                                         const choice = await interactive.selectPrompt('Please select flavor', options);
-                                        await (0, reactframeworkutils_1.createReactEditorExtension)(editorExtensionName, options[choice], isInternal, false);
+                                        await (0, reactframeworkutils_1.createReactEditorExtension)(editorExtensionName, options[choice], isInternal, packageManagerOptions, false);
                                         break;
                                 }
                             }
                             else {
-                                await (0, editorextension_1.createEditorExtension)(editorExtensionName, isInternal, false);
+                                await (0, editorextension_1.createEditorExtension)(editorExtensionName, isInternal, packageManagerOptions, false);
                             }
                             break;
                         case 1:
@@ -201,7 +230,7 @@ class LucidSuiteExtensionCLI {
                         case 2:
                             process.chdir(packagePath);
                             const dataConnectorName = await interactive.inputPrompt('Please enter the name of the data connector');
-                            await (0, dataconnector_1.createDataConnector)(dataConnectorName, isInternal, false);
+                            await (0, dataconnector_1.createDataConnector)(dataConnectorName, isInternal, packageManagerOptions, false);
                             break;
                     }
                 }
@@ -214,16 +243,16 @@ class LucidSuiteExtensionCLI {
                 else {
                     switch (parsed['command']) {
                         case 'bundle':
-                            await (0, package_1.writePackage)(parsed['quiet'], parsed['env'], parsed['skip_sdk']);
+                            await (0, package_1.writePackage)(packageManagerOptions, parsed['quiet'], parsed['env'], parsed['skip_sdk']);
                             break;
                         case 'update-sdk':
-                            await (0, package_1.updateAllExtensionSDK)();
+                            await (0, package_1.updateAllExtensionSDK)(packageManagerOptions);
                             break;
                         case 'create-editor-extension':
-                            await (0, editorextension_1.createEditorExtension)(parsed['name'], isInternal, parsed['skip_sdk']);
+                            await (0, editorextension_1.createEditorExtension)(parsed['name'], isInternal, packageManagerOptions, parsed['skip_sdk']);
                             break;
                         case 'build-editor-extension':
-                            await (0, editorextension_1.buildEditorExtension)(parsed['name'], isInternal, parsed['quiet'], parsed['skip_sdk']);
+                            await (0, editorextension_1.buildEditorExtension)(parsed['name'], isInternal, packageManagerOptions, parsed['quiet'], parsed['skip_sdk']);
                             break;
                         case 'create-shape-library':
                             await (0, shapelibrary_1.createEmptyShapeLibrary)(parsed['name']);
@@ -239,7 +268,7 @@ class LucidSuiteExtensionCLI {
                             await (0, shapelibrary_1.createImageShapeLibrary)(parsed['name'], parsed['path'], config);
                             break;
                         case 'create-data-connector':
-                            await (0, dataconnector_1.createDataConnector)(parsed['name'], isInternal, parsed['skip_sdk']);
+                            await (0, dataconnector_1.createDataConnector)(parsed['name'], isInternal, packageManagerOptions, parsed['skip_sdk']);
                             break;
                         case 'test-shape-libraries':
                             await (0, shapelibrary_1.debugShapeLibraries)();
@@ -248,10 +277,10 @@ class LucidSuiteExtensionCLI {
                             if (parsed['name'].length === 0) {
                                 parsed['name'] = await (0, editorextension_1.getAllExtensionNames)();
                             }
-                            await (0, editorextension_1.debugEditorExtension)(parsed['name'], isInternal, parsed['quiet'], parsed['anyport'], parsed['watch_ignore_node_modules']);
+                            await (0, editorextension_1.debugEditorExtension)(parsed['name'], isInternal, packageManagerOptions, parsed['quiet'], parsed['anyport'], parsed['watch_ignore_node_modules']);
                             break;
                         case 'watch-editor-extension':
-                            await (0, editorextension_1.watchEditorExtension)(parsed['name'], isInternal, parsed['quiet']);
+                            await (0, editorextension_1.watchEditorExtension)(parsed['name'], isInternal, packageManagerOptions, parsed['quiet']);
                             break;
                         default:
                             parser.print_help();

package/src/installationutil.d.ts

@@ -1,3 +1,16 @@
-export declare function installDependenciesIfNeeded(isInternal: boolean, skipSDKDependency?: boolean, additionalDependencies?: string[]): void;
-export declare function installReactProject(reactProjectName: string, typescript: boolean): void;
-export declare function installAngularProject(angularProjectName: string): void;
+export declare enum PackageManagerMode {
+    Pnpm = "pnpm",
+    Npm = "npm"
+}
+export interface PackageManagerOptions {
+    /** Which package manager to use. */
+    mode: PackageManagerMode;
+    /**
+     * Path to the package manager binary. If a path is not provided, the package manager is assumed to be on the PATH,
+     * , i.e., this is set to "pnpm" or "npm" and that command is assumed to be available on the PATH.
+     */
+    packageManagerPath: string;
+}
+export declare function installDependenciesIfNeeded(isInternal: boolean, packageManagerOptions: PackageManagerOptions, skipSDKDependency?: boolean, additionalDependencies?: string[]): void;
+export declare function installReactProject(reactProjectName: string, typescript: boolean, packageManagerOptions: PackageManagerOptions): void;
+export declare function installAngularProject(angularProjectName: string, packageManagerOptions: PackageManagerOptions): void;

package/src/installationutil.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.PackageManagerMode = void 0;
 exports.installDependenciesIfNeeded = installDependenciesIfNeeded;
 exports.installReactProject = installReactProject;
 exports.installAngularProject = installAngularProject;
@@ -7,9 +8,33 @@ const oldFs = require("fs");
 const path = require("path");
 const shellutil_1 = require("./shellutil");
 const theme_1 = require("./theme");
-function installDependenciesIfNeeded(isInternal, skipSDKDependency = false, additionalDependencies = []) {
+var PackageManagerMode;
+(function (PackageManagerMode) {
+    PackageManagerMode["Pnpm"] = "pnpm";
+    PackageManagerMode["Npm"] = "npm";
+})(PackageManagerMode || (exports.PackageManagerMode = PackageManagerMode = {}));
+/**
+ * Get the install command for installing dependencies from a lockfile.
+ */
+function getInstallCommand(options) {
+    if (options.mode === PackageManagerMode.Pnpm) {
+        return `"${options.packageManagerPath}" --silent install --frozen-lockfile`;
+    }
+    else {
+        // npm mode
+        return `"${options.packageManagerPath}" --silent ci`;
+    }
+}
+/**
+ * Get the command for adding a package as a dependency.
+ */
+function getAddCommand(options, packages, silent = false) {
+    const silentFlag = silent ? '--silent' : '';
+    return `"${options.packageManagerPath}" ${silentFlag} add ${packages.join(' ')}`;
+}
+function installDependenciesIfNeeded(isInternal, packageManagerOptions, skipSDKDependency = false, additionalDependencies = []) {
     if (!oldFs.existsSync('node_modules')) {
-        console.log((0, shellutil_1.execSyncLoggingOutputOnError)('npm ci --silent').toString());
+        console.log((0, shellutil_1.execSyncLoggingOutputOnError)(getInstallCommand(packageManagerOptions)).toString());
     }
     const sdkDir = path.join('node_modules', 'lucid-extension-sdk');
     if (isInternal) {
@@ -20,15 +45,16 @@ function installDependenciesIfNeeded(isInternal, skipSDKDependency = false, addi
         // Otherwise, install the NPM version of the SDK directly. If you would like to opt out of this you can use the
         // `--skip-sdk` CLI flag.
         console.log((0, theme_1.success)('Adding dependency on SDK'));
-        console.log((0, shellutil_1.execSyncLoggingOutputOnError)('npm install --save lucid-extension-sdk').toString());
+        console.log((0, shellutil_1.execSyncLoggingOutputOnError)(getAddCommand(packageManagerOptions, ['lucid-extension-sdk'])).toString());
     }
     if (additionalDependencies.length) {
-        console.log((0, shellutil_1.execSyncLoggingOutputOnError)(`npm install --silent ${additionalDependencies.reduce((acc, current) => `${acc} ${current}`, '')}`).toString());
+        console.log((0, shellutil_1.execSyncLoggingOutputOnError)(getAddCommand(packageManagerOptions, additionalDependencies, true)).toString());
     }
 }
-function installReactProject(reactProjectName, typescript) {
-    console.log((0, shellutil_1.execSyncLoggingOutputOnError)(`npm install create-react-app && npx create-react-app ${reactProjectName} ${typescript ? '--template typescript' : ''}`).toString());
+function installReactProject(reactProjectName, typescript, packageManagerOptions) {
+    const templateArg = typescript ? '--template typescript' : '';
+    console.log((0, shellutil_1.execSyncLoggingOutputOnError)(`"${packageManagerOptions.packageManagerPath}" add create-react-app && "${packageManagerOptions.packageManagerPath}" exec -- create-react-app ${reactProjectName} ${templateArg}`).toString());
 }
-function installAngularProject(angularProjectName) {
-    console.log((0, shellutil_1.execSyncLoggingOutputOnError)(`npm install @angular/cli && npx ng new ${angularProjectName}`).toString());
+function installAngularProject(angularProjectName, packageManagerOptions) {
+    console.log((0, shellutil_1.execSyncLoggingOutputOnError)(`"${packageManagerOptions.packageManagerPath}" add @angular/cli && "${packageManagerOptions.packageManagerPath}" exec -- ng new ${angularProjectName}`).toString());
 }

package/src/package.d.ts

@@ -1,11 +1,13 @@
+import { PackageManagerOptions } from './installationutil';
 import { PackageManifest } from './packagemanifest';
-export declare function createEmptyPackage(root: string): Promise<void>;
+export declare function createEmptyPackage(root: string, packageManagerOptions: PackageManagerOptions): Promise<void>;
 export declare function currentlyInPackage(): boolean;
 export declare function readJson(path: string): Promise<any>;
 export declare function modifyManifest(callback: (manifest: PackageManifest) => void | Promise<void>, manifestOverrideEnv?: string): Promise<void>;
-export declare function updateAllExtensionSDK(): Promise<void>;
+export declare function updateAllExtensionSDK(packageManagerOptions: PackageManagerOptions): Promise<void>;
 /**
  *
+ * @param packageManagerOptions Options for which package manager to use (npm or pnpm)
  * @param manifestOverrideEnv The environment definine what manifest to read from. `manifest.env.json`
  */
-export declare function writePackage(quiet?: boolean, manifestOverrideEnv?: string, skipSdkDependency?: boolean): Promise<void>;
+export declare function writePackage(packageManagerOptions: PackageManagerOptions, quiet?: boolean, manifestOverrideEnv?: string, skipSdkDependency?: boolean): Promise<void>;

package/src/package.js

@@ -13,15 +13,23 @@ const lucid_extension_sdk_1 = require("lucid-extension-sdk");
 const path = require("path");
 const editorextension_1 = require("./editorextension");
 const filesystemutil_1 = require("./filesystemutil");
+const installationutil_1 = require("./installationutil");
 const packagemanifest_1 = require("./packagemanifest");
 const shapelibrary_1 = require("./shapelibrary");
 const shellutil_1 = require("./shellutil");
 const theme_1 = require("./theme");
 const ziputil_1 = require("./ziputil");
-async function createEmptyPackage(root) {
+async function createEmptyPackage(root, packageManagerOptions) {
     console.log((0, theme_1.success)('Creating Lucid Suite package in ' + root));
     const source = path.join(__dirname, '..', 'templates', 'package');
-    (0, filesystemutil_1.copyFolderRecursiveSync)(source, root);
+    (0, filesystemutil_1.copyFolderRecursiveSync)(source, root, (0, filesystemutil_1.getPackageManagerExcludePaths)(source, packageManagerOptions.mode));
+    // For npm mode, modify package.json to use npm exec instead of pnpm dlx
+    if (packageManagerOptions.mode === installationutil_1.PackageManagerMode.Npm) {
+        const packageJsonPath = path.join(root, 'package.json');
+        let content = fsOld.readFileSync(packageJsonPath, 'utf8');
+        content = content.replace(/pnpm dlx/g, 'npm exec --');
+        fsOld.writeFileSync(packageJsonPath, content);
+    }
 }
 function currentlyInPackage() {
     return ((fsOld.existsSync('editorextensions') || fsOld.existsSync('shapelibraries')) &&
@@ -47,20 +55,22 @@ async function modifyManifest(callback, manifestOverrideEnv) {
     await callback(manifest);
     await fs.writeFile('manifest.json', JSON.stringify(manifest, undefined, 2));
 }
-async function updateAllExtensionSDK() {
+async function updateAllExtensionSDK(packageManagerOptions) {
     const manifest = await (0, packagemanifest_1.readManifest)();
     for (const extension of manifest['extensions'] || []) {
-        const parts = extension['codePath'].split(path.sep);
+        const codePath = (0, filesystemutil_1.getNormalizedZipPath)(extension['codePath']);
+        const parts = codePath.split(path.posix.sep);
         if (parts[0] === 'editorextensions') {
-            await (0, editorextension_1.updateExtensionSDK)(parts[1]);
+            await (0, editorextension_1.updateExtensionSDK)(parts[1], packageManagerOptions);
         }
     }
 }
 /**
  *
+ * @param packageManagerOptions Options for which package manager to use (npm or pnpm)
  * @param manifestOverrideEnv The environment definine what manifest to read from. `manifest.env.json`
  */
-async function writePackage(quiet = false, manifestOverrideEnv, skipSdkDependency = false) {
+async function writePackage(packageManagerOptions, quiet = false, manifestOverrideEnv, skipSdkDependency = false) {
     const zip = new JSZip();
     const quietableConsoleLog = (...data) => {
         if (!quiet) {
@@ -86,7 +96,9 @@ async function writePackage(quiet = false, manifestOverrideEnv, skipSdkDependenc
                     .join(', ')}`);
                 process.exit(1);
             }
-            const parts = extension['codePath'].split(path.sep);
+            const codePath = (0, filesystemutil_1.getNormalizedZipPath)(extension['codePath']);
+            extension['codePath'] = codePath;
+            const parts = codePath.split(path.posix.sep);
             if (parts[0] === 'editorextensions') {
                 //Can't just call the method, as the WebpackCLI class does process.exit(2) :facepalm:
                 quietableConsoleLog((0, theme_1.success)(`Compiling editor extension ${parts[1]}`));
@@ -95,7 +107,12 @@ async function writePackage(quiet = false, manifestOverrideEnv, skipSdkDependenc
                     process.argv[0] +
                     '" "' +
                     process.argv[1] +
-                    '" build-editor-extension ' +
+                    '" ' +
+                    // --mode and --package-manager-path are global args, so they need to go before
+                    // build-editor-extension (but after the script path)
+                    `--mode ${packageManagerOptions.mode} ` +
+                    `--package-manager-path "${packageManagerOptions.packageManagerPath}" ` +
+                    'build-editor-extension ' +
                     (quiet ? '--quiet ' : '') +
                     (skipSdkDependency ? '--skip-sdk ' : '') +
                     '"' +
@@ -104,16 +121,18 @@ async function writePackage(quiet = false, manifestOverrideEnv, skipSdkDependenc
                 quietableConsoleLog(cmd);
                 quietableConsoleLog((0, shellutil_1.execSyncLoggingOutputOnError)(cmd, (quiet = quiet)).toString());
             }
-            (0, ziputil_1.jsZipFileDeterministic)(zip, extension['codePath'], await fs.readFile(extension['codePath']));
+            (0, ziputil_1.jsZipFileDeterministic)(zip, codePath, await fs.readFile(codePath));
         }
         //Do the same for each shape library
         for (const library of manifest['shapeLibraries'] || []) {
-            const parts = library['lcszPath'].split(path.sep);
+            const lcszPath = (0, filesystemutil_1.getNormalizedZipPath)(library['lcszPath']);
+            library['lcszPath'] = lcszPath;
+            const parts = lcszPath.split(path.posix.sep);
             if (parts[0] === 'shapelibraries') {
                 quietableConsoleLog((0, theme_1.success)(`Building shape library ${parts[1]}`));
                 await (0, shapelibrary_1.buildShapeLibrary)(parts[1].replace('.lcsz', ''), quiet);
             }
-            (0, ziputil_1.jsZipFileDeterministic)(zip, library['lcszPath'], await fs.readFile(library['lcszPath']));
+            (0, ziputil_1.jsZipFileDeterministic)(zip, lcszPath, await fs.readFile(lcszPath));
         }
         //Add any static resources
         const checkDirForResources = async (directory, zipDirectory) => {