dazscript-framework 0.1.0

package/lib/delayed.ts

@@ -0,0 +1,39 @@
+export class Delayed {
+    private minDelay: number;
+    private maxDelay: number;
+    private timeout: any;
+    private action: () => void;
+
+    /**
+     * Perform an action delayed
+     * @param action action to delay
+     * @param minDelay min delay in milliseconds
+     * @param maxDelay max delay in milliseconds
+     */
+    constructor(action: () => void, minDelay = 100, maxDelay = 500) {
+        this.action = action;
+        this.minDelay = minDelay;
+        this.maxDelay = maxDelay;
+    }
+
+    public trigger() {
+        if (this.timeout === undefined) {
+            this.timeout = new DzTimer();
+            this.timeout.timeout.connect(() => {
+                this.action();
+                this.reset();
+            });
+            this.timeout.start(this.maxDelay);
+        } else {
+            this.timeout.stop();
+            this.timeout.start(this.minDelay);
+        }
+    }
+
+    private reset() {
+        if (this.timeout !== undefined) {
+            this.timeout.stop();
+            this.timeout = undefined;
+        }
+    }
+}

package/lib/dz-dump.ts

@@ -0,0 +1,121 @@
+import { any } from '@dsf/helpers/array-helper';
+import { contains, count, remove } from '@dsf/helpers/string-helper';
+
+function isUpperCase(myString: string) {
+    return (myString === myString.toUpperCase());
+}
+
+var lines = [];
+function processLine(x: string): void {
+    x = remove(x, "*");
+    x = x.replace("const ", "");
+    x = x.replace(/\(([a-zA-Z0-9]*),/, "(#{arg}:$1,");
+    x = x.replace(/,([a-zA-Z0-9]*)\)/, ", #{arg}:$1)");
+    x = x.replace(/,([a-zA-Z0-9]\w*)/g, ", #{arg}:$1");
+    while (contains(x, "#{arg}")) {
+        var n = count(x, "#{arg}") - 1;
+        x = x.replace(new RegExp('#{arg}(?!.*#{arg})'), `p${n}`);
+    }
+    x = x.replace(/(int|float)/g, "number");
+    x = x.replace(/(bool)/g, "boolean");
+    x = x.replace(/(QString)/g, "string");
+    x = x.replace(/(QPonumber)/g, "number");
+    x = x.replace(/\((\w*\))/, "(p0:$1");
+    x = x.replace(/\((\w*\))/, "(p0:$1");
+    x = x.replace("p0:)", ")");
+    lines.push("    " + x + ": any;");
+};
+
+// Keep track of classes avoiding duplicates
+var classesFound = {};
+
+export function dz_dump(obj: any) {
+    if (!obj || obj === null) {
+        print('null object');
+        App.flushLogBuffer()
+        return;
+    }
+
+    var className = null;
+    var enumerations = [];
+    var properties = [];
+    var functions = [];
+    var signals = [];
+
+    // is DAZ object?
+    if (obj["className"]) {
+        className = obj.className();
+    }
+
+    // already seen? leave
+    if (classesFound[className]) return;
+
+    for (var name in obj) {
+        var o = obj[name];
+        if (typeof o == "function") {
+            if (any(["Changed", "Requested", "Renamed", "Clicked", "Pressed"], x => contains(name, x)))
+                signals.push(name);
+            else
+                functions.push(name);
+        }
+        else {
+            if (isUpperCase(name[0]))
+                enumerations.push(name);
+            else
+                properties.push(name);
+        }
+    }
+    properties.sort();
+    functions.sort();
+    signals.sort();
+
+    lines.push("");
+    lines.push("/**");
+    lines.push(" * class " + className);
+    lines.push(" */");
+    lines.push("declare class " + className + " {");
+
+    if (enumerations.length > 0) {
+        lines.push("");
+        lines.push("    //#region Enumerations");
+        enumerations.forEach(function (x) {
+            lines.push("    static " + x + ": " + typeof obj[x] + "; // " + (obj[x]));
+        });
+    }
+    lines.push("    //#endregion");
+    lines.push("");
+    lines.push("    // Properties");
+
+    properties.forEach(function (x) {
+        lines.push("    " + x + ": " + typeof obj[x] + "; // " + (obj[x]));
+    });
+    lines.push("");
+    lines.push("    // Methods");
+
+    // Process LineFunctions
+    functions.forEach(processLine);
+
+    // Process Signals
+    if (signals.length > 0) {
+        lines.push("");
+        lines.push("    // Signals");
+        signals.forEach(processLine);
+    }
+    lines.push("}");
+
+    classesFound[className] = lines.join('\r\n');
+
+    // output classes found
+    for (var name in classesFound) {
+        print(classesFound[name]);
+    }
+
+}
+
+// =======================================
+// =======================================
+// =======================================
+//dump(new DzERCLink());
+// =======================================
+// =======================================
+// =======================================

package/lib/global.ts

@@ -0,0 +1,5 @@
+export const app = App
+export const scene = Scene
+export const mainWindow = MainWindow
+export const sceneHelper = new DzSceneHelper()
+export const arrayHelper = new DzArrayHelper()

package/lib/guid.ts

@@ -0,0 +1,3 @@
+export const createUID = (): string => {
+    return "uuid-" + ((new Date).getTime().toString(16) + Math.floor(1E7 * Math.random()).toString(16));
+}

package/lib/observable.ts

@@ -0,0 +1,94 @@
+export class Observable<T> {
+    protected _value: T;
+    private _beforeChange: (previous: T, current: T) => T
+    private _onChange: Array<(value: T) => void> = []
+    private _afterChange: (previous: T, current: T) => T
+    private _paused: boolean
+
+    constructor(value?: T, onChange?: (value: T) => void) {
+        this.value = value;
+        if (onChange)
+            this._onChange.push(onChange);
+    }
+
+    get value(): T {
+        return this._value;
+    }
+
+    set value(value: T) {
+        let previous = this._value
+        this._value = this._beforeChange?.(this._value, value) ?? value
+        if (!this._paused) this.trigger()
+        this._value = this._afterChange?.(previous, this._value) ?? this._value
+    }
+
+    connect(onChange: (value: T) => void): this {
+        if (this._onChange.indexOf(onChange) === -1) {
+            this._onChange.push(onChange)
+        }
+        return this
+    }
+
+    intercept(beforeChange: (previous: T, current: T) => T, afterChange?: (previous: T, current: T) => T): this {
+        this._beforeChange = beforeChange
+        this._afterChange = afterChange
+        return this
+    }
+
+    disconnect(onChange: (value: T) => void) {
+        const index = this._onChange.indexOf(onChange);
+        if (index > -1) {
+            this._onChange.splice(index, 1);
+        }
+    }
+
+    trigger(): void {
+        if (!this._paused)
+            this._onChange.forEach(callback => callback(this._value));
+    }
+
+    pause(callback?: () => void): void {
+        this._paused = true
+        callback?.()
+        this.resume()
+    }
+
+    resume(): void {
+        this._paused = false
+    }
+
+    toJSON() {
+        return this._value;
+    }
+}
+
+export class BooleanObservable extends Observable<boolean> {
+    private combined: BooleanObservable[] = []
+
+    combine(...observables: BooleanObservable[]): this {
+        observables.forEach((obs) => {
+            this.combined.push(obs)
+            obs.connect(_ => {
+                this._value = this.combined.every(b => b.value)
+            })
+        })
+        return this
+    }
+}
+
+
+// export class ObservableNumber extends Observable<number> {
+//     setMax(max: number): this {
+//         this.connect((value) => {
+//             if (value > max) value = max
+//         })
+//         return this
+//     }
+
+//     setMin(min: number): this {
+//         this.connect((value) => {
+//             if (value < min) value = min
+//         })
+//         return this
+//     }
+// }

package/lib/set.ts

@@ -0,0 +1,25 @@
+export default class CustomSet<T> {
+    private items: Record<string, T> = {};
+
+    add(item: T): void {
+        const key = this.getKey(item);
+        this.items[key] = item;
+    }
+
+    has(item: T): boolean {
+        const key = this.getKey(item);
+        return key in this.items;
+    }
+
+    private getKey(item: T): string {
+        if (typeof item === 'object') {
+            // For object items, use a unique identifier (e.g., JSON string) as the key
+            return JSON.stringify(item);
+        }
+        return String(item);
+    }
+
+    values(): T[] {
+        return Object.values(this.items);
+    }
+}

package/lib/settings.ts

@@ -0,0 +1,104 @@
+import { Observable } from './observable';
+
+export class AppSettings {
+    private appSettings: DzAppSettings
+    private _settingsPath: string
+    private _appDataPath: string
+    get appDataPath(): string {
+        return this._appDataPath
+    }
+
+    constructor(settingsPath: string, appDataPath?: string) {
+        this._settingsPath = settingsPath
+        this.setPaths({ settingsPath: settingsPath, appDataPath: appDataPath ?? settingsPath })
+    }
+
+    setPaths(paths: { settingsPath?: string, appDataPath?: string }) {
+        if (!paths.settingsPath && !paths.appDataPath) return
+        if (paths.settingsPath) {
+            this._settingsPath = paths.settingsPath
+            this.appSettings = new DzAppSettings(paths.settingsPath)
+        }
+        if (paths.appDataPath) {
+            this._appDataPath = `${App.getAppDataPath()}/${paths.appDataPath}`
+        }
+    }
+
+    forPath(path: string, ...paths: string[]): DzAppSettings {
+        let target = [this._settingsPath, path, ...paths].join('/')
+        return new DzAppSettings(target)
+    }
+
+    protected getInt(name: keyof this, value: number): number {
+        return this.appSettings.getIntValue(String(name), value);
+    }
+
+    protected setInt(name: keyof this, value: number) {
+        this.appSettings.setIntValue(String(name), value)
+    }
+
+    protected getFloat(name: keyof this, value: number): number {
+        return this.appSettings.getFloatValue(String(name), value);
+    }
+
+    protected setFloat(name: keyof this, value: number) {
+        this.appSettings.setFloatValue(String(name), value)
+    }
+
+    protected getBool(name: keyof this, defaultValue: boolean): boolean {
+        return this.appSettings.getBoolValue(String(name), defaultValue);
+    }
+
+    protected setBool(name: keyof this, value: boolean): void {
+        this.appSettings.setBoolValue(String(name), value)
+    }
+
+    protected getString(name: keyof this, defaultValue: string): string {
+        return this.appSettings.getStringValue(String(name), defaultValue)
+    }
+
+    protected setString(name: keyof this, value: string): void {
+        this.appSettings.setStringValue(String(name), value)
+    }
+
+    protected getArray(name: keyof this, defaultValue: string[]): string[] {
+        return this.appSettings.getStringValue(String(name), defaultValue.join(',')).split(',')
+    }
+
+    // protected setArray(name: keyof this, value: string[]): void {
+    //     this.appSettings.setStringValue(String(name), value.join(','))
+    // }
+
+    // protected getJson<T>(name: keyof this, defaultValue: T): T {
+    //     return JSON.parse(this.getString(name, JSON.stringify(defaultValue)))
+    // }
+
+    // protected setJson<T>(name: keyof this, value: T): void {
+    //     this.setString(name, JSON.stringify(value))
+    // }
+
+
+    bindBoolean(name: keyof this, defaultValue: boolean = false): Observable<boolean> {
+        return new Observable(this.getBool(name, defaultValue), (value) => this.setBool(name, value))
+    }
+
+    bindString(name: keyof this, defaultValue: string = ''): Observable<string> {
+        return new Observable(this.getString(name, defaultValue), (value) => this.setString(name, value))
+    }
+
+    bindInt(name: keyof this, defaultValue: number): Observable<number> {
+        return new Observable(this.getInt(name, defaultValue), (value) => this.setInt(name, value))
+    }
+
+    bindFloat(name: keyof this, defaultValue: number): Observable<number> {
+        return new Observable(this.getFloat(name, defaultValue), (value) => this.setFloat(name, value))
+    }
+
+    // bindArray(name: keyof this, defaultValue: string[] = []): Observable<string[]> {
+    //     return new Observable(this.getArray(name, defaultValue), (value) => this.setArray(name, value))
+    // }
+
+    // bindJson<T>(name: keyof this, defaultValue: T): Observable<T> {
+    //     return new Observable(this.getJson(name, defaultValue), (value) => this.setJson(name, value))
+    // }
+}

package/models/custom-action.ts

@@ -0,0 +1,12 @@
+export class CustomAction {
+    name: string
+    text: string
+    description: string
+    filePath: string
+    menuPath: string
+    icon?: string
+    toolbar?: string
+    sort?: number
+    group?: string
+    shortcut?: string
+}

package/models/frame-keys.ts

@@ -0,0 +1,68 @@
+import { find } from '@dsf/helpers/array-helper';
+
+export class PropertyKey {
+    index: number
+    frame: number = 0
+    time: DzTime
+    value: number
+
+    toJSON(): Object {
+        return {
+            index: this.index,
+            time: this.time.valueOf(),
+            frame: this.frame,
+            value: this.value,
+        }
+    }
+}
+
+export class PropertyKeys {
+    constructor(private _items: PropertyKey[]) {
+        if (!this._items) this._items = [];
+    }
+
+    forEach(callback: (key: PropertyKey) => any) {
+        this._items.forEach(key => {
+            callback(key);
+        });
+    }
+
+    get items(): PropertyKey[] {
+        return this._items;
+    }
+
+    get first(): PropertyKey | null {
+        return this._items[0]
+    }
+
+    get length(): number {
+        return this._items.length;
+    }
+
+    get current(): PropertyKey {
+        return find(this._items, k => k.time.valueOf() == Scene.getTime().valueOf())
+    }
+
+    get previous(): PropertyKey {
+        return find(this._items.sort((a, b) => b.index - a.index), k => k.time.valueOf() < Scene.getTime().valueOf())
+    }
+
+    get next(): PropertyKey {
+        return find(this._items, k => k.time.valueOf() > Scene.getTime().valueOf())
+    }
+
+    /**
+     * Given the animation frame number or time, return the property key
+     * @param frameorTime frame number or time
+     * @returns the property key
+     */
+    at(frameorTime: number | DzTime): PropertyKey | null {
+        return typeof frameorTime === 'number'
+            ? find(this._items, k => k.frame === frameorTime)
+            : find(this._items, k => k.time === frameorTime)
+    }
+
+    any(): boolean {
+        return this.items.length > 0
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "dazscript-framework",
+  "version": "0.1.0",
+  "author": "Freddy Diaz",
+  "license": "MPL-2.0",
+  "description": "",
+  "keywords": [
+    "daz3d",
+    "daz studio",
+    "daz script",
+    "dson",
+    "dsa",
+    "dse"
+  ],
+  "exports": {
+    "./webpack": "./webpack.config.js",
+    "./babel": "./babel/babel.config.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fjdiazt/dazscript-framework"
+  },
+  "peerDependencies": {
+    "@babel/core": "^7.23.2",
+    "@babel/plugin-proposal-class-properties": "^7.18.6",
+    "@babel/plugin-proposal-decorators": "^7.23.2",
+    "@babel/plugin-transform-arrow-functions": "^7.22.5",
+    "@babel/plugin-transform-block-scoping": "^7.23.0",
+    "@babel/preset-env": "^7.23.2",
+    "@babel/preset-typescript": "^7.23.2",
+    "@babel/types": "^7.23.0",
+    "babel-core": "^6.26.3",
+    "babel-loader": "^9.1.3",
+    "babel-loader-exclude-node-modules-except": "^1.2.1",
+    "babel-plugin-transform-class-properties": "^6.24.1",
+    "babel-plugin-transform-typescript-metadata": "^0.3.2",
+    "commander": "^11.1.0",
+    "cross-env": "^7.0.3",
+    "dazscript-types": "^0.1.0",
+    "glob": "^7.2.0",
+    "ts-file-parser": "^0.0.21",
+    "ts-loader": "^9.5.0",
+    "tsconfig-paths-webpack-plugin": "^4.1.0",
+    "typescript": "^5.2.2",
+    "webpack": "^5.88.2",
+    "webpack-cli": "^5.1.4"
+  }
+}

package/shared/base-script.ts

@@ -0,0 +1,30 @@
+import { debug, error, raise } from '@dsf/common/log';
+import { acceptUndo } from '@dsf/helpers/undo-helper';
+
+export abstract class BaseScript {
+    protected readonly scriptName: string
+    protected anounceExecution: boolean = true
+
+    constructor() {
+        this.scriptName = (<any>this.constructor).name;
+    }
+
+    protected abstract run(): void
+
+    exec() {
+        if (this.anounceExecution) {
+            debug(`=== Running script "${this.scriptName}" ===`)
+        }
+
+        try {
+            this.run()
+        } catch (err) {
+            error(`There was an error while running the script "${this.scriptName}"`)
+            raise(err)
+        }
+    }
+
+    protected acceptUndo(callback: () => void) {
+        acceptUndo(this.scriptName, callback);
+    }
+}