dazscript-framework 1.0.2 → 1.0.4

package/README.md

@@ -2,6 +2,28 @@
 
 **DazScript Framework** is a TypeScript toolkit for writing [Daz Studio](https://www.daz3d.com/daz-studio) scripts. It layers a full TypeScript development experience on top of [DAZ Script](https://docs.daz3d.com/public/software/dazstudio/4/referenceguide/scripting/start) (Qt Script / ECMAScript 5.1), and ships a fluent dialog builder so you can build UIs in code without touching the Qt widget API directly.
 
+## Table of Contents
+
+- [Why use it?](#why-use-it)
+- [Quick Start: Hello World](#quick-start-hello-world)
+- [Quick Start: A Simple Dialog](#quick-start-a-simple-dialog)
+- [Documentation](#documentation)
+  - [Installation & Setup](#installation--setup)
+  - [Project Configuration](#project-configuration)
+  - [The `action(...)` Entrypoint](#the-action-entrypoint)
+  - [Build Output: Launcher Shims](#build-output-launcher-shims)
+  - [Generated Setup Script](#generated-setup-script)
+  - [Setup Keyboard Shortcuts](#setup-keyboard-shortcuts)
+  - [Action-Level Bundles](#action-level-bundles)
+  - [Building UIs: Dialogs & Observables](#building-uis-dialogs--observables)
+  - [Observables](#observables)
+  - [Dialog Builder Reference](#dialog-builder-reference)
+  - [Available Helpers](#available-helpers)
+  - [Directory Structure](#directory-structure)
+  - [Development & Publishing](#development--publishing)
+- [Resources](#resources)
+- [Examples](#examples)
+
 ## Why use it?
 
 DAZ Script gives you direct access to the entire Daz Studio API. The DazScript Framework builds on that foundation and adds:
@@ -226,7 +248,15 @@ Each built action produces two files:
 
 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.
 
-At runtime the launcher looks for the local `lib/` bundle first, then falls back to `App.getAppDataPath()/<appDataPath>`.
+At runtime the launcher looks for a local encrypted `script.dse` bundle first, then the local `script.dsa` bundle, then the same encrypted/plain fallback paths under `App.getAppDataPath()/<appDataPath>`.
+
+To encrypt implementation bundles before packaging, run the build and then call Daz Studio through the framework CLI:
+
+```bash
+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.
 
 ---
 
@@ -254,7 +284,7 @@ Applying the dialog:
 - Affected toolbars are rebuilt; empty framework-created toolbars are removed
 - Selected keyboard shortcut rows are applied after actions are installed
 
-This replaces the older `Install.dsa.ts` / `Uninstall.dsa.ts` pattern. The installer generator removes those legacy files if they exist, except when shortcut restoration is needed.
+This replaces the older `Install.dsa.ts` / `Uninstall.dsa.ts` pattern. The installer generator removes those legacy files if they exist.
 
 ### Setup Keyboard Shortcuts
 
@@ -288,7 +318,7 @@ Before changing a non-custom Daz Studio action shortcut, setup writes the origin
 App.getAppDataPath()/<appDataPath>/Installer/keyboard-shortcuts-backup.json
 ```
 
-When shortcut JSON exists, the generator also writes `src/Uninstall.dsa.ts`. Running that uninstall script restores backed-up non-custom shortcuts. Custom action shortcuts are not backed up because uninstalling the custom action removes the shortcut with the action.
+Shortcut setup is part of the generated setup dialog. The generator does not create a separate shortcut-only uninstall script.
 
 ---
 

package/dist/scripts/cli.js

@@ -6,6 +6,7 @@ const readline = require('readline');
 const { runWebpack } = require('./build');
 const { loadConfig } = require('./config-loader');
 const { copyIcons } = require('./icons');
+const { runEncrypt } = require('./encrypt');
 const { generateInstallerFiles } = require('./install-generator');
 const { initProject } = require('./init');
 
@@ -16,14 +17,18 @@ Commands:
   init                Scaffold a DazScript project in the current directory
   build               Build DazScript files
   watch               Build and watch DazScript files
+  encrypt             Encrypt built implementation bundles through Daz Studio
   icons               Copy png assets into the output directory
   installer           Generate Install.dsa.ts and Uninstall.dsa.ts
 
-Options for init:
+Options:
   --menu-path <path>    Default menu path. Default: /MyScripts
   --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
+  --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
   --force               Overwrite generated files
   --help                Show this message
 `);
@@ -110,6 +115,23 @@ function parseOptions(args, defaults) {
       continue;
     }
 
+    if (arg === '--daz-studio') {
+      options.dazStudio = args[index + 1];
+      index += 1;
+      continue;
+    }
+
+    if (arg === '--keep-source') {
+      options.keepSource = true;
+      continue;
+    }
+
+    if (arg === '--timeout-ms') {
+      options.timeoutMs = Number(args[index + 1]);
+      index += 1;
+      continue;
+    }
+
     if (arg === '--file') {
       options.file = args[index + 1];
       index += 1;
@@ -158,6 +180,9 @@ async function main(argv) {
     outDir: undefined,
     appDataPath: undefined,
     file: undefined,
+    dazStudio: undefined,
+    keepSource: false,
+    timeoutMs: undefined,
   });
 
   if (options.help) {
@@ -192,6 +217,11 @@ async function main(argv) {
     return;
   }
 
+  if (command === 'encrypt') {
+    runEncrypt(workdir, resolvedOptions);
+    return;
+  }
+
   if (command === 'icons') {
     copyIcons(workdir, resolvedOptions);
     return;

package/dist/scripts/encrypt.js

@@ -0,0 +1,179 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function toDazPath(filePath) {
+  return path.resolve(filePath).replace(/\\/g, '/');
+}
+
+function findImplementationScripts(dir) {
+  const scripts = [];
+
+  function visit(currentDir) {
+    if (!fs.existsSync(currentDir)) {
+      return;
+    }
+
+    for (const entry of fs.readdirSync(currentDir, { withFileTypes: true })) {
+      const entryPath = path.join(currentDir, entry.name);
+
+      if (entry.isDirectory()) {
+        visit(entryPath);
+        continue;
+      }
+
+      if (
+        entry.isFile() &&
+        entry.name === 'script.dsa' &&
+        path.basename(path.dirname(entryPath)) !== 'lib' &&
+        entryPath.split(path.sep).includes('lib')
+      ) {
+        scripts.push(entryPath);
+      }
+    }
+  }
+
+  visit(dir);
+  return scripts;
+}
+
+function makeConverterScript() {
+  return [
+    '(function(){',
+    '    function log(message) { print("[dazscript encrypt] " + message); }',
+    '    function fail(message) {',
+    '        print("[dazscript encrypt] ERROR " + message);',
+    '        App.quit();',
+    '    }',
+    '    function splitList(value) {',
+    '        if (!value) return [];',
+    '        return String(value).split("|");',
+    '    }',
+    '    function removeSourceFile(sourcePath) {',
+    '        var sourceFile = new DzFile(sourcePath);',
+    '        if (sourceFile.exists() && !sourceFile.remove()) {',
+    '            log("warning: encrypted but could not delete " + sourcePath);',
+    '        }',
+    '        sourceFile.deleteLater();',
+    '    }',
+    '    var args = App.scriptArgs;',
+    '    var sourceList = splitList(args[0]);',
+    '    var deleteSources = String(args[1]) == "delete";',
+    '    if (!sourceList.length) {',
+    '        log("no implementation scripts found");',
+    '        App.quit();',
+    '        return;',
+    '    }',
+    '    var failures = 0;',
+    '    for (var i = 0; i < sourceList.length; i += 1) {',
+    '        var sourcePath = sourceList[i];',
+    '        var destPath = sourcePath.replace(/\\.dsa$/i, ".dse");',
+    '        var script = new DzScript();',
+    '        log("encrypt " + sourcePath);',
+    '        if (!script.loadFromFile(sourcePath)) {',
+    '            failures += 1;',
+    '            log("failed to load " + sourcePath);',
+    '            script.deleteLater();',
+    '            continue;',
+    '        }',
+    '        if (!script.checkSyntax()) {',
+    '            failures += 1;',
+    '            log("syntax error in " + sourcePath + " line " + script.errorLine() + ": " + script.errorMessage());',
+    '            script.deleteLater();',
+    '            continue;',
+    '        }',
+    '        var writeError = script.saveFile(destPath, DzScript.EncDAZScriptFile);',
+    '        script.deleteLater();',
+    '        if (Number(writeError) != 0) {',
+    '            failures += 1;',
+    '            log("failed to save " + destPath + " error=" + writeError);',
+    '            continue;',
+    '        }',
+    '        if (deleteSources) {',
+    '            removeSourceFile(sourcePath);',
+    '        }',
+    '        log("wrote " + destPath);',
+    '    }',
+    '    if (failures) {',
+    '        fail(String(failures) + " script(s) failed");',
+    '        return;',
+    '    }',
+    '    log("complete");',
+    '    App.quit();',
+    '})();',
+    '',
+  ].join('\n');
+}
+
+function runEncrypt(workdir, options) {
+  if (!options.dazStudio) {
+    throw new Error('Missing required option: --daz-studio <path>');
+  }
+
+  const outDir = path.resolve(workdir, options.outDir || './out');
+  const dazStudioPath = path.resolve(workdir, options.dazStudio);
+
+  if (!fs.existsSync(dazStudioPath)) {
+    throw new Error(`Daz Studio executable not found: ${dazStudioPath}`);
+  }
+
+  if (!fs.existsSync(outDir)) {
+    throw new Error(`Output directory not found: ${outDir}`);
+  }
+
+  const implementationScripts = findImplementationScripts(outDir);
+  if (!implementationScripts.length) {
+    console.log(`[dazscript encrypt] no implementation scripts found under ${outDir}`);
+    return;
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dazscript-encrypt-'));
+  const converterPath = path.join(tempDir, 'encrypt-output.dsa');
+  fs.writeFileSync(converterPath, makeConverterScript(), 'utf8');
+
+  const args = [
+    '-headless',
+    '-noPrompt',
+    '-scriptArg',
+    implementationScripts.map(toDazPath).join('|'),
+    '-scriptArg',
+    options.keepSource ? 'keep' : 'delete',
+    toDazPath(converterPath),
+  ];
+
+  console.log(`[dazscript encrypt] encrypting ${implementationScripts.length} implementation script(s)`);
+  const result = spawnSync(dazStudioPath, args, {
+    encoding: 'utf8',
+    stdio: 'inherit',
+    timeout: options.timeoutMs || 300000,
+  });
+
+  fs.rmSync(tempDir, { recursive: true, force: true });
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  if (result.status !== 0) {
+    throw new Error(`Daz Studio exited with code ${result.status}`);
+  }
+
+  const missingOutputs = implementationScripts.filter((scriptPath) => {
+    const encryptedPath = scriptPath.replace(/\.dsa$/i, '.dse');
+    return !fs.existsSync(encryptedPath);
+  });
+
+  if (missingOutputs.length) {
+    throw new Error(
+      'Daz Studio did not produce encrypted output for:\n' +
+        missingOutputs.map((scriptPath) => `  ${scriptPath}`).join('\n')
+    );
+  }
+}
+
+module.exports = {
+  runEncrypt,
+};

package/dist/scripts/install-generator.js

@@ -29,14 +29,6 @@ setup(${data}, ${JSON.stringify(options)});
 `;
 }
 
-function generateUninstallTemplate(options) {
-  return `
-import { restoreSetupKeyboardShortcuts as restoreShortcuts } from '@dsf/helpers/custom-action-installer-helper';
-
-restoreShortcuts(${JSON.stringify(options)});
-`;
-}
-
 function literalValue(node) {
   if (!node) {
     return undefined;
@@ -329,9 +321,7 @@ function generateInstallerFiles(workdir, options) {
   const uninstallPath = path.join(workdir, 'src', 'Uninstall.dsa.ts');
   if (fs.existsSync(installPath)) fs.unlinkSync(installPath);
 
-  if (shortcutData.shortcuts && shortcutData.shortcuts.length > 0) {
-    fs.writeFileSync(path.join(workdir, 'src', 'Uninstall.dsa.ts'), generateUninstallTemplate(setupOptions));
-  } else if (fs.existsSync(uninstallPath)) {
+  if (fs.existsSync(uninstallPath)) {
     fs.unlinkSync(uninstallPath);
   }
 }

package/dist/scripts/launchers.js

@@ -16,17 +16,20 @@ function getActionOutputPath(workdir, outDir, sourceFile) {
   return relativeSourceFile.replace(/\.ts$/, '');
 }
 
-function getImplementationRelativePath(outputRelativePath) {
+function getImplementationRelativePath(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.dsa');
+  return path.posix.join(implementationDirectory, `script.${extension}`);
 }
 
 function makeLauncherSource(implementationRelativePath, appDataImplementationRelativePath) {
+  const encryptedImplementationRelativePath = implementationRelativePath.replace(/\.dsa$/, '.dse');
+  const encryptedAppDataImplementationRelativePath = appDataImplementationRelativePath.replace(/\.dsa$/, '.dse');
+
   return [
     '// Auto-generated launcher shim.',
     '// The installed Daz action points at this stable file.',
@@ -34,7 +37,9 @@ function makeLauncherSource(implementationRelativePath, appDataImplementationRel
     '// and from the AppData fallback location second.',
     '',
     `var implementationRelativePath = '${implementationRelativePath}';`,
+    `var encryptedImplementationRelativePath = '${encryptedImplementationRelativePath}';`,
     `var appDataImplementationRelativePath = '${appDataImplementationRelativePath}';`,
+    `var encryptedAppDataImplementationRelativePath = '${encryptedAppDataImplementationRelativePath}';`,
     'var launcherFileName = getScriptFileName();',
     'var launcherInfo = new DzFileInfo(launcherFileName);',
     'var launcherDirectory = typeof launcherInfo.canonicalPath == "function"',
@@ -42,10 +47,20 @@ function makeLauncherSource(implementationRelativePath, appDataImplementationRel
     '    : launcherInfo.path();',
     'launcherInfo.deleteLater();',
     '',
-    "var implementationPath = launcherDirectory + '/' + implementationRelativePath;",
+    "var implementationPath = launcherDirectory + '/' + encryptedImplementationRelativePath;",
     'var implementationFile = new DzFile(implementationPath);',
     'if (!implementationFile.exists()) {',
     '    implementationFile.deleteLater();',
+    "    implementationPath = launcherDirectory + '/' + implementationRelativePath;",
+    '    implementationFile = new DzFile(implementationPath);',
+    '}',
+    'if (!implementationFile.exists()) {',
+    '    implementationFile.deleteLater();',
+    "    implementationPath = App.getAppDataPath() + '/' + encryptedAppDataImplementationRelativePath;",
+    '    implementationFile = new DzFile(implementationPath);',
+    '}',
+    'if (!implementationFile.exists()) {',
+    '    implementationFile.deleteLater();',
     "    implementationPath = App.getAppDataPath() + '/' + appDataImplementationRelativePath;",
     '    implementationFile = new DzFile(implementationPath);',
     '}',
@@ -86,6 +101,10 @@ function createActionLaunchers(workdir, options) {
     const launcherPath = path.join(outDir, outputRelativePath);
     const implementationRelativePath = getImplementationRelativePath(outputRelativePath);
     const implementationPath = path.join(outDir, implementationRelativePath);
+    const encryptedImplementationPath = path.join(
+      outDir,
+      getImplementationRelativePath(outputRelativePath, 'dse')
+    );
 
     if (!fs.existsSync(launcherPath)) {
       return;
@@ -95,6 +114,9 @@ function createActionLaunchers(workdir, options) {
     if (fs.existsSync(implementationPath)) {
       fs.unlinkSync(implementationPath);
     }
+    if (fs.existsSync(encryptedImplementationPath)) {
+      fs.unlinkSync(encryptedImplementationPath);
+    }
 
     fs.renameSync(launcherPath, implementationPath);
 

package/package.json

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

package/src/helpers/custom-action-helper.ts

@@ -78,6 +78,10 @@ export type CustomActionTargets = {
     toolbar: boolean
 }
 
+type ApplyCustomActionOptions = {
+    deferToolbar?: boolean
+}
+
 type CustomActionCandidate = {
     name: string
     text: string
@@ -377,13 +381,18 @@ export const getInstalledCustomActionState = (action: CustomAction, scriptsPath:
     }
 }
 
-export const applyCustomActionTargets = (action: CustomAction, targets: CustomActionTargets, scriptsPath: string = getScriptPath()) => {
+export const applyCustomActionTargets = (
+    action: CustomAction,
+    targets: CustomActionTargets,
+    scriptsPath: string = getScriptPath(),
+    options: ApplyCustomActionOptions = {}
+): CustomAction | null => {
     const resolvedAction = resolveActionPaths(action, scriptsPath)
     const shouldInstall = targets.menu || targets.toolbar
 
     if (!shouldInstall) {
         removeCustomActionTargets(action, { menu: true, toolbar: true }, scriptsPath)
-        return
+        return null
     }
 
     const customAction = createOrUpdateCustomAction(action, resolvedAction)
@@ -392,9 +401,11 @@ export const applyCustomActionTargets = (action: CustomAction, targets: CustomAc
         addToMenu(customAction)
     }
 
-    if (targets.toolbar && action.toolbar) {
+    if (targets.toolbar && action.toolbar && !options.deferToolbar) {
         addToToolbar(customAction)
     }
+
+    return customAction
 }
 
 export const removeCustomActionTargets = (action: CustomAction, targets: CustomActionTargets, scriptsPath: string = getScriptPath()) => {

package/src/helpers/custom-action-installer-helper.ts

@@ -561,24 +561,31 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
 
     debug(`[Setup] applying ${selections.actions.filter(selection => selection.selected).length}/${selections.actions.length} selected actions`)
 
-    const removedToolbarNames = new CustomSet<string>()
+    const touchedToolbarNames = new CustomSet<string>()
+    const selectedToolbarActions: CustomAction[] = []
 
     progress('Setting Up Scripts', selections.actions, (selection) => {
         debug(`[Setup] ${selection.selected ? 'install' : 'remove'} "${selection.action.text}"`)
 
+        if (selection.supportsToolbar && selection.action.toolbar) {
+            touchedToolbarNames.add(selection.action.toolbar)
+        }
+
         if (selection.selected) {
-            applyCustomActionTargets({
+            const customAction = applyCustomActionTargets({
                 ...selection.action,
                 shortcut: selection.effectiveShortcut
             }, {
                 menu: selection.supportsMenu,
                 toolbar: selection.supportsToolbar
+            }, undefined, {
+                deferToolbar: true
             })
-            return
-        }
 
-        if (selection.supportsToolbar && selection.action.toolbar) {
-            removedToolbarNames.add(selection.action.toolbar)
+            if (customAction && selection.supportsToolbar && selection.action.toolbar) {
+                selectedToolbarActions.push(customAction)
+            }
+            return
         }
 
         removeCustomActionTargets(selection.action, {
@@ -587,14 +594,11 @@ export const showSetupCustomActionsDialog = (actions: CustomAction[], options: s
         })
     })
 
-    removedToolbarNames.forEach((toolbarName) => {
+    touchedToolbarNames.forEach((toolbarName) => {
         clearToolbar(toolbarName)
 
-        const stillSelected = selections.actions.filter(s => s.selected && s.supportsToolbar && s.action.toolbar === toolbarName)
-        stillSelected.forEach((s) => addToToolbar({
-            ...s.action,
-            shortcut: s.effectiveShortcut
-        }))
+        const stillSelected = selectedToolbarActions.filter(action => action.toolbar === toolbarName)
+        stillSelected.forEach((action) => addToToolbar(action))
         debug(`[Setup] Toolbar ${toolbarName} rebuilt with ${stillSelected.length} remaining actions`)
 
         if (stillSelected.length === 0) {