x-essential-lib 0.1.0 → 0.1.1

package/src/index.ts

@@ -0,0 +1,38 @@
+import XConfirmDlg from './components/confirmDlg/index.vue'
+import XLoading from './components/loading/index.vue'
+import XMessage from './components/message/index.vue'
+import XPromptDlg from './components/promptDlg/index.vue'
+import XWaitDlg from './components/waitDlg/index.vue'
+import { waitMs, waitUtil } from './utils/core'
+import {
+  openConfirmDlg,
+  openPromptDlg,
+  openWaitDlg,
+  closeWaitDlg
+} from './utils/dialog'
+import {
+  messageError,
+  messageInfo,
+  messageSuccess,
+  messageWarning
+} from './utils/message'
+import { appAppear } from './utils/misc'
+
+export {
+  XConfirmDlg,
+  XLoading,
+  XMessage,
+  XPromptDlg,
+  XWaitDlg,
+  waitMs,
+  waitUtil,
+  openConfirmDlg,
+  openPromptDlg,
+  openWaitDlg,
+  closeWaitDlg,
+  messageError,
+  messageInfo,
+  messageSuccess,
+  messageWarning,
+  appAppear
+}

package/src/main.ts

@@ -0,0 +1,5 @@
+import { createApp } from 'vue'
+import App from './App.vue'
+import vuetify from './plugins/vuetify'
+
+createApp(App).use(vuetify).mount('#app')

package/src/plugins/vuetify.ts

@@ -0,0 +1,4 @@
+import 'vuetify/styles'
+import { createVuetify } from 'vuetify'
+
+export default createVuetify({})

package/src/utils/core.ts

@@ -0,0 +1,31 @@
+import mitt from 'mitt'
+
+export const eventBus = mitt()
+
+export async function waitMs(ms: number): Promise<void> {
+  return new Promise(resolve => {
+    setTimeout(resolve, ms)
+  })
+}
+
+export async function waitUtil(
+  conditionFunc: () => boolean,
+  timeout?: number,
+  interval?: number
+): Promise<boolean> {
+  const timestamp = Date.now()
+  return new Promise((resolve: any) => {
+    const check = async () => {
+      if (conditionFunc()) {
+        resolve(true)
+      } else {
+        if (timeout && Date.now() - timestamp > timeout) {
+          resolve(false)
+        } else {
+          setTimeout(check, interval ?? 30)
+        }
+      }
+    }
+    check()
+  })
+}

package/src/utils/dialog.ts

@@ -0,0 +1,87 @@
+import { eventBus, waitUtil } from './core'
+
+let lastTime: number = Date.now()
+
+function tryCooldown(): boolean {
+  const now = Date.now()
+  if (now - lastTime > 500) {
+    lastTime = now
+    return true
+  }
+  return false
+}
+
+let sequence: number = 0
+
+function getSequence(): number {
+  return ++sequence
+}
+
+interface ButtonOptions {
+  color?: string
+  text?: string
+}
+
+interface ConfirmParams {
+  title: string
+  text: string
+  cancel?: ButtonOptions
+  confirm?: ButtonOptions
+}
+
+export async function openConfirmDlg(
+  params: ConfirmParams
+): Promise<boolean | undefined> {
+  if (!tryCooldown()) {
+    return
+  }
+  let resp: boolean = false
+  let result: boolean | undefined
+  const onResult = (res: unknown) => {
+    result = res as boolean
+    resp = true
+  }
+  const seq = getSequence()
+  eventBus.on('confirmDlgResult' + seq, onResult)
+  eventBus.emit('confirmDlg', { ...params, seq })
+  await waitUtil(() => resp)
+  eventBus.off('confirmDlgResult' + seq, onResult)
+  return result
+}
+
+interface PromptParams {
+  title: string
+  text?: string
+  label?: string
+  placeholder?: string
+  rules?: ((val: string) => string | boolean)[]
+  value?: string
+  cancel?: ButtonOptions
+  confirm?: ButtonOptions
+}
+
+export async function openPromptDlg(params: PromptParams): Promise<any> {
+  if (!tryCooldown()) {
+    return
+  }
+  let resp: boolean = false
+  let result: any
+  const onResult = (res: any) => {
+    result = res
+    resp = true
+  }
+  const seq = getSequence()
+  eventBus.on('promptDlgResult' + seq, onResult)
+  eventBus.emit('promptDlg', { ...params, seq })
+  await waitUtil(() => resp)
+  eventBus.off('promptDlgResult' + seq, onResult)
+  return result
+}
+
+export function openWaitDlg() {
+  eventBus.emit('openWaitDlg')
+}
+
+export function closeWaitDlg() {
+  eventBus.emit('closeWaitDlg')
+}

package/src/utils/message.ts

@@ -0,0 +1,17 @@
+import { eventBus } from './core'
+
+export function messageError(text: string, timeout?: number) {
+  eventBus.emit('message', { type: 'error', text, timeout })
+}
+
+export function messageInfo(text: string, timeout?: number) {
+  eventBus.emit('message', { type: 'info', text, timeout })
+}
+
+export function messageSuccess(text: string, timeout?: number) {
+  eventBus.emit('message', { type: 'success', text, timeout })
+}
+
+export function messageWarning(text: string, timeout?: number) {
+  eventBus.emit('message', { type: 'warning', text, timeout })
+}

package/src/utils/misc.ts

@@ -0,0 +1,23 @@
+declare let window: any
+
+export function appAppear(name: string) {
+  // 忽略第一次动画
+  if (!window.appAppear) {
+    window.appAppear = true
+    return
+  }
+  const fullname = 'single-spa-application:' + name
+  const classList = document.getElementById(fullname)?.classList
+  if (!classList) {
+    return
+  }
+  classList.remove('app-left', 'app-right', 'app-reset')
+  if (window.routeExtras?.forward) {
+    classList.add('app-left')
+  } else {
+    classList.add('app-right')
+  }
+  setTimeout(() => {
+    classList.add('app-reset')
+  }, 0)
+}

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "Node",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "preserve",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.tsx", "src/**/*.vue"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/tsconfig.node.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}

package/vite.config.ts

@@ -0,0 +1,37 @@
+import { defineConfig } from 'vite'
+import { fileURLToPath, URL } from 'node:url'
+import vue from '@vitejs/plugin-vue'
+import cssInjectedByJs from 'vite-plugin-css-injected-by-js'
+
+// https://vitejs.dev/config/
+export default () => {
+  return defineConfig({
+    plugins: [vue(), cssInjectedByJs()],
+    define: { 'process.env': {} },
+    resolve: {
+      alias: {
+        '@': fileURLToPath(new URL('./src', import.meta.url))
+      }
+    },
+    server: {
+      port: 3333
+    },
+    build: {
+      lib: {
+        entry: 'src/index.ts',
+        formats: ['es'],
+        fileName: 'index'
+      },
+      rollupOptions: {
+        external: ['vue', 'vuetify'],
+        output: {
+          globals: {
+            vue: 'Vue',
+            vuetify: 'Vuetify'
+          }
+        }
+      },
+      emptyOutDir: true
+    }
+  })
+}

package/dist/index.es.js

@@ -1,36 +0,0 @@
-function o(i) {
-  return { all: i = i || /* @__PURE__ */ new Map(), on: function(t, n) {
-    var e = i.get(t);
-    e ? e.push(n) : i.set(t, [n]);
-  }, off: function(t, n) {
-    var e = i.get(t);
-    e && (n ? e.splice(e.indexOf(n) >>> 0, 1) : i.set(t, []));
-  }, emit: function(t, n) {
-    var e = i.get(t);
-    e && e.slice().map(function(s) {
-      s(n);
-    }), (e = i.get("*")) && e.slice().map(function(s) {
-      s(t, n);
-    });
-  } };
-}
-const a = o();
-async function u(i) {
-  return new Promise((t) => {
-    setTimeout(t, i);
-  });
-}
-async function f(i, t, n) {
-  const e = Date.now();
-  return new Promise((s) => {
-    const c = async () => {
-      i() ? s(!0) : t && Date.now() - e > t ? s(!1) : setTimeout(c, n ?? 30);
-    };
-    c();
-  });
-}
-export {
-  a as eventBus,
-  u as waitMs,
-  f as waitUtil
-};

package/types/index.d.ts

@@ -1,2 +0,0 @@
-import { eventBus, waitMs, waitUtil } from './utils/core';
-export { eventBus, waitMs, waitUtil };

package/types/utils/core.d.ts

@@ -1,3 +0,0 @@
-export declare const eventBus: import("mitt").Emitter<Record<import("mitt").EventType, unknown>>;
-export declare function waitMs(ms: number): Promise<void>;
-export declare function waitUtil(conditionFunc: () => boolean, timeout?: number, interval?: number): Promise<boolean>;