dazscript-framework 0.1.0

package/shared/install-generator.js

@@ -0,0 +1,185 @@
+const tsFileParser = require('ts-file-parser');
+const fs = require('fs');
+const path = require('path');
+const glob = require('glob');
+const { program } = require('commander');
+
+program
+  .requiredOption(
+    '-p, --scriptsPath <path>',
+    'Specify the path to your scripts'
+  )
+  .option(
+    '-m, --defaultMenuPath [path]',
+    'Specify the default menu path',
+    'My Scripts'
+  )
+  .parse(process.argv);
+let options = program.opts();
+
+const nameofActionDecorator = 'action';
+
+const scriptsPath = options.scriptsPath.endsWith('/')
+  ? options.scriptsPath
+  : options.scriptsPath + '/';
+const defaultMenuPath = options.defaultMenuPath.endsWith('/')
+  ? options.defaultMenuPath
+  : options.defaultMenuPath + '/';
+
+const container = { scripts: [] };
+
+function getPartialPath(filePath) {
+  const fileInfo = path.parse(filePath);
+  const dir = fileInfo.dir.replace('/src', '').replace(/^\.\//, '');
+  return `${dir}/${fileInfo.name}`;
+}
+
+function compareStrings(a, b) {
+  return a.localeCompare(b, undefined, { sensitivity: 'base' });
+}
+
+function stringOrDefault(str, defaultValue) {
+  return str !== undefined && str !== null && str !== '' ? str : defaultValue;
+}
+
+function generateInstallerTemplate(data) {
+  return `
+import { installCustomActions as install } from '@dsf/helpers/custom-action-helper';
+
+install(${data});
+`;
+}
+
+function generateUninstallerTemplate(data) {
+  return `
+import { uninstallCustomActions as uninstall } from '@dsf/helpers/custom-action-helper';
+
+uninstall(${data});
+`;
+}
+
+function processScript(filePath) {
+  const fileInfo = path.parse(filePath);
+  const content = fs.readFileSync(filePath, 'utf-8').toString();
+  const json = tsFileParser.parseStruct(content, {}, filePath);
+
+  json.classes.forEach((cls) => {
+    const actionDecorator = cls.decorators.find(
+      (d) => d.name === nameofActionDecorator
+    );
+
+    if (!actionDecorator) return;
+
+    const decorator = actionDecorator.arguments[0] ?? {};
+
+    const script = {
+      name: null,
+      text: fileInfo.name.replace('.dsa', ''),
+      filePath:
+        decorator.bundle === undefined
+          ? getPartialPath(filePath)
+          : fileInfo.name.replace('.ts', ''),
+      menuPath: `${defaultMenuPath}${path.parse(getPartialPath(filePath)).dir}`,
+      description: fileInfo.name.replace('.dsa', ''),
+      group: stringOrDefault(decorator.group, undefined),
+      shortcut: stringOrDefault(decorator.shortcut),
+      toolbar: stringOrDefault(decorator.toolbar, undefined),
+    };
+
+    const icon = filePath.replace('.ts', '.png');
+    if (fs.existsSync(icon)) {
+      script.icon =
+        decorator.bundle === undefined
+          ? `${getPartialPath(filePath)}.png`
+          : fileInfo.name.replace('.dsa', '.dsa.png');
+    }
+
+    if (actionDecorator) {
+      script.text = stringOrDefault(decorator.text, script.text);
+      if (typeof decorator.menuPath === 'boolean') {
+        script.menuPath = decorator.menuPath === true ? script.menuPath : '';
+      } else {
+        script.menuPath = stringOrDefault(decorator.menuPath, script.menuPath);
+      }
+      script.menuPath = script.menuPath.replace(
+        '#{defaultMenuPath}',
+        defaultMenuPath
+      );
+      script.shortcut = decorator.shortcut;
+    }
+
+    console.log(`Adding script: ${script.text}`, script);
+    container.scripts.push(script);
+
+    // Check if the decorator has a "bundle" property
+    if (decorator.bundle !== undefined) {
+      let packageInstallerFilePath = `Install.dsa.ts`;
+      let packageUninstallerFilePath = `Uninstall.dsa.ts`;
+
+      if (decorator.bundle !== true) {
+        // If decorator.bundle is a string, use it as the bundle file name
+        packageInstallerFilePath = `Install ${decorator.bundle}.dsa.ts`;
+        packageUninstallerFilePath = `Uninstall ${decorator.bundle}.dsa.ts`;
+      }
+
+      // Generate a separate file with the specified or default name
+      let bundleScriptContent = generateInstallerTemplate(
+        JSON.stringify(container.scripts, null, 4)
+      );
+      let bundleScriptFilePath = path.join(
+        path.parse(filePath).dir,
+        packageInstallerFilePath
+      );
+      fs.writeFileSync(bundleScriptFilePath, bundleScriptContent);
+
+      bundleScriptContent = generateUninstallerTemplate(
+        JSON.stringify(container.scripts, null, 4)
+      );
+      bundleScriptFilePath = path.join(
+        path.parse(filePath).dir,
+        packageUninstallerFilePath
+      );
+      fs.writeFileSync(bundleScriptFilePath, bundleScriptContent);
+    }
+  });
+}
+
+function processScripts(paths) {
+  paths.forEach((filePath) => {
+    console.log(`Processing ${filePath}`);
+    processScript(filePath);
+  });
+}
+
+function generate() {
+  glob(`${scriptsPath}/**/*.dsa.ts`, function (err, paths) {
+    if (err) {
+      console.error('Error while globbing:', err);
+      return;
+    }
+
+    processScripts(paths);
+
+    container.scripts = container.scripts.sort((a, b) => {
+      const aKey = a.menuPath + a.filePath;
+      const bKey = b.menuPath + b.filePath;
+      return compareStrings(aKey, bKey);
+    });
+
+    // Generate the InstallerScript class and call install function
+    const installerScriptContent = generateInstallerTemplate(
+      JSON.stringify(container.scripts, null, 4)
+    );
+    let outputFilePath = './src/Install.dsa.ts';
+    fs.writeFileSync(outputFilePath, installerScriptContent);
+
+    const uninstallerScriptContent = generateUninstallerTemplate(
+      JSON.stringify(container.scripts, null, 4)
+    );
+    outputFilePath = './src/Uninstall.dsa.ts';
+    fs.writeFileSync(outputFilePath, uninstallerScriptContent);
+  });
+}
+
+// Call the generate function at the end of the script
+generate();

package/shared/set-keyboard-shortcut.ts

@@ -0,0 +1,103 @@
+import { BasicDialog } from '@dsf/dialog/basic-dialog';
+import { setActionShortcut } from '@dsf/helpers/action-helper';
+import { contains } from '@dsf/helpers/array-helper';
+import { Observable } from '@dsf/lib/observable';
+
+class KeyboardShortcutModel {
+    actionLabel: string
+    shortcut = new Observable('')
+    control = new Observable(false)
+    alt = new Observable(false)
+    shift = new Observable(false)
+    windows = new Observable(false)
+}
+
+const letters = [
+    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '-'
+]
+
+const keys = [
+    'SPACE', 'HOME', 'END', 'INS', 'PLUS', 'MINUS',
+    'RIGHT', 'LEFT', 'UP', 'DOWN', 'TAB', 'BACKSPACE', 'COMMA', 'PERIOD', 'PGUP', 'PGDOWN', '-',
+    'F1', 'F2', 'F3', 'F4', 'F5', 'F6', 'F7', 'F8', 'F9', 'F10',
+    'F11', 'F12', 'F13', 'F14', 'F15', 'F16', 'F17', 'F18', 'F19',
+    'F20', 'F21', 'F22', 'F23', 'F24',
+];
+
+
+class KeyboardShortcutDialog extends BasicDialog {
+    private key = new Observable('')
+
+    constructor(private model: KeyboardShortcutModel) {
+        super('Keyboard Shortcut');
+    }
+
+    protected build(): void {
+        let add = this.add
+        let model = this.model
+        this.dialog.setAcceptButtonEnabled(false)
+        this.dialog.showHelpButton(false)
+        this.builder.context.layout.margin = 5
+        this.dialog.minWidth = 250
+
+        this.key.intercept((_, current) => {
+            let value = current
+            if (current.length > 1 && !contains(keys, current))
+                value = current[1]
+            if (value.length === 1)
+                value = value.toUpperCase()
+            return value
+        })
+        this.key.connect((text) => {
+            model.shortcut.value = this.getShortcut(text)
+        })
+
+        const metaKeys = [model.control, model.alt, model.shift, model.windows];
+        for (const observable of metaKeys) {
+            observable.connect(() => this.key.trigger());
+        }
+
+        this.key.connect((text) => {
+            this.dialog.setAcceptButtonEnabled(Boolean(text))
+        })
+
+        add.group('Assign Keyboard Shortcut').build((layout) => {
+            layout.spacing = 5
+            add.edit().text(model.actionLabel).readOnly(true)
+            add.comboEdit().focus().items([...letters, ...keys]).changed(this.key).edited(this.key)
+            add.checkbox('Control').value(model.control)
+            add.checkbox('Option / Alt').value(model.alt)
+            add.checkbox('Shift').value(model.shift)
+            add.checkbox('Command / Windows').value(model.windows)
+            add.group('Shortcut:').style({ flat: true }).build(() => {
+                add.edit().text(model.shortcut).readOnly(true)
+            })
+        })
+    }
+
+    getShortcut(key: string): string {
+        let keys: string[] = []
+
+        if (this.model.control.value) keys.push('CTRL')
+        if (this.model.alt.value) keys.push('ALT')
+        if (this.model.shift.value) keys.push('SHIFT')
+        if (this.model.windows.value) keys.push('WIN')
+
+        keys.push(key)
+
+        return keys.join('+')
+    }
+}
+
+export const setKeyboardShortcut = (actionLabel: string, actionName: string) => {
+    let model = new KeyboardShortcutModel()
+    model.actionLabel = actionLabel
+
+    let dialog = new KeyboardShortcutDialog(model)
+    let result = dialog.run()
+
+    if (!result || !model.shortcut) return
+
+    setActionShortcut(actionName, model.shortcut.value)
+}

package/webpack.config.js

@@ -0,0 +1,48 @@
+const path = require('path');
+const glob = require('glob');
+const TsconfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
+
+module.exports = (env, argv) => {
+  const isFileSpecified = env && env.file;
+  const entryFiles = isFileSpecified
+    ? [`./src/${env.file}.dsa.ts`]
+    : glob.sync('./src/**/*.dsa.ts');
+
+  return {
+    mode: 'production',
+    optimization: {
+      usedExports: true,
+    },
+    entry: entryFiles.reduce((acc, filePath) => {
+      const entry = filePath.replace('.dsa.ts', '').replace('src/', ''); // Remove 'src/' from the path
+      acc[entry] = `./${filePath}`;
+      return acc;
+    }, {}),
+    module: {
+      rules: [
+        {
+          test: /\.ts$/,
+          use: ['babel-loader', 'ts-loader'],
+          exclude: /node_modules/,
+        },
+      ],
+    },
+    resolve: {
+      extensions: ['.tsx', '.ts', '.js'],
+      plugins: [new TsconfigPathsPlugin()],
+    },
+    output: {
+      filename: '[name].dsa',
+      path: path.resolve(__dirname, 'dist'),
+      environment: {
+        arrowFunction: false,
+        bigIntLiteral: false,
+        const: false,
+        destructuring: false,
+        dynamicImport: false,
+        forOf: true,
+        module: false,
+      },
+    },
+  };
+};