@talex-touch/utils 1.0.0

package/channel/index.ts

@@ -0,0 +1,94 @@
+export enum ChannelType {
+  MAIN = "main",
+  PLUGIN = "plugin"
+}
+
+export enum DataCode {
+  SUCCESS = 200,
+  NETWORK_ERROR = 500,
+  ERROR = 100
+}
+
+export interface ITouchChannel {
+  
+  /**
+   * Register a channel
+   * @description Register a channel, and return a function to cancel the registration
+   * @param type {@link ChannelType} The type of channel
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType
+   * @param callback {Function} The callback function
+   */
+  regChannel(type: ChannelType, eventName: string, callback: Function): () => void
+
+  /**
+   * Send a message to a channel
+   * @param type {@link ChannelType} The type of channel
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
+   * @param arg {any} The arguments of the message
+   */
+  send(type: ChannelType, eventName: string, arg?: any): Promise<any>
+}
+
+export interface ITouchClientChannel {
+  
+  /**
+   * Register a channel
+   * @description Register a channel, and return a function to cancel the registration
+   * @param type {@link ChannelType} The type of channel
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType
+   * @param callback {Function} The callback function
+   */
+  regChannel(eventName: string, callback: Function): () => void
+
+  /**
+   * Send a message to a channel
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
+   * @param arg {any} The arguments of the message
+   */
+  send(eventName: string, arg?: any): Promise<any>
+
+  /**
+   * Send a message to a channel and get the response
+   * @param eventName {string} The name of event, must be unique in the channel {@link ChannelType}
+   * @param arg {any} The arguments of the message
+   */
+  sendSync(eventName: string, arg?: any): any
+}
+
+export interface RawChannelSyncData {
+  timeStamp: number
+  /**
+   * The sync-data timeout
+   * @description The unit is milliseconds, and set it to 0 to cancel it.
+   * @default 10000
+   */
+  timeout: 10000
+
+  /**
+   * The sync-data unique id
+   * @description To identify each sync-request.
+   */
+  id: string
+}
+
+export interface RawChannelHeaderData {
+  status: 'reply' | 'request'
+  type: ChannelType
+  _originData?: any
+}
+
+export interface RawChannelData {
+  name: string
+  header: RawChannelHeaderData
+  sync?: RawChannelSyncData
+}
+
+export interface RawStandardChannelData extends RawChannelData {
+  code: DataCode
+  data?: any
+  plugin?: string
+}
+
+export interface StandardChannelData extends RawStandardChannelData {
+  reply: (code: DataCode, data: any, options?: any) => void
+}

package/common/index.ts

@@ -0,0 +1,39 @@
+export async function sleep(time: number) {
+    return new Promise(resolve => setTimeout(() => resolve(time), time))
+}
+
+export function anyStr2Num(str: string): BigInt {
+    const numbers = new Array<String>
+    let minium = Infinity
+
+    for (let index = 0; index < str.length; index++) {
+        const e = +str.charCodeAt(index);
+
+        numbers.push(("" + e).padStart(5, "0"))
+
+        if ( minium > e ) minium = e
+        
+    }
+
+    // each number transform
+    numbers.forEach((e, i) => numbers[i] = (BigInt(+e) - BigInt(minium)).toString().padStart(2, "0"))
+
+    return BigInt(`${minium}000${BigInt(+numbers.join(""))}`)
+}
+
+export function num2anyStr(num: BigInt): string {
+    const strs = num.toString().split("000")
+    const baseNum = +strs[0]
+    const length = +strs[1].length / 2
+
+    let text = ''
+
+    for ( let i = 0; i < length; i++ ) {
+        const str = strs[1].slice(i * 2, i * 2 + 2)
+
+        // strs[1] = strs[1].replace(str, (BigInt(+str) + BigInt(baseNum)).toString().padStart(5, "0"))
+        text += String.fromCharCode(+str + baseNum)
+    }
+
+    return text
+}

package/eventbus/index.ts

@@ -0,0 +1,87 @@
+export type EventHandler = (event: ITouchEvent) => void;
+
+export interface EventHandlerWrapper {
+  /**
+   * Event handler
+   */
+  handler: EventHandler;
+
+  /**
+   * Event type
+   * @see EventType
+   * @default EventType.PERSIST (must be, if implements)
+   */
+  type?: EventType;
+}
+
+export enum EventType {
+  PERSIST,
+  CONSUME,
+}
+
+export interface ITouchEvent<E = any> {
+  /**
+   * Event name
+   */
+  name: E;
+
+  /**
+   * Event data
+   */
+  data?: any;
+}
+
+export interface ITouchEventBus<E> {
+  map: Map<E, Set<EventHandlerWrapper>>;
+
+  /**
+   * Subscribe touch-app events (any kind of events extends from TouchEvent)
+   * @param event EventName (extends from TouchEvent)
+   * @param handler Event handler (extends from EventHandler)
+   * @returns true if the event was added, otherwise false
+   */
+  on(event: E, handler: EventHandler): boolean;
+
+  /**
+   * Subscribe touch-app events (any kind of events extends from TouchEvent)
+   * @param event EventName (extends from TouchEvent)
+   * @param handler Event handler (extends from EventHandler)
+   * @returns true if the event was added, otherwise false
+   */
+  once(event: E, handler: EventHandler): boolean;
+
+  /**
+   * UnSubscribe touch-app events (any kind of events extends from TouchEvent)
+   * @param event EventName (extends from TouchEvent)
+   * @param handler Event handler (extends from EventHandler)
+   * @returns true if the event was removed, otherwise false
+   * @example
+   * ```ts
+   * const handler = (event: TouchEvent) => {
+   *    console.log(event)
+   * }
+   */
+  off<T extends ITouchEvent>(event: E, handler: EventHandler): boolean;
+
+  /**
+   * UnSubscribe touch-app events all matched (any kind of events extends from TouchEvent)
+   * @param event EventName (extends from TouchEvent)
+   * @returns true if the event was added, otherwise false
+   */
+  offAll(event: E): boolean;
+
+  /**
+   * UnSubscribe touch-app events all matched (any kind of events extends from TouchEvent)
+   * @param event EventName (extends from TouchEvent)
+   * @param handler Event handler (extends from EventHandler)
+   * @returns true if the event was added, otherwise false
+   */
+  off<T extends ITouchEvent>(event: E, handler: EventHandler): boolean;
+
+  /**
+   * Emit touch-app events (any kind of events extends from TouchEvent)
+   * @param event EventName (extends from TouchEvent)
+   * @param data Event data (extends from TouchEvent)
+   */
+  emit<T extends ITouchEvent<E>>(event: E, data: T): void;
+}

package/help/tree-generator.ts

@@ -0,0 +1,38 @@
+import fse from "fs-extra";
+import path from "path";
+import fs from "fs";
+
+export function genFileTree(basePath: string, depth: number = 0, options = {
+  maxDepth: 1,
+  ignores: [
+    "node_modules",
+    ".git",
+    ".vscode",
+    ".idea",
+    ".github",
+    ".gitignore"
+  ]
+}) {
+  if (depth > options.maxDepth) return;
+  const name = path.basename(basePath);
+
+  if (options.ignores.includes(name)) return;
+
+  if (depth === 0) {
+    console.log("Touch tree helper: ");
+    console.log(` > ${name}:`);
+  }
+
+
+  fse.readdirSync(basePath).forEach((file) => {
+    const fullPath = path.join(basePath, file);
+    const stat = fs.statSync(fullPath);
+
+    if (stat.isDirectory()) {
+      console.log(`   ├${"─".repeat(depth + 2)} ${file}:`);
+      genFileTree(fullPath, depth + 1);
+    } else {
+      console.log(`       ├${"─".repeat(depth * 2 )} ${file}`);
+    }
+  });
+}

package/package.json

@@ -0,0 +1,29 @@
+{
+  "main": "./index.ts",
+  "name": "@talex-touch/utils",
+  "author": "TalexDreamSoul",
+  "module": "./index.ts",
+  "license": "MPL-2.0",
+  "private": false,
+  "version": "1.0.0",
+  "scripts": {
+    "publish": "npm publish --access public"
+  },
+  "keywords": [
+    "vue",
+    "electron",
+    "talex-touch"
+  ],
+  "repository": {
+    "url": "https://github.com/talex-touch/talex-touch.git",
+    "type": "git"
+  },
+  "description": "TalexTouch series utils",
+  "dependencies": {
+    "vue": "^3.2.47"
+  },
+  "peerDependencies": {
+    "vue": "^3.2.47",
+    "electron": "^24.4.0"
+  }
+}

package/plugin/channel.ts

@@ -0,0 +1,182 @@
+const { ipcRenderer, IpcMainEvent } = require("electron");
+import {
+  ChannelType,
+  DataCode,
+  ITouchClientChannel,
+  RawChannelSyncData,
+  RawStandardChannelData,
+  StandardChannelData,
+} from "./../channel";
+
+class TouchChannel implements ITouchClientChannel {
+  channelMap: Map<string, Function[]> = new Map();
+
+  pendingMap: Map<string, Function> = new Map();
+
+  plugin: string;
+
+  constructor(pluginName: string) {
+    this.plugin = pluginName;
+
+    ipcRenderer.on("@main-process-message", this.__handle_main.bind(this));
+  }
+
+  __parse_raw_data(e, arg): RawStandardChannelData | null {
+    // console.log("Raw data: ", arg, e);
+    if (arg) {
+      const { name, header, code, plugin, data, sync } = arg;
+
+      if (header) {
+        return {
+          header: {
+            status: header.status || "request",
+            type: ChannelType.PLUGIN,
+            _originData: arg,
+          },
+          sync,
+          code,
+          data,
+          plugin,
+          name: name as string,
+        };
+      }
+    }
+
+    console.error(e, arg);
+    return null;
+    // throw new Error("Invalid message!");
+  }
+
+  __handle_main(e: typeof IpcMainEvent, arg: any): any {
+    const rawData = this.__parse_raw_data(e, arg);
+    if ( !rawData ) return
+
+    if ( rawData.header.status === 'reply' && rawData.sync ) {
+      const { id } = rawData.sync;
+
+      return this.pendingMap.get(id)?.(rawData);
+    }
+
+    if ( rawData.plugin !== this.plugin ) return
+
+    this.channelMap.get(rawData.name)?.forEach((func) => {
+      const handInData: StandardChannelData = {
+        reply: (code: DataCode, data: any, options: any) => {
+          e.sender.send(
+            "@main-process-message",
+            this.__parse_sender(code, rawData, data, rawData.sync)
+          );
+        },
+        ...rawData,
+      };
+
+      const res = func(handInData);
+
+      if (res && res instanceof Promise) return;
+
+      handInData.reply(DataCode.SUCCESS, res);
+    });
+  }
+
+  __parse_sender(
+    code: DataCode,
+    rawData: RawStandardChannelData,
+    data: any,
+    sync?: RawChannelSyncData
+  ): RawStandardChannelData {
+    return {
+      code,
+      data,
+      sync: !sync
+        ? undefined
+        : {
+            timeStamp: new Date().getTime(),
+            // reply sync timeout should follow the request timeout, unless user set it.
+            timeout: sync.timeout,
+            id: sync.id,
+          },
+      name: rawData.name,
+      header: {
+        status: "reply",
+        type: rawData.header.type,
+        _originData: rawData.header._originData,
+      },
+    };
+  }
+
+  regChannel(
+    eventName: string,
+    callback: Function
+  ): () => void {
+    const listeners = this.channelMap.get(eventName) || [];
+
+    if (!listeners.includes(callback)) {
+      listeners.push(callback);
+    } else return () => void 0;
+
+    this.channelMap.set(eventName, listeners);
+
+    return () => {
+      const index = listeners.indexOf(callback);
+
+      if (index !== -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }
+
+  send(eventName: string, arg: any): Promise<any> {
+    const uniqueId = `${new Date().getTime()}#${eventName}@${Math.random().toString(
+      12
+    )}`;
+
+    const data = {
+      code: DataCode.SUCCESS,
+      data: arg,
+      sync: {
+        timeStamp: new Date().getTime(),
+        timeout: 10000,
+        id: uniqueId,
+      },
+      name: eventName,
+      plugin: this.plugin,
+      header: {
+        status: "request",
+        type: ChannelType.PLUGIN,
+      },
+    } as RawStandardChannelData;
+
+    return new Promise((resolve) => {
+      
+      ipcRenderer.send("@main-process-message", data);
+
+      this.pendingMap.set(uniqueId, (res) => {
+        this.pendingMap.delete(uniqueId);
+
+        resolve(res.data);
+      });
+    });
+  }
+
+  sendSync(eventName: string, arg?: any): any {
+    const data = {
+      code: DataCode.SUCCESS,
+      data: arg,
+      name: eventName,
+      plugin: this.plugin,
+      header: {
+        status: "request",
+        type: ChannelType.PLUGIN,
+      },
+    } as RawStandardChannelData;
+
+    const res = this.__parse_raw_data(null, ipcRenderer.sendSync("@main-process-message", data))!
+    
+    if ( res.header.status === 'reply' ) return res.data;
+
+    return res;
+
+  }
+}
+
+export const touchChannel: ITouchClientChannel = window['$channel'] = new TouchChannel(window.$plugin.name);

package/plugin/index.ts

@@ -0,0 +1,56 @@
+export enum PluginStatus {
+  DISABLED,
+  DISABLING,
+  
+  CRASHED,
+
+  ENABLED,
+  ACTIVE,
+  
+  LOADING,
+  LOADED
+}
+
+export interface IPluginIcon {
+  type: string | 'remixicon'
+  value: any
+}
+
+export interface IPluginBaseInfo {
+  name: string
+  readme: string
+  version: string
+  desc: string
+  icon: IPluginIcon
+}
+
+export interface IPluginDev {
+  enable: boolean
+  address: string
+}
+
+export interface IPluginWebview {
+}
+
+export interface ITouchPlugin extends IPluginBaseInfo {
+  dev: IPluginDev
+  webViewInit: boolean
+  webview: IPluginWebview
+
+  get status(): PluginStatus
+  set status(v: PluginStatus)
+
+  enable(): Promise<boolean>
+  disable(): Promise<boolean>
+}
+
+export interface IPluginManager {
+  plugins: Map<string, ITouchPlugin>
+  active: string | null
+  pluginPath: string
+
+  setActivePlugin(pluginName: string): boolean
+  
+  loadPlugin(pluginName: string): Promise<boolean>
+  unloadPlugin(pluginName: string): Promise<boolean>
+}

package/plugin/preload.ts

@@ -0,0 +1,34 @@
+import { touchChannel } from "./channel";
+
+// window type
+declare global {
+  export interface Window {
+    $plugin: {
+      name: string;
+      path: Object;
+    };
+    $send: (type: string, data: any) => void;
+    $sendSync: (type: string, data: any) => Promise<any>;
+    $regChannel: (type: string, callback: Function) => void;
+    $crash: (message: string, extraData: any) => void;
+    $config: {
+      themeStyle: any;
+    };
+  }
+}
+
+export function init(window: Window) {
+  const plugin = window.$plugin;
+  if (!plugin)
+    throw new Error("Plugin has a fatal error! Please check your plugin!");
+
+  window.$crash = function(message, extraData) {
+    window.$send("crash", { message, ...extraData });
+  };
+}
+
+export function initBridge(window: Window) {
+  window.$send = touchChannel.send;
+  window.$sendSync = touchChannel.sendSync;
+  window.$regChannel = touchChannel.regChannel;
+}

package/renderer/ref.ts

@@ -0,0 +1,55 @@
+import { computed, customRef } from 'vue'
+
+export function useModelWrapper(props: any, emit: any, name = 'modelValue') {
+  return computed({
+      get: () => props[name],
+      set: (value) => emit(`update:${name}`, value)
+  })
+}
+
+export function throttleRef(value: any, time: number) {
+
+  let ts = 0
+
+  return customRef((track, trigger) => {
+      return {
+          get() {
+              track()
+              return value
+          },
+          set(newValue) {
+
+              if( new Date().getTime() - ts < time ) return
+
+              value = newValue
+              track()
+              trigger()
+              ts = new Date().getTime()
+          }
+      }
+  })
+
+}
+
+export function debounceRef(value: any, delay: number) {
+
+  let timer: any
+
+  return customRef((track, trigger) => {
+      return {
+          get() {
+              track()
+              return value
+          },
+          set(newValue) {
+              clearTimeout(timer)
+              timer = setTimeout(() => {
+                  value = newValue
+                  track()
+                  trigger()
+              }, delay)
+          }
+      }
+  })
+
+}