dazscript-framework 0.1.0

package/babel/babel.config.js

@@ -0,0 +1,33 @@
+module.exports = {
+  presets: [
+    [
+      '@babel/preset-env',
+      {
+        targets: {
+          esmodules: true,
+          ie: '11',
+        },
+        include: ['@babel/plugin-transform-class-properties'],
+      },
+    ],
+    '@babel/preset-typescript',
+  ],
+  plugins: [
+    '@babel/plugin-transform-class-properties',
+    'babel-plugin-transform-typescript-metadata',
+    ['@babel/plugin-proposal-decorators', { version: 'legacy' }],
+    ['@babel/plugin-transform-arrow-functions'],
+    '@babel/plugin-transform-block-scoping',
+    '@babel/plugin-proposal-class-properties',
+    '@babel/plugin-transform-private-property-in-object',
+    '@babel/plugin-transform-private-methods',
+    [
+      './src/framework/babel/trace-babel-plugin',
+      { default: false, retainLines: false },
+    ],
+    [
+      './src/framework/babel/trace-log-babel-plugin',
+      { default: false, retainLines: false },
+    ],
+  ],
+};

package/babel/trace-babel-plugin.js

@@ -0,0 +1,243 @@
+const t = require('@babel/types');
+const path = require('path');
+let globalEnable = true;
+let enabled = false;
+
+function isTraceDecorator(node) {
+  return false; // Your existing isTraceDecorator logic
+}
+
+function isTraceComment(node) {
+  return false; // Your existing isTraceComment logic
+}
+
+function createConsoleLogStatement(
+  location,
+  filename,
+  lineNumber,
+  functionName,
+  parameters
+) {
+  const filenameWithoutPath = path.basename(filename);
+  let logMessage = `[TRACE] ${location}: ${filenameWithoutPath}(${lineNumber}): ${functionName}`;
+
+  if (parameters.length > 0) {
+    logMessage += `(${parameters.join(', ')})`;
+  } else {
+    logMessage += '()';
+  }
+
+  return t.blockStatement([
+    t.expressionStatement(
+      t.callExpression(
+        t.memberExpression(t.identifier('App'), t.identifier('debug')),
+        [t.stringLiteral(logMessage)]
+      )
+    ),
+    t.expressionStatement(
+      t.callExpression(
+        t.memberExpression(t.identifier('App'), t.identifier('flushLogBuffer')),
+        []
+      )
+    ),
+  ]);
+}
+
+function processFunction(enabled, path, state) {
+  const filename = state.file.opts.filename || 'unknown';
+  const lineNumber = path.node.loc?.start?.line || 'unknown';
+  const functionName = path.node.id ? path.node.id.name : 'anonymous';
+  const parameters = path.node.params.map((param) => param.name);
+
+  if (!enabled || functionName === 'anonymous' || lineNumber === 'unknown')
+    return;
+
+  const enteringLogStatement = createConsoleLogStatement(
+    'Entering',
+    filename,
+    lineNumber,
+    functionName,
+    parameters
+  );
+  const exitingLogStatement = createConsoleLogStatement(
+    'Exiting',
+    filename,
+    lineNumber,
+    functionName,
+    parameters
+  );
+
+  // Process the return statements within the function body
+  path.get('body').traverse({
+    ReturnStatement(returnPath) {
+      returnPath.insertBefore(exitingLogStatement);
+    },
+  });
+
+  if (enteringLogStatement) {
+    if (t.isBlockStatement(path.node.body)) {
+      path.node.body.body.unshift(enteringLogStatement);
+    } else {
+      path.node.body = t.blockStatement([enteringLogStatement, path.node.body]);
+    }
+  }
+}
+
+function processAssignmentExpression(path, state) {
+  const filename = state.file.opts.filename || 'unknown';
+  const lineNumber = path.node.loc?.start?.line || 'unknown';
+  let functionName = 'anonymous'; // Default value for function name
+  const parameters = [];
+
+  if (!enabled || lineNumber === 'unknown') return;
+
+  if (t.isMemberExpression(path.node.left)) {
+    functionName = path.node.left.property.name;
+  }
+
+  const enteringLogStatement = createConsoleLogStatement(
+    'Entering',
+    filename,
+    lineNumber,
+    functionName,
+    parameters
+  );
+  const exitingLogStatement = createConsoleLogStatement(
+    'Exiting',
+    filename,
+    lineNumber,
+    functionName,
+    parameters
+  );
+
+  // Process the return statements within the function body
+  path.get('right').traverse({
+    ReturnStatement(returnPath) {
+      returnPath.insertBefore(exitingLogStatement);
+    },
+  });
+
+  if (
+    t.isFunctionExpression(path.node.right) ||
+    t.isArrowFunctionExpression(path.node.right)
+  ) {
+    // Handle the case where the right-hand side is a function expression or arrow function expression
+    if (t.isBlockStatement(path.node.right.body)) {
+      path.node.right.body.body.unshift(enteringLogStatement);
+      path.node.right.body.body.push(exitingLogStatement);
+    } else {
+      path.node.right.body = t.blockStatement([
+        enteringLogStatement,
+        t.returnStatement(path.node.right.body),
+        exitingLogStatement,
+      ]);
+    }
+  }
+}
+
+function processVariableDeclaration(path, state) {
+  const filename = state.file.opts.filename || 'unknown';
+  const lineNumber = path.node.loc?.start?.line || 'unknown';
+
+  path.node.declarations.forEach((declarator) => {
+    if (
+      t.isFunctionExpression(declarator.init) ||
+      t.isArrowFunctionExpression(declarator.init)
+    ) {
+      const functionName = declarator.id.name;
+      const parameters = declarator.init.params.map((param) => param.name);
+
+      if (!enabled || lineNumber === 'unknown') return;
+
+      const enteringLogStatement = createConsoleLogStatement(
+        'Entering',
+        filename,
+        lineNumber,
+        functionName,
+        parameters
+      );
+      const exitingLogStatement = createConsoleLogStatement(
+        'Exiting',
+        filename,
+        lineNumber,
+        functionName,
+        parameters
+      );
+
+      // Ensure the Exiting statement is added to the end of the function body
+      if (t.isBlockStatement(declarator.init.body)) {
+        declarator.init.body.body.push(exitingLogStatement);
+      } else {
+        declarator.init.body = t.blockStatement([
+          declarator.init.body,
+          exitingLogStatement,
+        ]);
+      }
+
+      // Process the return statements within the function body
+      declarator.init.body.body.forEach((statement, index) => {
+        if (t.isReturnStatement(statement)) {
+          // Add Exiting statement before the return statement
+          declarator.init.body.body.splice(index, 0, exitingLogStatement);
+        }
+      });
+
+      // Add the Entering statement at the beginning of the function body
+      if (t.isBlockStatement(declarator.init.body)) {
+        declarator.init.body.body.unshift(enteringLogStatement);
+      } else {
+        declarator.init.body = t.blockStatement([
+          enteringLogStatement,
+          t.returnStatement(declarator.init.body),
+        ]);
+      }
+    }
+  });
+}
+
+module.exports = function () {
+  let declarationFound = false;
+
+  return {
+    pre() {
+      if (this.opts && typeof this.opts.default === 'boolean') {
+        enabled = globalEnable = this.opts.default;
+      }
+      enabled = globalEnable;
+      declarationFound = false;
+    },
+    visitor: {
+      VariableDeclaration(path, state) {
+        const declarations = path.node.declarations;
+        const traceDeclaration = declarations.find(
+          (declaration) => declaration.id.name === 'TRACE'
+        );
+
+        if (!declarationFound) {
+          if (traceDeclaration) {
+            enabled = traceDeclaration.init
+              ? traceDeclaration.init.value
+              : false;
+            declarationFound = true;
+          } else {
+            enabled = globalEnable;
+          }
+        }
+
+        processVariableDeclaration(path, state);
+      },
+      FunctionDeclaration(path, state) {
+        //processFunction(path, state);
+      },
+      FunctionExpression(path, state) {
+        processFunction(enabled, path, state);
+      },
+      ArrowFunctionExpression(path, state) {
+        //processFunction(path, state);
+      },
+      AssignmentExpression(path, state) {
+        processAssignmentExpression(path, state);
+      },
+    },
+  };
+};

package/babel/trace-log-babel-plugin.js

@@ -0,0 +1,164 @@
+const t = require('@babel/types');
+const pathModule = require('path');
+let globalEnable = true;
+let enabled = false;
+
+function wrapWithLogMethod(t, logMethodName, expression) {
+  return t.callExpression(
+    t.memberExpression(t.identifier('log'), t.identifier(logMethodName)),
+    [t.stringLiteral(expression)]
+  );
+}
+
+function createLogMessage(path) {
+  // Ensure that the parent is a function before accessing its name
+  if (
+    t.isFunctionDeclaration(path.parent) ||
+    t.isFunctionExpression(path.parent)
+  ) {
+    const functionName = path.parent.id ? path.parent.id.name : 'anonymous';
+    const filename = path.hub.file.opts.filename || 'unknown';
+    const lineNumber = path.node.loc?.start?.line || 'unknown';
+    const filenameWithoutPath = pathModule.basename(filename);
+
+    return `${filenameWithoutPath}.${functionName}(${lineNumber + 2}): ${
+      path.node.arguments[0].value
+    }`;
+  } else {
+    // If the parent is not a function, use "anonymous"
+    const filename = path.hub.file.opts.filename || 'unknown';
+    const lineNumber = path.node.loc?.start?.line || 'unknown';
+    const filenameWithoutPath = pathModule.basename(filename);
+    const lineNumberStr = lineNumber === 'unknown' ? '' : `(${lineNumber + 2})`;
+
+    return `${filenameWithoutPath}${lineNumberStr}: ${path.node.arguments[0].value}`;
+  }
+}
+
+function isNonStringLiteralOrTemplateLiteral(node) {
+  // Check if the node is not a string literal or is a template literal
+  return !(t.isStringLiteral(node) || t.isTemplateLiteral(node));
+}
+
+function replaceLogStatements(path, logMethodName) {
+  if (!enabled) return;
+  if (t.isCallExpression(path.node) && !path.node.processed) {
+    const callee = path.node.callee;
+
+    if (
+      isNonStringLiteralOrTemplateLiteral(path.node.arguments[0]) &&
+      t.isIdentifier(callee) &&
+      callee.name === logMethodName
+    ) {
+      // Handle non-string literal or template literal here
+      const functionName = path.parent.id ? `.${path.parent.id.name}` : '';
+      const filename = path.hub.file.opts.filename || 'unknown';
+      const lineNumber = path.node.loc?.start?.line || 'unknown';
+      const filenameWithoutPath = pathModule.basename(filename);
+
+      let logMessage = `[TRACE] ${filenameWithoutPath}${functionName}(${
+        lineNumber + 2
+      })`;
+
+      const logLine = t.blockStatement([
+        t.expressionStatement(
+          t.callExpression(
+            t.memberExpression(t.identifier('App'), t.identifier('debug')),
+            [t.stringLiteral(logMessage)]
+          )
+        ),
+        t.expressionStatement(
+          t.callExpression(
+            t.memberExpression(
+              t.identifier('App'),
+              t.identifier('flushLogBuffer')
+            ),
+            []
+          )
+        ),
+      ]);
+
+      path.insertBefore(logLine);
+      path.node.processed = true;
+    } else if (
+      t.isMemberExpression(callee) &&
+      t.isIdentifier(callee.object, { name: 'log' })
+    ) {
+      // It's log.debug or similar, wrap it with wrapWithLogMethod
+      const logMessage = createLogMessage(path, logMethodName);
+      path.replaceWith(wrapWithLogMethod(t, logMethodName, logMessage));
+      path.node.processed = true;
+    } else if (t.isIdentifier(callee) && callee.name === logMethodName) {
+      // It's just the specified method, update the argument directly
+      path.node.arguments[0].value = createLogMessage(path, logMethodName);
+      path.node.processed = true;
+    }
+  }
+}
+
+module.exports = function () {
+  let declarationFound = false;
+
+  return {
+    pre() {
+      if (this.opts && typeof this.opts.default === 'boolean') {
+        enabled = globalEnable = this.opts.default;
+      }
+      enabled = globalEnable;
+      declarationFound = false;
+    },
+    visitor: {
+      VariableDeclaration(path, state) {
+        const declarations = path.node.declarations;
+        const traceDeclaration = declarations.find(
+          (declaration) => declaration.id.name === 'TRACE'
+        );
+
+        if (!declarationFound) {
+          if (traceDeclaration) {
+            enabled = traceDeclaration.init
+              ? traceDeclaration.init.value
+              : false;
+            declarationFound = true;
+          } else {
+            enabled = globalEnable;
+          }
+        }
+      },
+      FunctionDeclaration(path, state) {
+        path.traverse({
+          CallExpression(callPath) {
+            //replaceLogStatements(callPath, 'trace');
+          },
+        });
+      },
+      FunctionExpression(path, state) {
+        path.traverse({
+          CallExpression(callPath) {
+            replaceLogStatements(callPath, 'debug');
+          },
+        });
+        path.traverse({
+          CallExpression(callPath) {
+            replaceLogStatements(callPath, 'error');
+          },
+        });
+        path.traverse({
+          CallExpression(callPath) {
+            replaceLogStatements(callPath, 'info');
+          },
+        });
+        path.traverse({
+          CallExpression(callPath) {
+            replaceLogStatements(callPath, 'dump');
+          },
+        });
+        path.traverse({
+          CallExpression(callPath) {
+            replaceLogStatements(callPath, 'trace');
+          },
+        });
+      },
+    },
+  };
+};

package/common/core.ts

@@ -0,0 +1,2 @@
+// import '@dsf/polyfills/array-polyfill'
+// export { Array } from '@dsf/polyfills/array-polyfill'

package/common/log.ts

@@ -0,0 +1,57 @@
+import * as global from '@dsf/lib/global'
+
+export const debug = (message: any) => {
+    App.debug(format(message))
+    App.flushLogBuffer()
+}
+
+export const info = (message: any) => {
+    global.app.log(format(message))
+    App.flushLogBuffer()
+}
+
+export const error = (message: any) => {
+    App.warning(format(message, "ERROR"))
+    App.flushLogBuffer()
+}
+
+export const warn = (message: any) => {
+    App.warning(message)
+    App.flushLogBuffer()
+}
+
+export const trace = (message: any) => {
+    App.debug(format(message, "TRACE"))
+    App.flushLogBuffer()
+}
+
+export const status = (message: any, log: boolean = true) => {
+    App.statusLine(message, log)
+}
+
+/**
+ * Log the error and raise an exception
+ * @param err
+ */
+export const raise = (err: string) => {
+    error(err)
+    throw Error(err)
+}
+
+export const dump = (obj: any) => {
+    App.debug(`[DUMP]\r\n${JSON.stringify(obj, null, 2)}`)
+    App.flushLogBuffer()
+}
+
+
+const format = (message: string, level?: 'ERROR' | 'TRACE' | 'DUMP' | 'INFO') => {
+    if (message == null) {
+        return ''
+    }
+
+    let text = message
+
+    if (level) text = `[${level}] ${text}`
+    return text
+}
+

package/common/trace.ts

@@ -0,0 +1,26 @@
+import { app } from '@dsf/lib/global';
+
+export function trace(enabled: boolean = true) {
+    return function (target: any, key?: string, descriptor?: PropertyDescriptor) {
+        if (key !== undefined && descriptor !== undefined) {
+            // Applied to a method
+            if (!enabled)
+                return descriptor
+
+            const originalMethod = descriptor.value;
+            descriptor.value = function (...args: any[]) {
+                app.debug(`[TRACE] Entering method: ${key}`);
+                app.flushLogBuffer()
+                const result = originalMethod.apply(this, args);
+                app.debug(`[TRACE] Exiting method: ${key}`);
+                app.flushLogBuffer()
+                return result;
+            };
+
+            return descriptor;
+        } else if (key === undefined && descriptor === undefined) {
+            // Applied to a class
+            return target;
+        }
+    }
+}

package/core/action-decorator.ts

@@ -0,0 +1,16 @@
+class CustomActionDefinition {
+    text?: string
+    description?: string
+    icon?: string
+    menuPath?: string | boolean
+    toolbar?: string
+    sort?: number
+    group?: string
+    shortcut?: string
+    bundle?: string | boolean
+}
+
+export const action = (action?: CustomActionDefinition) => {
+    return (target: Function) => {
+    }
+}

package/dialog/basic-dialog.ts

@@ -0,0 +1,32 @@
+import { DialogBuilder } from '@dsf/dialog/builders/dialog-builder';
+
+export abstract class BasicDialog {
+    protected dialog: DzBasicDialog
+    protected readonly builder: DialogBuilder
+
+    protected get add(): DialogBuilder {
+        return this.builder
+    }
+
+    constructor(name: string, id?: string) {
+        this.builder = new DialogBuilder(name, id)
+    }
+
+    protected abstract build(): void
+
+    protected init() {
+        this.builder.build(() => {
+            this.dialog = this.builder.context.dialog
+            this.build()
+        })
+    }
+
+    run(): boolean {
+        this.init()
+        return this.dialog.exec()
+    }
+
+    close() {
+        this.dialog.close()
+    }
+}

package/dialog/builders/button-builder.ts

@@ -0,0 +1,53 @@
+import { Observable } from '@dsf/lib/observable';
+import { WidgetBuilderBase, createWidget } from './widget-builder';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export class ButtonBuilder extends WidgetBuilderBase<DzPushButton> {
+    constructor(context: WidgetBuilderContext) {
+        super(createWidget(context).build(DzPushButton))
+    }
+
+    text(text: string): this {
+        this.widget.text = text
+        return this
+    }
+
+    toggle(bind: Observable<boolean>): this {
+        this.widget.setCheckable(true)
+        this.widget.checked = bind.value
+        this.widget.toggled.scriptConnect((value) => {
+            bind.value = value
+        })
+        bind.connect((value) => {
+            this.widget.checked = value
+        })
+        return this
+    }
+
+    clicked(then: Observable<void> | ((button: DzPushButton) => void)): this {
+        if (then instanceof Observable) {
+            this.widget.clicked.scriptConnect(() => {
+                then.trigger()
+            })
+        }
+        else {
+            this.widget.clicked.scriptConnect(() => {
+                then?.(this.widget)
+            })
+        }
+        return this
+    }
+
+    icon(image: string | Pixmap): this {
+        this.widget.pixmap = typeof image === 'string'
+            ? new Pixmap(image)
+            : image
+        return this
+    }
+
+    build(then?: (button: DzPushButton) => void): DzPushButton {
+        if (!this.widget.text && this.widget.pixmap) this.widget.collapseEmptySpace = true
+        then?.(this.widget)
+        return this.widget
+    }
+}

package/dialog/builders/checkbox-builder.ts

@@ -0,0 +1,30 @@
+import { Observable } from '@dsf/lib/observable';
+import { WidgetBuilderBase, createWidget } from './widget-builder';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export default class CheckBoxBuilder extends WidgetBuilderBase<DzCheckBox> {
+    constructor(context: WidgetBuilderContext) {
+        super(createWidget(context).build(DzCheckBox))
+    }
+
+    label(text: string): this {
+        this.widget.text = text ?? ''
+        return this
+    }
+
+    value(property: Observable<boolean>): this {
+        this.widget.checked = property.value
+        property.connect((value) => {
+            this.widget.checked = value
+        })
+        this.widget.toggled.scriptConnect((value) => {
+            property.value = value
+        })
+        return this
+    }
+
+    build(): DzCheckBox {
+        return this.widget
+    }
+
+}

package/dialog/builders/combo-box-builder.ts

@@ -0,0 +1,36 @@
+import { Observable } from '@dsf/lib/observable';
+import { WidgetBuilderBase, createWidget } from './widget-builder';
+import { WidgetBuilderContext } from './widgets-builder';
+
+export class ComboBoxBuilder extends WidgetBuilderBase<DzComboBox>{
+    items(items: string[]): this {
+        items.forEach((item, idx) => {
+            if (!item)
+                this.widget.insertSeparator(idx)
+            else
+                this.widget.insertItem(idx, item)
+        });
+        return this
+    }
+
+    selected(bind: Observable<string>): this {
+        this.widget.currentText = bind.value
+        bind.connect((text) => {
+            if (this.widget.findText(text) >= 0)
+                this.widget.currentText = text
+        })
+        this.widget.textChanged.scriptConnect((text) => {
+            bind.value = text
+        })
+        return this
+    }
+
+    constructor(context: WidgetBuilderContext) {
+        super(createWidget(context).build(DzComboBox))
+    }
+
+    build(then?: (comboBox: DzComboBox) => void) {
+        then?.(this.widget)
+        return this.widget
+    }
+}