dazscript-framework 1.0.4 → 1.0.6

package/README.md

@@ -32,7 +32,7 @@ DAZ Script gives you direct access to the entire Daz Studio API. The DazScript F
 - **Fast UI development** — a fluent builder API lets you describe dialogs declaratively without touching the Qt widget API by hand.
 - **Two-way data binding** — link your data model to UI controls so they stay in sync automatically. The user types in a field and your model updates; you update the model in code and the UI reflects it instantly. No manual synchronization needed.
 - **One-command build** — `npm run build` compiles TypeScript to `.dsa` files that Daz Studio runs directly.
-- **Stable launcher shims** — built scripts use a two-level layout so iterating on your code never requires reinstalling actions in Daz Studio.
+- **Stable launcher shims** — built scripts use a launcher/implementation layout so iterating on your code never requires reinstalling actions in Daz Studio.
 - **Automated installer generation** — `npm run installer` produces a full setup dialog by reading action metadata from your source code.
 
 ---
@@ -53,7 +53,7 @@ npm install dazscript-framework dazscript-types
 npx dazscript init
 ```
 
-Follow the prompt for your AppData author namespace (e.g. `YourName/my-project`). This creates `dazscript.config.ts`, `tsconfig.json`, and wires the `build`, `watch`, `icons`, and `installer` scripts into `package.json`.
+Follow the prompt for your AppData author namespace (e.g. `YourName/my-project`). This creates `dazscript.config.ts`, `tsconfig.json`, and wires the `build`, `build:encrypted`, `build:release`, `watch`, `encrypt`, `icons`, and `installer` scripts into `package.json`.
 
 ### 3. Write the script
 
@@ -159,7 +159,8 @@ If `--app-data-path` is not provided, `init` prompts for the AppData author name
 This generates:
 - `dazscript.config.ts`
 - `tsconfig.json`
-- `package.json` script wiring for `build`, `watch`, `icons`, and `installer`
+- `package.json` script wiring for `build`, `build:encrypted`, `watch`, `encrypt`, `icons`, and `installer`
+- `build:release` uses `--log-level warn` before encryption so release packages suppress debug and trace output
 
 Available `init` flags:
 
@@ -174,6 +175,8 @@ npx dazscript init --menu-path /MyScripts --scripts-path ./src --out-dir ./out -
 | `--out-dir` | Where `build` writes `.dsa` files and copies icons |
 | `--app-data-path` | AppData namespace for launcher fallback (`Author/Product` format) |
 
+Builds also accept `--log-level <trace|debug|info|warn|error|off>`. This sets the minimum runtime log level for the compiled scripts. Use `debug` or `trace` during development and `warn` for release packages.
+
 Use `--scripts-path ./src/scripts` when runnable files live under a subfolder; use `--scripts-path ./src` when they are at the source root.
 
 ---
@@ -244,7 +247,7 @@ action({ text: 'My Script' }, MyScript);
 Each built action produces two files:
 
 - `out/<script>.dsa` — the stable **launcher** registered with Daz Studio (menus, toolbars, shortcuts)
-- `out/<folder>/lib/<script-name>/script.dsa` — the **implementation bundle** the launcher executes
+- `out/<folder>/lib/<script-name>/<script-name>.dsa` — the **implementation bundle** the launcher executes
 
 When you rebuild, only the implementation bundle changes. The launcher path stays stable, so re-registering the action in Daz Studio is normally not required.
 
@@ -256,7 +259,9 @@ To encrypt implementation bundles before packaging, run the build and then call
 npx dazscript encrypt --out-dir ./out --daz-studio "C:/Program Files/DAZ 3D/DAZStudio4/DAZStudio.exe"
 ```
 
-The `encrypt` command launches Daz Studio with `-headless -noPrompt`, converts each `out/**/lib/**/script.dsa` to `script.dse`, and deletes the source `script.dsa` after the matching encrypted file is written. Add `--keep-source` to leave the plain implementation bundles in place.
+The `encrypt` command launches Daz Studio with `-headless -noPrompt`, converts each implementation bundle under `out/**/lib/**/*.dsa` to a matching `.dse` file, and deletes the source `.dsa` after the matching encrypted file is written. Add `--keep-source` to leave the plain implementation bundles in place.
+
+Individual script packages can wrap this command in `package.json` scripts such as `npm run encrypt` or `npm run build:encrypted` so release packaging does not depend on remembering the full Daz Studio executable argument.
 
 ---
 
@@ -515,6 +520,7 @@ Files ending in `.dsa.ts` are treated as runnable entry points and compiled to `
 | Command | What it does |
 |---|---|
 | `npm run build` | Compile TypeScript → Daz Script |
+| `npm run build:release` | Build with `--log-level warn`, then encrypt implementation bundles |
 | `npm run watch` | Recompile on every save |
 | `npm run installer` | Generate the setup dialog |
 | `npm run icons` | Copy icon assets to the output folder |

package/dist/scripts/build.js

@@ -8,6 +8,7 @@ function runWebpack(workdir, options) {
   const env = {
     context: workdir,
     outputPath: options.outDir || './out',
+    logLevel: options.logLevel || '',
   };
 
   if (options.file) {

package/dist/scripts/cli.js

@@ -26,6 +26,7 @@ Options:
   --scripts-path <path> Source directory to scan. Default: ./src
   --out-dir <path>      Build output directory. Default: ./out
   --app-data-path <path> AppData namespace used by launcher fallbacks. Example: Author/Product
+  --log-level <level>   Minimum runtime log level: trace, debug, info, warn, error, off
   --daz-studio <path>   Daz Studio executable for encrypt
   --keep-source         Keep source script.dsa files after encrypting
   --timeout-ms <value>  Daz Studio encrypt timeout. Default: 300000
@@ -115,6 +116,12 @@ function parseOptions(args, defaults) {
       continue;
     }
 
+    if (arg === '--log-level') {
+      options.logLevel = args[index + 1];
+      index += 1;
+      continue;
+    }
+
     if (arg === '--daz-studio') {
       options.dazStudio = args[index + 1];
       index += 1;
@@ -179,6 +186,7 @@ async function main(argv) {
     scriptsPath: undefined,
     outDir: undefined,
     appDataPath: undefined,
+    logLevel: undefined,
     file: undefined,
     dazStudio: undefined,
     keepSource: false,

package/dist/scripts/encrypt.js

@@ -27,8 +27,7 @@ function findImplementationScripts(dir) {
 
       if (
         entry.isFile() &&
-        entry.name === 'script.dsa' &&
-        path.basename(path.dirname(entryPath)) !== 'lib' &&
+        entry.name.endsWith('.dsa') &&
         entryPath.split(path.sep).includes('lib')
       ) {
         scripts.push(entryPath);

package/dist/scripts/init.js

@@ -93,8 +93,11 @@ function updatePackageJson(workdir, options) {
     ...(packageJson.scripts || {}),
     prebuild: 'npm run installer',
     build: 'dazscript build',
+    'build:encrypted': 'npm run build && npm run encrypt',
+    'build:release': 'npm run build -- --log-level warn && npm run encrypt',
     postbuild: 'npm run icons',
     watch: 'dazscript watch',
+    encrypt: 'dazscript encrypt --out-dir ./out --daz-studio "C:\\Program Files\\DAZ 3D\\DAZStudio4\\DAZStudio.exe"',
     icons: 'dazscript icons',
     installer: 'dazscript installer',
   };

package/dist/scripts/launchers.js

@@ -23,6 +23,26 @@ function getImplementationRelativePath(outputRelativePath, extension = 'dsa') {
     ? path.posix.join('lib', outputBaseName)
     : path.posix.join(outputDirectory, 'lib', outputBaseName);
 
+  return path.posix.join(implementationDirectory, `${outputBaseName}.${extension}`);
+}
+
+function getFlatImplementationRelativePath(outputRelativePath, extension = 'dsa') {
+  const outputDirectory = path.posix.dirname(outputRelativePath);
+  const outputBaseName = path.posix.basename(outputRelativePath, '.dsa');
+  const implementationDirectory = outputDirectory === '.'
+    ? 'lib'
+    : path.posix.join(outputDirectory, 'lib');
+
+  return path.posix.join(implementationDirectory, `${outputBaseName}.${extension}`);
+}
+
+function getLegacyImplementationRelativePath(outputRelativePath, extension = 'dsa') {
+  const outputDirectory = path.posix.dirname(outputRelativePath);
+  const outputBaseName = path.posix.basename(outputRelativePath, '.dsa');
+  const implementationDirectory = outputDirectory === '.'
+    ? path.posix.join('lib', outputBaseName)
+    : path.posix.join(outputDirectory, 'lib', outputBaseName);
+
   return path.posix.join(implementationDirectory, `script.${extension}`);
 }
 
@@ -89,6 +109,14 @@ function ensureParentDir(filePath) {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
 }
 
+function removeEmptyDir(dirPath) {
+  try {
+    fs.rmdirSync(dirPath);
+  } catch (_err) {
+    // Directory is missing or still contains user/generated files.
+  }
+}
+
 function createActionLaunchers(workdir, options) {
   const outDir = path.resolve(workdir, options.outDir || './out');
   const appDataPath = validateAppDataPath(options.appDataPath, workdir);
@@ -105,11 +133,34 @@ function createActionLaunchers(workdir, options) {
       outDir,
       getImplementationRelativePath(outputRelativePath, 'dse')
     );
+    const legacyImplementationPath = path.join(
+      outDir,
+      getLegacyImplementationRelativePath(outputRelativePath)
+    );
+    const legacyEncryptedImplementationPath = path.join(
+      outDir,
+      getLegacyImplementationRelativePath(outputRelativePath, 'dse')
+    );
+    const flatImplementationPath = path.join(
+      outDir,
+      getFlatImplementationRelativePath(outputRelativePath)
+    );
+    const flatEncryptedImplementationPath = path.join(
+      outDir,
+      getFlatImplementationRelativePath(outputRelativePath, 'dse')
+    );
 
     if (!fs.existsSync(launcherPath)) {
       return;
     }
 
+    if (path.resolve(launcherPath) === path.resolve(implementationPath)) {
+      throw new Error(
+        `[dazscript] Launcher path collides with implementation path: ${implementationRelativePath}. ` +
+        `Move the source action out of a lib/ folder or use a different script name.`
+      );
+    }
+
     ensureParentDir(implementationPath);
     if (fs.existsSync(implementationPath)) {
       fs.unlinkSync(implementationPath);
@@ -117,6 +168,21 @@ function createActionLaunchers(workdir, options) {
     if (fs.existsSync(encryptedImplementationPath)) {
       fs.unlinkSync(encryptedImplementationPath);
     }
+    if (fs.existsSync(legacyImplementationPath)) {
+      fs.unlinkSync(legacyImplementationPath);
+    }
+    if (fs.existsSync(legacyEncryptedImplementationPath)) {
+      fs.unlinkSync(legacyEncryptedImplementationPath);
+    }
+    if (fs.existsSync(flatImplementationPath)) {
+      fs.unlinkSync(flatImplementationPath);
+    }
+    if (fs.existsSync(flatEncryptedImplementationPath)) {
+      fs.unlinkSync(flatEncryptedImplementationPath);
+    }
+    if (path.resolve(path.dirname(legacyImplementationPath)) !== path.resolve(path.dirname(implementationPath))) {
+      removeEmptyDir(path.dirname(legacyImplementationPath));
+    }
 
     fs.renameSync(launcherPath, implementationPath);
 

package/package.json

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

package/src/common/log.test.ts

@@ -0,0 +1,45 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { debug, error, getLogLevel, info, setLogLevel, shouldLog, trace, warn } from './log'
+
+describe('log levels', () => {
+    beforeEach(() => {
+        ;(globalThis as any).App = {
+            debug: vi.fn(),
+            log: vi.fn(),
+            warning: vi.fn(),
+            flushLogBuffer: vi.fn(),
+            statusLine: vi.fn()
+        }
+        setLogLevel('debug')
+    })
+
+    it('filters messages below the active level', () => {
+        setLogLevel('warn')
+
+        debug('hidden debug')
+        info('hidden info')
+        warn('visible warn')
+        error('visible error')
+
+        expect((globalThis as any).App.debug).not.toHaveBeenCalled()
+        expect((globalThis as any).App.log).not.toHaveBeenCalled()
+        expect((globalThis as any).App.warning).toHaveBeenCalledTimes(2)
+    })
+
+    it('allows trace only when active level is trace', () => {
+        setLogLevel('debug')
+        trace('hidden trace')
+
+        setLogLevel('trace')
+        trace('visible trace')
+
+        expect((globalThis as any).App.debug).toHaveBeenCalledTimes(1)
+    })
+
+    it('normalizes invalid levels to debug', () => {
+        setLogLevel('not-a-level')
+
+        expect(getLogLevel()).toBe('debug')
+        expect(shouldLog('debug')).toBe(true)
+    })
+})

package/src/common/log.ts

@@ -1,32 +1,73 @@
-import * as global from '@dsf/core/global'
+export type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'off'
+
+declare const __DAZSCRIPT_LOG_LEVEL__: string | undefined
+
+const logLevels: LogLevel[] = ['trace', 'debug', 'info', 'warn', 'error', 'off']
+const logLevelWeights: { [key in LogLevel]: number } = {
+    trace: 0,
+    debug: 1,
+    info: 2,
+    warn: 3,
+    error: 4,
+    off: 5
+}
+
+let currentLogLevel: LogLevel = normalizeLogLevel(
+    typeof __DAZSCRIPT_LOG_LEVEL__ === 'string'
+        ? __DAZSCRIPT_LOG_LEVEL__
+        : 'debug'
+)
+
+export const setLogLevel = (level: string): LogLevel => {
+    currentLogLevel = normalizeLogLevel(level)
+    return currentLogLevel
+}
+
+export const getLogLevel = (): LogLevel => currentLogLevel
+
+export function normalizeLogLevel(level: string): LogLevel {
+    if (!level) return 'debug'
+    const normalized = level.toLowerCase() as LogLevel
+    return logLevels.indexOf(normalized) >= 0 ? normalized : 'debug'
+}
+
+export const shouldLog = (level: LogLevel): boolean => {
+    return logLevelWeights[level] >= logLevelWeights[currentLogLevel]
+        && currentLogLevel !== 'off'
+}
 
 export const debug = (message: any) => {
-    App.debug(format(message))
-    App.flushLogBuffer()
+    if (!shouldLog('debug')) return
+    app().debug(format(message))
+    flush()
 }
 
 export const info = (message: any) => {
-    global.app.log(format(message))
-    App.flushLogBuffer()
+    if (!shouldLog('info')) return
+    app().log(format(message))
+    flush()
 }
 
 export const error = (message: any) => {
-    App.warning(format(message, "ERROR"))
-    App.flushLogBuffer()
+    if (!shouldLog('error')) return
+    app().warning(format(message, "ERROR"))
+    flush()
 }
 
 export const warn = (message: any) => {
-    App.warning(message)
-    App.flushLogBuffer()
+    if (!shouldLog('warn')) return
+    app().warning(message)
+    flush()
 }
 
 export const trace = (message: any) => {
-    App.debug(format(message, "TRACE"))
-    App.flushLogBuffer()
+    if (!shouldLog('trace')) return
+    app().debug(format(message, "TRACE"))
+    flush()
 }
 
 export const status = (message: any, log: boolean = true) => {
-    App.statusLine(message, log)
+    app().statusLine(message, log)
 }
 
 /**
@@ -39,8 +80,9 @@ export const raise = (err: string) => {
 }
 
 export const dump = (obj: any) => {
-    App.debug(`[DUMP]\r\n${JSON.stringify(obj, null, 2)}`)
-    App.flushLogBuffer()
+    if (!shouldLog('debug')) return
+    app().debug(`[DUMP]\r\n${JSON.stringify(obj, null, 2)}`)
+    flush()
 }
 
 const format = (message: string, level?: 'ERROR' | 'TRACE' | 'DUMP' | 'INFO') => {
@@ -54,3 +96,9 @@ const format = (message: string, level?: 'ERROR' | 'TRACE' | 'DUMP' | 'INFO') =>
     return text
 }
 
+const app = (): any => App
+
+const flush = () => {
+    app().flushLogBuffer()
+}
+

package/webpack.config.js

@@ -1,5 +1,6 @@
 const path = require('path');
 const glob = require('glob');
+const webpack = require('webpack');
 const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
 const { createActionLaunchers } = require('./dist/scripts/launchers');
 const { validateAppDataPath } = require('./dist/scripts/app-data-path');
@@ -29,6 +30,7 @@ module.exports = (env, argv) => {
     (env && env.appDataPath) || projectConfig.appDataPath,
     projectRoot
   );
+  const logLevel = (env && env.logLevel) || '';
   const sourceRoot = path.resolve(projectRoot, 'src');
   const projectNodeModules = path.resolve(projectRoot, 'node_modules');
   const frameworkSourceRoot = path.resolve(
@@ -120,6 +122,9 @@ module.exports = (env, argv) => {
       },
     },
     plugins: [
+      new webpack.DefinePlugin({
+        __DAZSCRIPT_LOG_LEVEL__: JSON.stringify(logLevel),
+      }),
       new ActionLauncherPlugin({
         workdir: projectRoot,
         outDir: outputPath,