dazscript-framework 1.0.20 → 1.0.22

package/README.md

@@ -175,7 +175,7 @@ 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. When omitted, builds default to `trace`; use `warn` for release packages.
+Builds also accept `--log-level <trace|debug|info|warn|error|off>`. This sets the minimum runtime log level for the compiled scripts. When omitted, builds default to `debug`; use `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.
 

package/package.json

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

package/src/common/log.test.ts

@@ -43,10 +43,11 @@ describe('log levels', () => {
         expect(shouldLog('debug')).toBe(true)
     })
 
-    it('normalizes an empty build level to trace', () => {
+    it('normalizes an empty build level to debug', () => {
         setLogLevel('')
 
-        expect(getLogLevel()).toBe('trace')
-        expect(shouldLog('trace')).toBe(true)
+        expect(getLogLevel()).toBe('debug')
+        expect(shouldLog('debug')).toBe(true)
+        expect(shouldLog('trace')).toBe(false)
     })
 })

package/src/common/log.ts

@@ -15,7 +15,7 @@ const logLevelWeights: { [key in LogLevel]: number } = {
 let currentLogLevel: LogLevel = normalizeLogLevel(
     typeof __DAZSCRIPT_LOG_LEVEL__ === 'string'
         ? __DAZSCRIPT_LOG_LEVEL__
-        : 'trace'
+        : 'debug'
 )
 
 export const setLogLevel = (level: string): LogLevel => {
@@ -26,7 +26,7 @@ export const setLogLevel = (level: string): LogLevel => {
 export const getLogLevel = (): LogLevel => currentLogLevel
 
 export function normalizeLogLevel(level: string): LogLevel {
-    if (!level) return 'trace'
+    if (!level) return 'debug'
     const normalized = level.toLowerCase() as LogLevel
     return logLevels.indexOf(normalized) >= 0 ? normalized : 'debug'
 }

package/src/dialog/basic-dialog.ts

@@ -23,7 +23,11 @@ export abstract class BasicDialog {
 
     run(): boolean {
         this.init()
-        return this.dialog.exec()
+        this.builder.restoreObjectName()
+        this.builder.traceGeometry('beforeExec')
+        let result = this.dialog.exec()
+        this.builder.traceGeometry('afterExec', { result })
+        return result
     }
 
     ok(): boolean {

package/src/dialog/builders/dialog-builder.ts

@@ -1,8 +1,10 @@
 import { DialogProperties } from '../shared';
 import { WidgetBuilderContext, WidgetsBuilder } from './widgets-builder';
+import { debug } from '@dsf/common/log';
 
 export class DialogBuilder extends WidgetsBuilder {
     public properties: DialogProperties
+    private objectName: string
 
     constructor(private title: string, private id?: string) {
         super(new WidgetBuilderContext(new DzBasicDialog()))
@@ -15,16 +17,25 @@ export class DialogBuilder extends WidgetsBuilder {
 
     build(setup: () => void): DzBasicDialog {
         this.init()
+        this.traceGeometry('init')
         setup()
+        this.restoreObjectName()
+        this.traceGeometry('afterSetup')
         this.resize()
+        this.restoreObjectName()
+        this.traceGeometry('afterResize')
         return this.context.dialog
     }
 
     private init() {
         this.context.dialog.caption = this.title
-        let dialogWidget = this.context.dialog.getWidget()
-        var key = (this.id ?? this.context.dialog.caption).replace(/ /g, "") + "Dlg"
-        dialogWidget.objectName = key
+        this.objectName = (this.id ?? this.context.dialog.caption).replace(/ /g, "") + "Dlg"
+        this.restoreObjectName()
+    }
+
+    restoreObjectName() {
+        if (!this.objectName) return
+        this.context.dialog.getWidget().objectName = this.objectName
     }
 
     private resize() {
@@ -51,5 +62,64 @@ export class DialogBuilder extends WidgetsBuilder {
             this.context.dialog.setFixedHeight(height);
         }
     }
-}
 
+    traceGeometry(phase: string, extra: { [key: string]: string | number | boolean | undefined } = {}) {
+        let dialog = this.context.dialog
+        let dialogWidget = dialog.getWidget()
+        let objectName = this.read(dialogWidget, 'objectName')
+        let caption = this.read(dialog, 'caption')
+        let sizeHint = this.read(dialogWidget, 'minimumSizeHint')
+        let key = objectName ?? ''
+        let fields: { [key: string]: string | number | boolean | undefined } = {
+            event: 'dialog.geometry',
+            phase,
+            title: this.title,
+            id: this.id ?? '',
+            caption,
+            objectName,
+            windowGeometryKey: key,
+            dialogX: this.read(dialog, 'x'),
+            dialogY: this.read(dialog, 'y'),
+            dialogWidth: this.read(dialog, 'width'),
+            dialogHeight: this.read(dialog, 'height'),
+            widgetX: this.read(dialogWidget, 'x'),
+            widgetY: this.read(dialogWidget, 'y'),
+            widgetWidth: this.read(dialogWidget, 'width'),
+            widgetHeight: this.read(dialogWidget, 'height'),
+            sizeHintWidth: this.read(sizeHint, 'width'),
+            sizeHintHeight: this.read(sizeHint, 'height'),
+            propertyWidth: this.properties.width,
+            propertyHeight: this.properties.height,
+            propertyMaxWidth: this.properties.maxWidth,
+            propertyMaxHeight: this.properties.maxHeight,
+            resizable: this.properties.resizable === true,
+            registrySubKey: key ? `WindowGeometries\\${key}` : ''
+        }
+
+        Object.keys(extra).forEach((name) => fields[name] = extra[name])
+        debug(`[DialogGeometry] ${this.formatGeometryTrace(fields)}`)
+    }
+
+    private read(source: any, field: string): any {
+        if (!source) return undefined
+        try {
+            return source[field]
+        }
+        catch (err) {
+            return undefined
+        }
+    }
+
+    private formatGeometryTrace(fields: { [key: string]: string | number | boolean | undefined }): string {
+        return Object.keys(fields)
+            .filter((name) => fields[name] !== undefined)
+            .map((name) => `${name}=${this.formatGeometryValue(name, fields[name])}`)
+            .join(' ')
+    }
+
+    private formatGeometryValue(name: string, value: string | number | boolean | undefined): string {
+        if (name === 'event' || name === 'phase') return String(value)
+        if (typeof value === 'string') return JSON.stringify(value)
+        return String(value)
+    }
+}

package/src/dialog/dialog-geometry-trace.test.ts

@@ -0,0 +1,148 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+import { BasicDialog } from './basic-dialog'
+import { setLogLevel } from '../common/log'
+
+class TestDialog extends BasicDialog {
+    protected build(): void {
+        this.builder.options({ resizable: true })
+    }
+}
+
+class HeaderDialog extends BasicDialog {
+    protected build(): void {
+        this.builder.header({ text: 'Header' }).build()
+        this.builder.options({ resizable: true })
+    }
+}
+
+describe('dialog geometry trace', () => {
+    beforeEach(() => {
+        ; (globalThis as any).App = {
+            debug: vi.fn(),
+            log: vi.fn(),
+            warning: vi.fn(),
+            flushLogBuffer: vi.fn(),
+            statusLine: vi.fn()
+        }
+        ; (globalThis as any).DzBasicDialog = class {
+            caption = ''
+            width = 300
+            height = 200
+            minHeight = 0
+            sizeGripEnabled = false
+            private widget = {
+                objectName: '',
+                x: 10,
+                y: 20,
+                width: 300,
+                height: 200,
+                minimumSizeHint: { width: 300, height: 200 }
+            }
+
+            getWidget() {
+                return this.widget
+            }
+
+            inherits(typeName: string) {
+                return typeName === 'DzWidget'
+            }
+
+            addLayout() { }
+
+            exec() {
+                this.width = 640
+                this.height = 480
+                this.widget.width = 640
+                this.widget.height = 480
+                return true
+            }
+        }
+        const Layout = class {
+            direction = 0
+            constructor(public parent: unknown) { }
+            inherits(typeName: string) {
+                return typeName === 'DzLayout'
+            }
+            addWidget() { }
+        }
+        class Widget {
+            private _name = ''
+            height = 30
+            width = 100
+            minHeight = 0
+            maxHeight = 0
+            toolTip = ''
+            whatsThis = ''
+            constructor(private parent: any) { }
+            set name(value: string) {
+                this._name = value
+                if (this.parent?.getWidget) this.parent.getWidget().objectName = value
+            }
+            get name() {
+                return this._name
+            }
+            getWidget() {
+                return this
+            }
+            inherits(typeName: string) {
+                return typeName === 'DzWidget'
+            }
+            setFixedHeight(value: number) {
+                this.height = value
+            }
+            setFixedWidth(value: number) {
+                this.width = value
+            }
+            show() { }
+            hide() { }
+        }
+        ; (globalThis as any).DzVBoxLayout = Layout
+        ; (globalThis as any).DzHBoxLayout = Layout
+        ; (globalThis as any).DzWidget = Widget
+        ; (globalThis as any).DzLabel = Widget
+        ; (globalThis as any).DzTextBrowser = class extends Widget {
+            html = ''
+            readOnly = false
+            lineWrapMode = 0
+            wordWrapMode = 0
+        }
+        ; (globalThis as any).DzTextEdit = { WidgetWidth: 1, WordWrap: 2 }
+        ; (globalThis as any).DzSplitter = { Vertical: 1, Horizontal: 2 }
+        setLogLevel('trace')
+    })
+
+    it('logs dialog objectName and geometry before and after exec', () => {
+        new TestDialog('Power Loader', 'Vholf3D Power Loader').run()
+
+        const messages = (globalThis as any).App.debug.mock.calls.map((call: unknown[]) => String(call[0]))
+
+        expect(messages.some((message: string) =>
+            message.includes('event=dialog.geometry phase=init') &&
+            message.includes('objectName="Vholf3DPowerLoaderDlg"')
+        )).toBe(true)
+        expect(messages.some((message: string) =>
+            message.includes('event=dialog.geometry phase=beforeExec') &&
+            message.includes('dialogWidth=300')
+        )).toBe(true)
+        expect(messages.some((message: string) =>
+            message.includes('event=dialog.geometry phase=afterExec') &&
+            message.includes('dialogWidth=640') &&
+            message.includes('result=true')
+        )).toBe(true)
+    })
+
+    it('keeps the DAZ geometry objectName stable after building a header widget', () => {
+        new HeaderDialog('Power Menu - Active Tool', 'Vholf3D Power Menu - Active Tool').run()
+
+        const messages = (globalThis as any).App.debug.mock.calls.map((call: unknown[]) => String(call[0]))
+
+        expect(messages.some((message: string) =>
+            message.includes('event=dialog.geometry phase=afterSetup') &&
+            message.includes('objectName="Vholf3DPowerMenu-ActiveToolDlg"')
+        )).toBe(true)
+        expect(messages.some((message: string) =>
+            message.includes('event=dialog.geometry phase=beforeExec') &&
+            message.includes('objectName="Vholf3DPowerMenu-ActiveToolDlg"')
+        )).toBe(true)
+    })
+})