@talex-touch/utils 1.0.3 → 1.0.6

package/channel/index.ts

@@ -15,7 +15,7 @@ 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 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: (data: StandardChannelData) => any): () => void

package/eventbus/index.ts

@@ -40,7 +40,7 @@ export interface ITouchEventBus<E> {
    * @param handler Event handler (extends from EventHandler)
    * @returns true if the event was added, otherwise false
    */
-  on(event: E, handler: EventHandler): boolean;
+  on(event: E, handler: EventHandler): boolean | void;
 
   /**
    * Subscribe touch-app events (any kind of events extends from TouchEvent)
@@ -48,7 +48,7 @@ export interface ITouchEventBus<E> {
    * @param handler Event handler (extends from EventHandler)
    * @returns true if the event was added, otherwise false
    */
-  once(event: E, handler: EventHandler): boolean;
+  once(event: E, handler: EventHandler): boolean | void;
 
   /**
    * UnSubscribe touch-app events (any kind of events extends from TouchEvent)

package/package.json

@@ -1,29 +1,29 @@
-{
-  "main": "./index.ts",
-  "name": "@talex-touch/utils",
-  "author": "TalexDreamSoul",
-  "module": "./index.ts",
-  "license": "MPL-2.0",
-  "private": false,
-  "version": "1.0.3",
-  "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"
-  }
-}
+{
+  "main": "./index.ts",
+  "name": "@talex-touch/utils",
+  "author": "TalexDreamSoul",
+  "module": "./index.ts",
+  "license": "MPL-2.0",
+  "private": false,
+  "version": "1.0.6",
+  "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.3.4"
+  },
+  "peerDependencies": {
+    "vue": "^3.2.47",
+    "electron": "^24.4.0"
+  }
+}

package/permission/index.ts

@@ -0,0 +1,49 @@
+export interface Permission {
+  /**
+   * permission id
+   */
+  id: symbol;
+
+  /**
+   * permission name
+   */
+  name: string;
+
+  /**
+   * permission description
+   */
+  description: string;
+}
+
+export interface IPermissionCenter {
+  /**
+   * add a permission
+   * @param pluginScope plugin name
+   * @param permission permission
+   * @throws if permission already exists
+   */
+  addPermission(pluginScope: string, permission: Permission): void;
+
+  /**
+   * remove a permission
+   * @param pluginScope plugin name
+   * @param permission permission
+   * @throws if permission not exists
+   */
+  delPermission(pluginScope: string, permission: Permission): void;
+
+  /**
+   * if pluginScope has permission
+   * @param pluginScope plugin name
+   * @param permission permission
+   */
+  hasPermission(pluginScope: string, permission: Permission): boolean;
+
+  /**
+   * get permission
+   * @param pluginScope plugin name
+   * @param permission permission id
+   * @returns permission
+   */
+  getPermission(pluginScope: string, permission: symbol): Permission;
+}

package/plugin/channel.ts

@@ -18,13 +18,13 @@ class TouchChannel implements ITouchClientChannel {
   constructor(pluginName: string) {
     this.plugin = pluginName;
 
-    ipcRenderer.on("@main-process-message", this.__handle_main.bind(this));
+    ipcRenderer.on("@plugin-process-message", this.__handle_main.bind(this));
   }
 
-  __parse_raw_data(e, arg): RawStandardChannelData | null {
-    // console.log("Raw data: ", arg, e);
+  __parse_raw_data(e: typeof IpcMainEvent, arg: any): RawStandardChannelData | null {
+    console.log("Raw data: ", arg, e);
     if (arg) {
-      const { name, header, code, plugin, data, sync } = arg;
+      const { name, header, code, data, sync } = arg;
 
       if (header) {
         return {
@@ -36,7 +36,6 @@ class TouchChannel implements ITouchClientChannel {
           sync,
           code,
           data,
-          plugin,
           name: name as string,
         };
       }
@@ -47,7 +46,8 @@ class TouchChannel implements ITouchClientChannel {
     // throw new Error("Invalid message!");
   }
 
-  __handle_main(e: typeof IpcMainEvent, arg: any): any {
+  __handle_main(e: typeof IpcMainEvent, _arg: any): any {
+    const arg = JSON.parse(_arg)
     const rawData = this.__parse_raw_data(e, arg);
     if ( !rawData ) return
 
@@ -57,13 +57,13 @@ class TouchChannel implements ITouchClientChannel {
       return this.pendingMap.get(id)?.(rawData);
     }
 
-    if ( rawData.plugin !== this.plugin ) return
+    // if ( rawData.plugin !== this.plugin ) return
 
     this.channelMap.get(rawData.name)?.forEach((func) => {
       const handInData: StandardChannelData = {
-        reply: (code: DataCode, data: any, options: any) => {
+        reply: (code: DataCode, data: any) => {
           e.sender.send(
-            "@main-process-message",
+            "@plugin-process-message",
             this.__parse_sender(code, rawData, data, rawData.sync)
           );
         },
@@ -148,9 +148,9 @@ class TouchChannel implements ITouchClientChannel {
 
     return new Promise((resolve) => {
       
-      ipcRenderer.send("@main-process-message", data);
+      ipcRenderer.send("@plugin-process-message", data);
 
-      this.pendingMap.set(uniqueId, (res) => {
+      this.pendingMap.set(uniqueId, (res: any) => {
         this.pendingMap.delete(uniqueId);
 
         resolve(res.data);
@@ -170,7 +170,7 @@ class TouchChannel implements ITouchClientChannel {
       },
     } as RawStandardChannelData;
 
-    const res = this.__parse_raw_data(null, ipcRenderer.sendSync("@main-process-message", data))!
+    const res = this.__parse_raw_data(null, ipcRenderer.sendSync("@plugin-process-message", data))!
     
     if ( res.header.status === 'reply' ) return res.data;
 
@@ -179,4 +179,13 @@ class TouchChannel implements ITouchClientChannel {
   }
 }
 
-export const touchChannel: ITouchClientChannel = window['$channel'] = new TouchChannel(window.$plugin.name);
+let touchChannel: ITouchClientChannel
+
+export function genChannel() {
+  if (!touchChannel) {
+    // @ts-ignore
+    touchChannel = window.$channel = new TouchChannel(window.$plugin.name)
+  }
+
+  return touchChannel
+}

package/plugin/index.ts

@@ -68,3 +68,30 @@ export interface IPluginManager {
   loadPlugin(pluginName: string): Promise<boolean>
   unloadPlugin(pluginName: string): Promise<boolean>
 }
+
+export interface IManifest {
+  name: string
+  version: string
+  description: string
+  plugin?: {
+    dev: {
+      enable: boolean
+      address: string
+    }
+  }
+  build?: {
+    files: string[]
+    secret: {
+      pos: string
+      addon: string[]
+    }
+    verify?: {
+      enable: boolean
+      online: 'custom' | 'always' | 'once'
+    }
+    version?: {
+      update: 'auto' | 'ask' | 'readable'
+      downgrade: boolean
+    }
+  }
+}

package/plugin/preload.ts

@@ -1,4 +1,5 @@
-import { touchChannel } from './channel'
+import { genChannel } from './channel'
+import './sdk/index'
 
 // window type
 declare global {
@@ -30,7 +31,9 @@ export function init(window: Window) {
 }
 
 export function initBridge(window: Window) {
-  window.$send = touchChannel.send
-  window.$sendSync = touchChannel.sendSync
-  window.$regChannel = touchChannel.regChannel
+  const touchChannel = genChannel()
+
+  window.$send = touchChannel.send.bind(touchChannel)
+  window.$sendSync = touchChannel.sendSync.bind(touchChannel)
+  window.$regChannel = touchChannel.regChannel.bind(touchChannel)
 }

package/plugin/sdk/common.ts

@@ -0,0 +1,30 @@
+import { genChannel } from '../channel';
+import {
+  BrowserWindowConstructorOptions
+} from "electron";
+
+export function regShortcut(key: string, func: Function) {
+    const channel = genChannel()
+
+    const res = channel.sendSync('shortcon:reg', { key })
+    if ( res instanceof  String ) throw new Error(res)
+    if ( res === false ) return false;
+
+    channel.regChannel('shortcon:trigger', ({ data }) => key === data.key && func())
+
+    return true;
+}
+
+export function createWindow(options: BrowserWindowConstructorOptions & { file?: string } & { url?: string }): number {
+  const res = genChannel().sendSync('window:new', options)
+  if ( res.error ) throw new Error(res.error)
+
+  return res.id
+}
+
+export function toggleWinVisible(id: number, visible?: boolean): boolean {
+    const res = genChannel().sendSync('window:visible', visible !== undefined ? { id, visible } : { id })
+    if ( res.error ) throw new Error(res.error)
+
+    return res.visible
+}

package/plugin/sdk/hooks/index.ts

@@ -0,0 +1 @@
+export * as LifeCycle from './life-cycle'

package/plugin/sdk/hooks/life-cycle.ts

@@ -0,0 +1,96 @@
+import { genChannel } from './../../channel';
+
+export enum LifecycleHooks {
+  ENABLE = 'en',
+  DISABLE = 'di',
+  ACTIVE = 'ac',
+  INACTIVE = 'in',
+  // FORE_PAUSED = 'fp',
+  CRASH = 'cr'
+}
+
+// @ts-ignore
+export function injectHook(type: LifecycleHooks, hook: Function, processFunc = ({ data, reply }) => {
+  // @ts-ignore
+  const hooks: Array<Function> = window.$touchSDK.__hooks[type]
+  if (hooks) {
+    hooks.forEach(hook => hook(data))
+  }
+  reply(true)
+}) {
+  // @ts-ignore
+  const __hooks = window.$touchSDK.__hooks
+  // @ts-ignore
+  const hooks: Array<Function> = __hooks[type] || (__hooks[type] = [])
+
+  if (hooks.length === 0) {
+
+    genChannel().regChannel("@lifecycle:" + type, (obj: any) => {
+
+      processFunc(obj)
+
+      // @ts-ignore
+      delete window.$touchSDK.__hooks[type]
+    })
+
+  }
+
+  const wrappedHook = (data: any) => {
+
+    try {
+
+      hook(data)
+
+    } catch (e) {
+      console.error(`[TouchSDK] ${type} hook error: `, e)
+    }
+
+  }
+
+  hooks.push(wrappedHook)
+
+  return wrappedHook
+}
+
+export const createHook = <T extends Function = (data: any) => any>(type: LifecycleHooks) => (hook: T) => injectHook(type, hook)
+
+/**
+ * The plugin is enabled
+ * When the plugin is enabled, the plugin can be used
+ * @returns void
+ */
+export const onPluginEnable = createHook(LifecycleHooks.ENABLE)
+
+/**
+ * The plugin is disabled
+ * When the plugin is disabled, the plugin can not be used
+ * @returns void
+ */
+export const onPluginDisable = createHook(LifecycleHooks.DISABLE)
+
+/**
+ * The plugin is activated
+ * @returns boolean If return false, the plugin will not be activated (User can force to activate the plugin)
+ */
+export const onPluginActive = createHook(LifecycleHooks.ACTIVE)
+
+/**
+ * The plugin is inactivated
+ * @returns boolean If return false, the plugin will not be inactivated (User can force to inactivate the plugin)
+ */
+export const onPluginInactive = createHook(LifecycleHooks.INACTIVE)
+
+/**
+ * When plugin is in foreground (e.g. plugin is using media, camera, microphone, etc.) But paused by user
+ * For a detail example: User force to stop music playing
+ * @returns void
+ */
+// export const onForePaused = createHook(LifecycleHooks.FORE_PAUSED)
+
+/**
+ * When plugin is crashed
+ * data.message Crash message
+ * data.extraData Crash data
+ * @returns void
+ */
+export const onCrash = createHook(LifecycleHooks.CRASH)

package/plugin/sdk/index.ts

@@ -0,0 +1,13 @@
+import * as HOOKS from './hooks/index'
+
+export interface ITouchSDK {
+  hooks: typeof HOOKS
+  __hooks: {}
+}
+
+// window type
+declare global {
+  export interface Window {
+    $touchSDK: ITouchSDK
+  }
+}

package/plugin/sdk/service/index.ts

@@ -0,0 +1,30 @@
+import { genChannel } from '../../channel';
+import { IService } from "../../../service";
+
+export function regService(service: IService, handler: Function): boolean {
+  const res = !!genChannel().sendSync('service:reg', { service: service.name })
+
+  if (res)
+    onHandleService(service, handler)
+
+  return res
+}
+
+export function unRegService(service: IService): boolean {
+  return !!genChannel().sendSync('service:unreg', { service: service.name })
+}
+
+export function onHandleService(service: IService, handler: Function) {
+  // @ts-ignore
+  genChannel().regChannel('service:handle', ({ data: _data }) => {
+    const { data } = _data
+
+    // console.log('service:handle', data, service)
+
+    if (data.service === service.name) {
+      return handler(data)
+    }
+
+    return false
+  })
+}

package/service/index.ts

@@ -0,0 +1,68 @@
+export interface IService {
+  /**
+   * service id
+   */
+  id: Symbol;
+
+  /**
+   * service name
+   */
+  name: string;
+
+  /**
+   * service description
+   */
+  description: string;
+}
+
+export interface IServiceEvent {
+
+  service: IService;
+
+  setCancelled(cancelled: boolean): void;
+
+  isCancelled(): boolean;
+}
+
+export interface IServiceHandler {
+  /**
+   * The plugin scope of the service handler
+   * @description
+   * When service registered, the service center will use the plugin scope to find the service handler.
+   * If plugin is disabled, the app will automatically enable plugin and hand on the service to the plugin.
+   * When plugin enabled, you must immediately register service handler to the service center, app will waiting for the service handler, until the service handler handled.
+   */
+  pluginScope: string
+
+  /**
+   * Handle the service data
+   * @param data service data
+   */
+  handle(event: IServiceEvent, data: object): any;
+}
+
+export interface IServiceCenter {
+  /**
+   * The service center will register the service
+   * @param service will be registered service
+   * @param handler service handler
+   * @returns register result (true: success, false: fail)
+   */
+  regService(service: IService, handler: IServiceHandler): boolean;
+
+  /**
+   * The service center will unregister the service
+   * @param service will be unregistered service
+   * @returns unregister result (true: success, false: fail)
+   */
+  unRegService(service: IService): boolean;
+
+  /**
+   * Get the service by service id
+   * @param id service id
+   * @returns service
+   */
+  // getService(id: symbol): IService;
+
+  useService(service: IService, data: object): Promise<boolean> | boolean;
+}

package/service/protocol/index.ts

@@ -0,0 +1,78 @@
+import { IService } from './../index';
+
+export abstract class ProtocolService<T extends string> implements IService {
+  id: symbol;
+  name: string;
+  description: string;
+
+  protocol: string[]
+
+  type: T
+
+  constructor(id: symbol, protocol: string[]) {
+    this.id = id;
+    this.name = id.description!;
+    this.description = `${this.name} Protocol Service`;
+    this.protocol = protocol
+
+    this.type = id.description as T
+  }
+}
+
+export const IMAGE_SUFFIX = [
+  'jpg', 'png', 'gif', 'bmp', 'webp', 'svg', 'ico', 'tiff', 'tif', 'jpeg', 'avif'
+]
+
+export class ImageProtocolService extends ProtocolService<'image'> {
+  constructor() {
+    super(Symbol('Image'), IMAGE_SUFFIX)
+  }
+}
+
+export const AUDIO_SUFFIX = [
+  'mp3', 'wav', 'ogg', 'aac', 'flac', 'wma', 'ape', 'm4a', 'm4r', 'm4b', 'm4p', 'm4v', 'mp4', '3gp', 'avi', 'mov', 'wmv', 'flv', 'mkv', 'rmvb', 'rm', 'asf', 'dat', 'mpg', 'mpeg', 'vob', 'f4v', 'm3u8', 'webm', 'ts', 'mts', 'm2ts', 'mts', 'dv', 'divx', 'xvid', 'mpe', 'mod', 'sdp', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts'
+]
+
+export class AudioProtocolService extends ProtocolService<'audio'> {
+  constructor() {
+    super(Symbol('Audio'), AUDIO_SUFFIX)
+  }
+}
+
+export const VIDEO_SUFFIX = [
+  'mp4', '3gp', 'avi', 'mov', 'wmv', 'flv', 'mkv', 'rmvb', 'rm', 'asf', 'dat', 'mpg', 'mpeg', 'vob', 'f4v', 'm3u8', 'webm', 'ts', 'mts', 'm2ts', 'mts', 'dv', 'divx', 'xvid', 'mpe', 'mod', 'sdp', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts', 'm2v', 'm2p', 'm2t', 'm2ts'
+]
+
+export class VideoProtocolService extends ProtocolService<'video'> {
+  constructor() {
+    super(Symbol('Video'), VIDEO_SUFFIX)
+  }
+}
+
+export const TEXT_SUFFIX = [
+  'txt', 'md', 'markdown', 'json', 'js', 'ts', 'html', 'css', 'scss', 'sass', 'less', 'xml', 'yaml', 'yml', 'ini', 'log', 'bat', 'sh', 'cmd', 'c', 'cpp', 'h', 'hpp', 'java', 'py', 'go', 'php', 'sql', 'swift', 'vb', 'vbs', 'lua', 'rb', 'r', 'cs', 'm', 'mm', 'pl', 'perl', 'asm', 'asmx', 'inc', 'coffee', 'ts', 'tsx', 'jsx', 'vue', 'php', 'php3', 'php4', 'php5', 'php7', 'phps', 'phtml', 'pht', 'phar', 'phpt', 'php-cgi', 'php-cs-fixer', 'phpunit', 'phpunit.xml', 'phpunit.xml.dist', 'phpunit.phar', 'phpunit.phar.dist', 'phpunit-4.8.36.phar', 'phpunit-4.8.36.phar.dist', 'phpunit-5.7.27.phar', 'phpunit-5.7.27.phar.dist', 'phpunit-6.5.14.phar', 'phpunit-6.5.14.phar.dist', 'phpunit-7.5.20.phar', 'phpunit-7.5.20.phar.dist', 'phpunit-8.5.8.phar', 'phpunit-8.5.8.phar.dist', 'phpunit-9.3.10.phar', 'phpunit-9.3.10.phar.dist', 'phpunit-9.4.3.phar', 'phpunit-9.4.3.phar.dist', 'phpunit-9.5.0.phar', 'phpunit-9.5.0.phar.dist', 'phpunit-9.5.1.phar', 'phpunit-9.5.1.phar.dist', 'phpunit-9.5.2.phar', 'phpunit-9.5.2.phar.dist', 'phpunit-9.5.4.phar', 'phpunit-9.5.4.phar.dist', 'php'
+]
+
+export class TextProtocolService extends ProtocolService<'text'> {
+  constructor() {
+    super(Symbol('Text'), TEXT_SUFFIX)
+  }
+}
+
+export const serviceSuffixMap = new Map<ProtocolService<string>, string[]>
+
+serviceSuffixMap.set(new ImageProtocolService(), IMAGE_SUFFIX)
+serviceSuffixMap.set(new AudioProtocolService(), AUDIO_SUFFIX)
+serviceSuffixMap.set(new VideoProtocolService(), VIDEO_SUFFIX)
+serviceSuffixMap.set(new TextProtocolService(), TEXT_SUFFIX)
+
+export function suffix2Service(suffix: string): ProtocolService<string> | null {
+
+  for (const [type, suffixes] of serviceSuffixMap.entries()) {
+    if (suffixes.includes(suffix)) {
+      return type
+    }
+  }
+
+  return null
+}