dazscript-framework 0.1.0

package/helpers/array-helper.ts

@@ -0,0 +1,145 @@
+import Set from '@dsf/lib/set';
+
+export const contains = <T>(array: T[], searchElement: T, fromIndex?: number): boolean => {
+  if (array == null) {
+    throw new TypeError('Array.prototype includes called on null or undefined');
+  }
+
+  const O = Object(array);
+  const len = O.length >>> 0;
+
+  if (len === 0) {
+    return false;
+  }
+
+  let k = 0;
+
+  if (fromIndex !== undefined) {
+    k = fromIndex | 0;
+    k = Math.max(k >= 0 ? k : len - Math.abs(k), 0);
+  }
+
+  while (k < len) {
+    if (O[k] === searchElement) {
+      return true;
+    }
+    k++;
+  }
+
+  return false;
+}
+
+export const find = <T>(array: T[], f: (item: T) => boolean): T | null => {
+  for (const item of array) {
+    if (f(item)) {
+      return item
+    }
+  }
+  return null
+}
+
+export const distinct = <T>(items: T[], f?: (item: T) => any): T[] => {
+  const distinctItems: T[] = [];
+  const customSet = new Set<T>();
+
+  for (const item of items) {
+    const key = f ? f(item) : item;
+    if (!customSet.has(key)) {
+      customSet.add(key);
+      distinctItems.push(item);
+    }
+  }
+
+  return distinctItems;
+}
+
+/**
+ * Adds the item to the array only if it is not already contained
+ * @param array
+ * @param item
+ * @returns
+ */
+export const append = <T>(array: T[], item: T): T[] => {
+  if (!contains(array, item)) {
+    array.push(item);
+  }
+  return array
+}
+
+export const flatten = <T>(array: (T | T[])[]): T[] => {
+  const flattened: T[] = [];
+  const stack: (T | T[])[] = [...array];
+
+  while (stack.length) {
+    const item = stack.pop();
+    if (Array.isArray(item)) {
+      // If the item is an array, push its contents onto the stack.
+      stack.push(...item);
+    } else {
+      // If the item is not an array, add it to the flattened array.
+      flattened.push(item);
+    }
+  }
+
+  return flattened.reverse(); // Reverse the array to maintain original order.
+}
+
+export const any = <T>(array: T[], f?: (item: T) => boolean): boolean => {
+  if (!f)
+    return array.length > 0
+
+  for (const item of array) {
+    if (f(item)) {
+      return true
+    }
+  }
+  return false;
+}
+
+export const moveToTop = <T>(arr: T[], element: T, findBy: (item: T) => string) => {
+  const findByValue = findBy(element);
+  let index = -1;
+
+  for (let i = 0; i < arr.length; i++) {
+    if (findBy(arr[i]) === findByValue) {
+      index = i;
+      break;
+    }
+  }
+
+  if (index > -1) {
+    const [removed] = arr.splice(index, 1);
+    arr.unshift(removed);
+    return;
+  }
+}
+
+export const moveToBottom = <T>(arr: T[], element: T, findBy: (item: T) => string) => {
+  const findByValue = findBy(element);
+  let index = -1;
+
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (findBy(arr[i]) === findByValue) {
+      index = i;
+      break;
+    }
+  }
+
+  if (index > -1) {
+    const [removed] = arr.splice(index, 1);
+    arr.push(removed);
+    return;
+  }
+}
+
+export const group = <T, K extends string>(array: T[], getKey: (item: T) => K): Record<K, T[]> => {
+  let reduced: Record<K, T[]> = array.reduce((previous, currentItem) => {
+    let group = getKey(currentItem);
+    if (!group) group = "" as K;
+    if (!previous[group]) previous[group] = [];
+    previous[group].push(currentItem);
+    return previous;
+  }, {} as Record<K, T[]>);
+  return reduced;
+}
+

package/helpers/camera-helper.ts

@@ -0,0 +1,14 @@
+import * as global from '@dsf/lib/global'
+import { mainWindow } from '@dsf/lib/global';
+
+export const getActiveCamera = (): DzCamera => {
+    return mainWindow.getViewportMgr().getActiveViewport().get3DViewport().getCamera()
+}
+
+export const setActiveCamera = (camera: DzCamera) => {
+    mainWindow.getViewportMgr().getActiveViewport().get3DViewport().setCamera(camera);
+}
+
+export const getPerspectiveCamera = (): DzCamera => {
+    return mainWindow.getViewportMgr().getViewCamera(DzCamera.PERSPECTIVE_CAM)
+}

package/helpers/custom-action-helper.ts

@@ -0,0 +1,176 @@
+import { debug } from '@dsf/common/log'
+import * as array from '@dsf/helpers/array-helper'
+import { mainWindow } from '@dsf/lib/global'
+import { CustomAction } from '@dsf/models/custom-action'
+import { getMenu } from './menu-helper'
+import { keys } from './object-helper'
+import { progress } from './progress-helper'
+import { getScriptPath } from './script-helper'
+
+const actionMgr = mainWindow.getActionMgr()
+const paneMgr = mainWindow.getPaneMgr()
+
+export const findByFilePath = (action: CustomAction, filePath: string): CustomAction | null => {
+    var actionsCount = actionMgr.getNumCustomActions()
+    for (var i = 0; i < actionsCount; i++) {
+        var actionFilePath = actionMgr.getCustomActionFile(i)
+
+        if (actionFilePath != filePath) continue
+
+        var name = actionMgr.getCustomActionName(i)
+        var text = actionMgr.getCustomActionText(i)
+        var desc = actionMgr.getCustomActionDesc(i)
+        var icon = actionMgr.getCustomActionIcon(i)
+
+        return {
+            name: name.toString(),
+            text: text.toString(),
+            description: desc.toString(),
+            filePath: actionFilePath.toString(),
+            icon: icon.toString(),
+            menuPath: action.menuPath,
+            group: action.group,
+            shortcut: action.shortcut,
+            sort: action.sort,
+            toolbar: action.toolbar
+        } as CustomAction
+    }
+
+    return null
+}
+
+export const findMenuFor = (actionName: string, topMenu?: DzActionMenu): DzActionMenu | null => {
+    topMenu = topMenu ?? actionMgr.getMenu()
+    if (!topMenu.hasItems()) return null
+    for (let i = 0; i < topMenu.getNumItems(); i++) {
+        let item = topMenu.getItem(i)
+        if (item.type == DzActionMenuItem.CustomAction && item.action == actionName)
+            return item.getParentMenu()
+        if (item.type == DzActionMenuItem.SubMenu) {
+            var subMenu = findMenuFor(actionName, item.getSubMenu())
+            if (subMenu) return subMenu
+        }
+    }
+    return null
+}
+
+export const findInMenu = (menu: DzActionMenu, actionName: string): DzActionMenuItem | null => {
+    var item: DzActionMenuItem
+
+    var aItems = menu.getItemList()
+    for (var i = 0; i < aItems.length; i += 1) {
+        item = aItems[i]
+
+        if (item.type != DzActionMenuItem.CustomAction) {
+            continue
+        }
+
+        if (item.action == actionName) {
+            return item
+        }
+    }
+
+    return null
+}
+
+export const createCustomAction = (action: CustomAction, update: boolean) => {
+    let existingAction = findByFilePath(action, action.filePath)
+
+    if (existingAction && !update) return
+
+    if (existingAction) {
+        removeCustomAction(existingAction)
+    }
+
+    let name = actionMgr.addCustomAction(String(action.text), String(action.description), String(action.filePath), true, action.shortcut ?? "", String(action.icon)).toString()
+    action.name = name
+
+    if (action.shortcut) {
+        actionMgr.setCustomActionShortcut(actionMgr.findCustomAction(name), action.shortcut)
+        debug(`Created Custom Action: ${action.text} (${action.name}): ${action.filePath}`)
+    }
+
+    addToMenu(action)
+    addToToolbar(action)
+}
+
+export const addToMenu = (action: CustomAction) => {
+    if (!action.menuPath) return
+    action.menuPath = action.menuPath + '/'
+    var menu = getMenu(action.menuPath, true)
+    var menuAction = findInMenu(menu, action.name)
+    if (menuAction) return
+    menu.insertCustomAction(action.name, action.sort ?? -1)
+    debug(`Action "${action.text}" added to menu "${menu.getPath()}"`)
+}
+
+export const addToToolbar = (action: CustomAction) => {
+    if (!action.toolbar) return;
+
+    var toolbar = paneMgr.findToolBar(action.toolbar);
+
+    if (!toolbar) {
+        toolbar = paneMgr.createToolBar(action.toolbar);
+        toolbar.dock(DzToolBar.ToolBarTop);
+    }
+
+    if (array.find(toolbar.getItemList(), i => i.action == action.name)) return
+
+    debug(`Adding menu to toolbar ${toolbar.name}`)
+    toolbar.insertCustomAction(action.name, action.sort)
+}
+
+const removeCustomAction = (action: CustomAction) => {
+    if (!action.name) return
+    var menu = findMenuFor(action.name, actionMgr.getMenu())
+    if (menu) {
+        var menuAction = findInMenu(menu, action.name)
+        if (menuAction) {
+            menu.removeItem(menuAction)
+            debug(`Action ${action.text} Removed from menu`)
+        }
+    }
+
+    actionMgr.removeCustomAction(actionMgr.findCustomAction(action.name))
+    debug(`Action ${action.text} Removed`)
+    debug(`Toolbar: ${action.toolbar}`)
+
+    if (!action.toolbar) return
+    debug(`Removing Toolbar ${action.toolbar}`)
+    var toolbar = paneMgr.findToolBar(action.toolbar)
+    if (!toolbar) return
+    toolbar.clear()
+    paneMgr.removeToolBar(action.toolbar)
+    debug(`Toolbar Removed`)
+}
+
+export const installCustomActions = (actions: CustomAction[]) => {
+    uninstallCustomActions(actions)
+    let scriptsPath = getScriptPath()
+    debug(`Script path: ${scriptsPath}`)
+    let menuPaths = array.group(actions, (a => a.menuPath ?? ""))
+    progress('Installing', keys(menuPaths), (menuPath) => {
+        let actions = menuPaths[menuPath] as CustomAction[]
+        let groups = array.group(actions, (action) => action.group ?? "")
+        keys(groups).forEach(group => {
+            groups[group].forEach(action => {
+                action.filePath = `${scriptsPath}/${action.filePath}`
+                action.icon = action.icon ? `${scriptsPath}/${action.icon}` : ''
+                createCustomAction(action, true)
+                // findMenuFor(action.name)
+            })
+        })
+    })
+}
+
+export const uninstallCustomActions = (actions: CustomAction[]) => {
+    debug(`Uninstalling Actions`)
+    actions.forEach(action => {
+        if (!action) return
+        let customAction = findByFilePath(action, `${getScriptPath()}/${action.filePath}`)
+        if (!customAction) return
+        debug(`Uninstalling action "${customAction.text} (${customAction.name})"`)
+        removeCustomAction(customAction)
+    })
+}
+

package/helpers/file-helper.ts

@@ -0,0 +1,90 @@
+import * as log from '@dsf/common/log'
+
+/**
+ * Reads a file and tries to deserialize it to the specified type, assuming the file content
+ * is a valid JSON
+ * @param filePath the file to read
+ * @param cache if true, cache the file into memory
+ * @returns the deserialized object or null of the file cannot be deserialized
+ */
+export const readFromFile = <T>(filePath: string, cache: boolean = false): T | null => {
+    try {
+        var file = new DzFile(filePath)
+        if (!file.exists()) return null
+        file.open(DzFile.ReadOnly)
+        file.setCaching(cache)
+        var content = file.read().toString()
+        var items: T = JSON.parse(content)
+        file.close()
+        file.deleteLater()
+        return items
+    } catch (error) {
+        log.error(`Error while reading file ${filePath}`)
+        return null
+    }
+}
+
+/**
+ *
+ * @param path
+ * @param fileName
+ * @param content
+ * @returns
+ */
+export const saveToFile = (filePath: string, content: string): boolean => {
+    try {
+        if (!filePath || !content) return false
+        let fileInfo = new DzFileInfo(filePath)
+        let path = fileInfo.absolutePath()
+        var dzDir = new DzDir(path)
+        dzDir.mkpath(path)
+        var file = new DzFile(`${filePath}`)
+        file.open(DzFile.WriteOnly)
+        file.write(content)
+        file.close()
+        fileInfo.deleteLater()
+        file.deleteLater()
+        return true
+    } catch (error) {
+        log.error(`Error while saving file ${filePath}`)
+        return false
+    }
+}
+
+/**
+ *
+ * @param path
+ * @param fileName
+ * @param content
+ * @returns
+ * @deprecated must remove path argument
+ */
+export const saveToFileOld = (path: string, fileName: string, content: string): boolean => {
+    try {
+        if (!path || !fileName || !content) return false
+        var dzDir = new DzDir(path)
+        dzDir.mkpath(path)
+        var file = new DzFile(`${path}${fileName}`)
+        file.open(DzFile.WriteOnly)
+        file.write(content)
+        file.close()
+        file.deleteLater()
+        return true
+    } catch (error) {
+        log.error(`Error while saving file ${path}${fileName}`)
+        return false
+    }
+}
+
+export const deleteFile = (filePath: string): boolean => {
+    try {
+        var file = new DzFile(filePath)
+        if (!file.exists()) return
+        file.remove(filePath)
+        file.deleteLater()
+        return true
+    } catch (error) {
+        log.error(`Error while deleting file ${filePath}`)
+        return false
+    }
+}

package/helpers/input-helper.ts

@@ -0,0 +1,19 @@
+export const getModifierKeys = (): {
+    shift: boolean,
+    ctrl: boolean,
+    command: boolean,
+    win: boolean,
+    control: boolean,
+    alt: boolean
+} => {
+    var nModifierState = App.modifierKeyState();
+
+    return {
+        shift: (nModifierState & 0x02000000) != 0,
+        ctrl: (nModifierState & 0x04000000) != 0,
+        alt: (nModifierState & 0x08000000) != 0,
+        win: (nModifierState & 0x10000000) != 0,
+        command: (nModifierState & 0x04000000) != 0,
+        control: (nModifierState & 0x10000000) != 0
+    };
+}

package/helpers/list-view-helper.ts

@@ -0,0 +1,89 @@
+import { contains } from './string-helper'
+
+export const clearColumns = (listView: DzListView) => {
+    for (let i = 0; i < listView.columns; i++) {
+        listView.removeColumn(i)
+    }
+}
+
+export const setDataItem = (listItem: DzListViewItem, data: any) => {
+    listItem.addDataItem('data', data)
+}
+
+export const getDataItem = <T>(listItem: DzListViewItem): T | null => {
+    return listItem?.getDataItem('data') ?? null
+}
+
+export const filter = (listView: DzListView, filterOn: (viewItem: DzListViewItem) => string, keywords: string, options?: { selectOnFilter?: boolean, filters?: (viewItem: DzListViewItem) => boolean }) => {
+    listView.clearSelection()
+    listView.getItems(DzListView.All).forEach(item => item.visible = true)
+
+    const matchFilter = (text: string): boolean => {
+        text = text.toLowerCase()
+        var words = keywords?.toLowerCase().split(" ") ?? []
+
+        return !keywords || keywords.trim() == "" ||
+            words.every(w => {
+                return w.length >= 1 || !isNaN(Number(w))
+                    ? contains(text, w)
+                    : text.startsWith(w)
+            });
+    }
+
+    const setListViewItemVisibility = (viewItem: DzListViewItem): boolean => {
+        let keywordMatch = matchFilter(filterOn(viewItem))
+        let filtersMatch = !options?.filters || options.filters?.(viewItem) === true
+        viewItem.visible = keywordMatch && filtersMatch
+
+        if (options?.selectOnFilter === true && viewItem.visible && !listView.selectedItem()) {
+            listView.setSelected(viewItem, true)
+            listView.ensureItemVisible(viewItem)
+        }
+
+        return viewItem.visible;
+    }
+
+    const filterListViewItem = (viewItem: DzListViewItem): boolean => {
+        var visible = false;
+
+        if (viewItem.childCount() > 0) {
+            var child = viewItem.firstChild()
+            while (child) {
+                visible = visible || filterListViewItem(child)
+                child = child.nextSibling()
+            }
+        }
+
+        viewItem.visible = visible || setListViewItemVisibility(viewItem);
+        return viewItem.visible;
+    }
+
+    listView.getItems(DzListView.All).forEach(viewItem => {
+        viewItem.visible = true
+        filterListViewItem(viewItem)
+    });
+}
+
+export const expand = (listView: DzListView, expandOrCollapse: boolean, listItem?: DzListViewItem) => {
+    if (listItem) {
+        listItem.open = expandOrCollapse
+        if (listItem.childCount() > 0) {
+            var child = listItem.firstChild()
+            while (child) {
+                expand(listView, expandOrCollapse, child)
+                child = child.nextSibling()
+            }
+        }
+    }
+    else {
+        listView.getItems(DzListView.All).forEach((item) => {
+            item.open = expandOrCollapse
+        })
+    }
+}
+
+export const checkAll = (listView: DzListView, onOff: boolean) => {
+    listView.getItems(onOff ? DzListView.NotChecked : DzListView.Checked).forEach(item => {
+        (item as DzCheckListItem).on = onOff
+    })
+}

package/helpers/menu-helper.ts

@@ -0,0 +1,29 @@
+import { mainWindow } from '@dsf/lib/global'
+
+const actionMgr = mainWindow.getActionMgr()
+const paneMgr = mainWindow.getPaneMgr()
+
+export const getMenu = (menuPath: string, createIfNotFound: boolean): DzActionMenu => {
+    var index = menuPath.indexOf("::")
+    var hasPaneDelimiter = index >= 0
+
+    // TODO: Check what a path delimiter is and how to use it
+    if (hasPaneDelimiter) {
+        var paneClass = menuPath.substring(0, index)
+        var paneManager = paneMgr.findPane(paneClass)
+        if (paneManager) {
+            var menu = paneManager.getOptionsMenu();
+            var subMenu = menuPath.substring(index + 2)
+            // Get/Create the sub menu
+            return createIfNotFound
+                ? menu.findOrCreateSubMenu(subMenu)
+                : menu.findSubMenu(subMenu);
+        }
+    }
+    else {
+        // Get/Create the sub menu
+        return createIfNotFound
+            ? actionMgr.getMenu().findOrCreateSubMenu(menuPath)
+            : actionMgr.getMenu().findSubMenu(menuPath)
+    }
+}

package/helpers/message-box-helper.ts

@@ -0,0 +1,16 @@
+import * as log from "@dsf/common/log"
+
+export const info = (msg: string) => {
+    MessageBox.information(msg, "", "Ok")
+}
+
+export const error = (message: string, writeLog?: boolean) => {
+    if (writeLog) log.debug(message)
+    MessageBox.critical(message, "Error", "Ok")
+}
+
+export const confirm = (message?: string): { ok: boolean, cancel: boolean } => {
+    var response = MessageBox.question(message ?? "Confirm?", "", "Ok", "Cancel");
+
+    return { ok: response == 0, cancel: response != 0 };
+}