dazscript-framework 1.0.30 → 1.0.32

package/dist/scripts/integration.js

@@ -153,11 +153,65 @@ function run(command, args, options) {
   return result;
 }
 
+function getNpmInvocation(args, platform) {
+  const npmArgs = args || [];
+  if ((platform || process.platform) !== 'win32') {
+    return { command: 'npm', args: npmArgs };
+  }
+
+  const npmCliPath = path.join(path.dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
+  if (fs.existsSync(npmCliPath)) {
+    return { command: process.execPath, args: [npmCliPath].concat(npmArgs) };
+  }
+
+  return { command: 'npm.cmd', args: npmArgs };
+}
+
 function writeFile(filePath, content) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
+const fixtureBuildDependencies = [
+  '@babel/core',
+  '@babel/plugin-proposal-class-properties',
+  '@babel/plugin-proposal-decorators',
+  '@babel/plugin-transform-arrow-functions',
+  '@babel/plugin-transform-block-scoping',
+  '@babel/plugin-transform-class-properties',
+  '@babel/plugin-transform-private-methods',
+  '@babel/plugin-transform-private-property-in-object',
+  '@babel/preset-env',
+  '@babel/preset-typescript',
+  'babel-core',
+  'babel-loader',
+  'babel-plugin-transform-class-properties',
+  'babel-plugin-transform-typescript-metadata',
+  'glob',
+  'ts-loader',
+  'tsconfig-paths-webpack-plugin',
+  'typescript',
+  'webpack',
+];
+
+function getFixtureBuildDependencies(frameworkRoot) {
+  const frameworkPackageJson = JSON.parse(
+    fs.readFileSync(path.join(frameworkRoot, 'package.json'), 'utf8')
+  );
+  const availableDependencies = {
+    ...(frameworkPackageJson.dependencies || {}),
+    ...(frameworkPackageJson.devDependencies || {}),
+  };
+
+  return fixtureBuildDependencies.reduce((result, dependencyName) => {
+    const version = availableDependencies[dependencyName];
+    if (version) {
+      result[dependencyName] = version;
+    }
+    return result;
+  }, {});
+}
+
 function buildFixtureProject(options) {
   fs.rmSync(options.fixtureRoot, { recursive: true, force: true });
   fs.mkdirSync(path.join(options.fixtureRoot, 'src'), { recursive: true });
@@ -171,7 +225,7 @@ function buildFixtureProject(options) {
       'dazscript-framework': `file:${options.frameworkRoot}`,
       'dazscript-types': '^1.0.1',
     },
-    devDependencies: {},
+    devDependencies: getFixtureBuildDependencies(options.frameworkRoot),
   }, null, 2));
 
   writeFile(path.join(options.fixtureRoot, 'dazscript.config.ts'), [
@@ -223,8 +277,10 @@ function buildFixtureProject(options) {
   }, null, 2));
 
   fs.copyFileSync(options.fixturePath, path.join(options.fixtureRoot, 'src', `${options.fixtureName}.dsa.ts`));
-  run('npm', ['install', '--ignore-scripts'], { cwd: options.fixtureRoot });
-  run('npm', ['run', 'build'], { cwd: options.fixtureRoot });
+  const npmInstall = getNpmInvocation(['install', '--ignore-scripts']);
+  run(npmInstall.command, npmInstall.args, { cwd: options.fixtureRoot });
+  const npmBuild = getNpmInvocation(['run', 'build']);
+  run(npmBuild.command, npmBuild.args, { cwd: options.fixtureRoot });
 }
 
 function runDazFixture(options) {
@@ -296,6 +352,8 @@ async function runIntegration(rawOptions, injectedEnv, cwd) {
 module.exports = {
   loadEnvFile,
   normalizeForDaz,
+  getNpmInvocation,
+  getFixtureBuildDependencies,
   readIntegrationResult,
   resolveIntegrationOptions,
   buildFixtureProject,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dazscript-framework",
-  "version": "1.0.30",
+  "version": "1.0.32",
   "author": "Freddy Diaz",
   "license": "MPL-2.0",
   "description": "",

package/src/helpers/progress-helper.test.ts

@@ -0,0 +1,95 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const started: Array<{
+    info: string
+    totalSteps: number
+    isCancellable: boolean
+    showTimeElapsed: boolean
+}> = []
+const steps: number[] = []
+
+const installProgressGlobals = (cancelled = false): void => {
+    vi.stubGlobal('startProgress', (info: string, totalSteps: number, isCancellable: boolean, showTimeElapsed: boolean) => {
+        started.push({ info, totalSteps, isCancellable, showTimeElapsed })
+    })
+    vi.stubGlobal('stepProgress', (count = 1) => {
+        steps.push(count)
+    })
+    vi.stubGlobal('finishProgress', vi.fn())
+    vi.stubGlobal('progressIsCancelled', () => cancelled)
+    vi.stubGlobal('processEvents', vi.fn())
+}
+
+beforeEach(() => {
+    started.length = 0
+    steps.length = 0
+    vi.resetModules()
+})
+
+afterEach(() => {
+    vi.unstubAllGlobals()
+})
+
+describe('withProgress', () => {
+    it('starts progress, exposes a manual step handle, and finishes after callback returns', async () => {
+        installProgressGlobals()
+        const { withProgress } = await import('./progress-helper')
+
+        const result = withProgress('Manual Work', 4, (progress) => {
+            progress.step()
+            progress.step(2)
+            return 'done'
+        })
+
+        expect(result).toBe('done')
+        expect(started).toEqual([
+            {
+                info: 'Manual Work',
+                totalSteps: 4,
+                isCancellable: true,
+                showTimeElapsed: true,
+            },
+        ])
+        expect(steps).toEqual([1, 2])
+        expect(finishProgress).toHaveBeenCalledTimes(1)
+    })
+
+    it('finishes progress when the callback throws', async () => {
+        installProgressGlobals()
+        const { withProgress } = await import('./progress-helper')
+
+        expect(() => withProgress('Manual Work', 2, () => {
+            throw new Error('failed phase')
+        })).toThrow('failed phase')
+
+        expect(finishProgress).toHaveBeenCalledTimes(1)
+    })
+
+    it('reports cancellation consistently with cancellable progress', async () => {
+        installProgressGlobals(true)
+        const { withProgress } = await import('./progress-helper')
+
+        let callbackCancelled = false
+        withProgress('Manual Work', 2, (progress) => {
+            callbackCancelled = progress.isCancelled()
+            progress.step()
+        })
+
+        expect(callbackCancelled).toBe(true)
+        expect(processEvents).toHaveBeenCalledTimes(1)
+        expect(steps).toEqual([])
+        expect(finishProgress).toHaveBeenCalledTimes(1)
+    })
+})
+
+describe('progress', () => {
+    it('finishes progress when an item callback stops the loop', async () => {
+        installProgressGlobals()
+        const { progress } = await import('./progress-helper')
+
+        progress('Array Work', [1, 2, 3], (item: number) => item !== 2)
+
+        expect(steps).toEqual([1])
+        expect(finishProgress).toHaveBeenCalledTimes(1)
+    })
+})

package/src/helpers/progress-helper.ts

@@ -1,5 +1,29 @@
 import { status } from '@dsf/common/log';
 
+export type ProgressOptions = {
+    isCancellable?: boolean
+    showTimeElapsed?: boolean
+    totalSteps?: number
+}
+
+export type ProgressHandle = {
+    step: (count?: number) => boolean
+    isCancelled: () => boolean
+}
+
+const defaultProgressOptions = (totalSteps: number, options?: ProgressOptions): Required<ProgressOptions> => ({
+    isCancellable: true,
+    showTimeElapsed: true,
+    totalSteps,
+    ...options
+})
+
+const reportInfo = (info: string | string[]): string => {
+    const infoMessage = Array.isArray(info) ? '' : info;
+    if (Array.isArray(info)) info.forEach(line => status(line));
+    return infoMessage;
+}
+
 /**
  * Displays a progress dialog to the user if one is not already being displayed and starts a progress tracking operation.
  * @param info The string to display in the progress dialog as the current description of the operation.
@@ -10,43 +34,79 @@ import { status } from '@dsf/common/log';
  * @param totalSteps The number of progress steps for the operation to be complete.
  */
 export const progress = <T>(info: string | string[], items: T[], callback: (item: T) => boolean | void,
-    options?: { isCancellable?: boolean, showTimeElapsed?: boolean, totalSteps?: number }) => {
+    options?: ProgressOptions) => {
 
-    options = {
-        isCancellable: true,
-        showTimeElapsed: true,
-        totalSteps: items.length,
-        ...options
-    };
+    const resolvedOptions = defaultProgressOptions(items.length, options);
 
-    const infoMessage = Array.isArray(info) ? '' : info;
-    startProgress(infoMessage, options.totalSteps, options.isCancellable, options.showTimeElapsed);
+    const infoMessage = reportInfo(info);
+    startProgress(infoMessage, resolvedOptions.totalSteps, resolvedOptions.isCancellable, resolvedOptions.showTimeElapsed);
 
-    if (Array.isArray(info)) info.forEach(line => status(line));
+    try {
+        // const total = Math.max(1, options.totalSteps ?? items.length);
+        // let lastQuarter = -1; // -1 so first boundary triggers
+
+        for (let i = 0; i < items.length; i++) {
+            // cancellation
+            if (resolvedOptions.isCancellable && progressIsCancelled()) {
+                processEvents(); // flush once on cancel
+                break;
+            }
+
+            // work
+            if (callback && callback(items[i]) === false) break;
 
-    // const total = Math.max(1, options.totalSteps ?? items.length);
-    // let lastQuarter = -1; // -1 so first boundary triggers
+            // progress
+            stepProgress(1);
 
-    for (let i = 0; i < items.length; i++) {
-        // cancellation
-        if (options.isCancellable && progressIsCancelled()) {
-            processEvents(); // flush once on cancel
-            break;
+            // 25/50/75/100 checkpoints
+            // const quarter = Math.floor(((i + 1) * 2) / total); // 0..4
+            // if (quarter > lastQuarter) {
+            //     processEvents();
+            //     lastQuarter = quarter;
+            // }
         }
+    }
+    finally {
+        finishProgress();
+    }
+}
 
-        // work
-        if (callback && callback(items[i]) === false) return;
+/**
+ * Starts a progress operation for multi-phase work that does not map to a single item array.
+ * Uses script-level cleanup for normal returns and catchable script exceptions; host crashes or native aborts can still bypass script cleanup.
+ * @param info The string to display in the progress dialog as the current description of the operation.
+ * @param totalSteps The number of progress steps for the operation to be complete.
+ * @param callback The function to run with a manual progress handle.
+ * @param options Progress dialog options consistent with the array-driven progress helper.
+ */
+export const withProgress = <T>(info: string | string[], totalSteps: number, callback: (progress: ProgressHandle) => T,
+    options?: Omit<ProgressOptions, 'totalSteps'>): T => {
 
-        // progress
-        stepProgress(1);
+    const resolvedOptions = defaultProgressOptions(totalSteps, options);
+    const infoMessage = reportInfo(info);
+    startProgress(infoMessage, resolvedOptions.totalSteps, resolvedOptions.isCancellable, resolvedOptions.showTimeElapsed);
 
-        // 25/50/75/100 checkpoints
-        // const quarter = Math.floor(((i + 1) * 2) / total); // 0..4
-        // if (quarter > lastQuarter) {
-        //     processEvents();
-        //     lastQuarter = quarter;
-        // }
+    let flushedCancellation = false;
+    const handle: ProgressHandle = {
+        isCancelled: () => {
+            const cancelled = resolvedOptions.isCancellable && Boolean(progressIsCancelled());
+            if (cancelled && !flushedCancellation) {
+                processEvents();
+                flushedCancellation = true;
+            }
+            return cancelled;
+        },
+        step: (count: number = 1) => {
+            if (handle.isCancelled()) return false;
+            stepProgress(count);
+            return true;
+        }
     }
 
-    finishProgress();
-}
+    try {
+        return callback(handle);
+    }
+    finally {
+        finishProgress();
+    }
+}

package/src/scripts/integration.test.ts

@@ -5,6 +5,8 @@ import { afterEach, describe, expect, it } from 'vitest'
 
 const {
     loadEnvFile,
+    getFixtureBuildDependencies,
+    getNpmInvocation,
     readIntegrationResult,
     resolveIntegrationOptions,
 } = require('../../dist/scripts/integration')
@@ -78,6 +80,34 @@ describe('integration option resolution', () => {
     })
 })
 
+describe('integration command resolution', () => {
+    it('uses node plus npm-cli on Windows so child_process can spawn without a shell', () => {
+        const invocation = getNpmInvocation(['--version'], 'win32')
+
+        expect(invocation.command).toMatch(/node(\.exe)?$/i)
+        expect(invocation.args[0]).toMatch(/npm-cli\.js$/)
+        expect(invocation.args[1]).toBe('--version')
+    })
+
+    it('uses npm on non-Windows platforms', () => {
+        expect(getNpmInvocation(['--version'], 'linux')).toEqual({
+            command: 'npm',
+            args: ['--version']
+        })
+    })
+})
+
+describe('integration fixture build dependencies', () => {
+    it('includes webpack loader dependencies needed by generated fixture projects', () => {
+        const dependencies = getFixtureBuildDependencies(path.resolve(__dirname, '../..'))
+
+        expect(dependencies['babel-loader']).toBeTruthy()
+        expect(dependencies['ts-loader']).toBeTruthy()
+        expect(dependencies['webpack']).toBeTruthy()
+        expect(dependencies['typescript']).toBeTruthy()
+    })
+})
+
 describe('integration result reader', () => {
     it('accepts successful result JSON', () => {
         const projectDir = makeProject()