@d-mok/quasar-app-extension-quasar-axe 3.1.1 → 3.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@d-mok/quasar-app-extension-quasar-axe",
-    "version": "3.1.1",
+    "version": "3.1.3",
     "description": "A Quasar App Extension",
     "main": "src/index.js",
     "scripts": {

package/src/templates/src/boot/axe/AutoReg.ts

@@ -9,7 +9,7 @@ function pascal(s: string): string {
 
 console.log('[QuasarAxe] Run Boot AutoReg')
 
-const components = import.meta.globEager('src/**/*.vue')
+const components = import.meta.glob<any>('src/**/*.vue', { eager: true })
 
 export default boot(({ app }) => {
     for (let path in components) {

package/src/templates/src/boot/axe/AutoRoute.ts

@@ -13,14 +13,14 @@ const HOME_ROUTE = process.env.HOME_ROUTE ?? '/'
 
 console.log('[QuasarAxe] Run Boot AutoRoute')
 
-const pages = import.meta.globEager('src/**/pages/**/*.vue')
+const pages = import.meta.glob<any>('src/**/pages/**/*.vue', { eager: true })
 
 const routes = Object.keys(pages).map(path => ({
     path: pascal(path).toLowerCase(),
     component: pages[path].default,
 }))
 
-const _pages = import.meta.globEager('src/**/_*.vue')
+const _pages = import.meta.glob<any>('src/**/_*.vue', { eager: true })
 
 const _routes = Object.keys(_pages).map(path => ({
     path: pascal(path).toLowerCase().replace('_', ''),

package/src/templates/src/utils/puppets/index.ts

@@ -1 +1,214 @@
-export { ORM } from './ORM'
+import {
+    DeleteBuilder,
+    InsertBuilder,
+    SelectBuilder,
+    SelectInBuilder,
+    SelectRPCBuilder,
+    UpdateBuilder,
+    UpsertBuilder,
+} from './builder'
+import { Constructor, Key, BooleanKeys } from './type'
+import { Core } from './core'
+import { reactive } from 'vue'
+
+export function ORM<
+    RBase extends Constructor,
+    K extends Key<InstanceType<RBase>>
+>(RClass: RBase, tableName: string, idKey: K) {
+    type R = InstanceType<RBase>
+
+    class E extends RClass {
+        private _hostTable: InstanceType<ReturnType<typeof getTable>>
+
+        constructor(...args: any[]) {
+            super()
+            let [row, hostTable] = args
+            Object.assign(this, row)
+            this._hostTable = hostTable
+        }
+
+        update(this: E & R, row: Partial<R>) {
+            return this._hostTable.update(this[idKey], row)
+        }
+
+        delete(this: E & R) {
+            return this._hostTable.delete(this[idKey])
+        }
+
+        toggle(this: E & R, key: BooleanKeys<R>) {
+            let val = !this[key]
+            let obj = { [key]: val } as Partial<R>
+            return this._hostTable.update(this[idKey], obj)
+        }
+    }
+
+    function getTable<EBase extends RBase>(EClass: EBase) {
+        type T = InstanceType<EBase>
+
+        function convertor(host: TableClass) {
+            return ($: R) => new EClass($, host) as T
+        }
+
+        function core(host: TableClass) {
+            return new Core<T, R>(
+                tableName,
+                idKey,
+                Object.keys(new RClass()) as Key<R>[],
+                convertor(host)
+            )
+        }
+
+        class TableClass extends Array<InstanceType<EBase>> {
+            /** make reactive */
+            reactive(): this {
+                const rec = reactive(this) as this
+                if (process.env.DEBUGGING) {
+                    // @ts-ignore
+                    globalThis.TABLES.push(rec)
+                }
+                return rec
+            }
+
+            protected onChange(): void {}
+            protected onEdit(): void {}
+            protected onSanitize(row: Partial<R>): Partial<R> {
+                return row
+            }
+
+            select() {
+                let callback = ($: T[]) => {
+                    this.set($)
+                    this.onChange()
+                }
+                return new SelectBuilder(core(this), callback)
+            }
+
+            patch() {
+                let callback = ($: T[]) => {
+                    this.absorb($, idKey)
+                    this.onChange()
+                }
+                return new SelectBuilder(core(this), callback)
+            }
+
+            selectIn<K extends Key<R>>(key: K, vals: R[K][]) {
+                let callback = ($: T[]) => {
+                    this.set($)
+                    this.sortBy($ => vals.indexOf($[key]))
+                    this.onChange()
+                }
+                return new SelectInBuilder(key, vals, core(this), callback)
+            }
+
+            patchIn<K extends Key<R>>(key: K, vals: R[K][]) {
+                let callback = ($: T[]) => {
+                    this.absorb($, idKey)
+                    this.sortBy($ => vals.indexOf($[key]))
+                    this.onChange()
+                }
+                return new SelectInBuilder(key, vals, core(this), callback)
+            }
+
+            selectRPC(param: object = {}) {
+                let callback = ($: T[]) => {
+                    this.set($)
+                    this.onChange()
+                }
+                return new SelectRPCBuilder(param, core(this), callback)
+            }
+
+            patchRPC(param: object = {}) {
+                let callback = ($: T[]) => {
+                    this.absorb($, idKey)
+                    this.onChange()
+                }
+                return new SelectRPCBuilder(param, core(this), callback)
+            }
+
+            selectCustom(rows: R[]) {
+                let convert = core(this).convertor
+                let entities = rows.map(convert)
+                this.set(entities)
+                this.onChange()
+            }
+
+            insert(row: Partial<R>) {
+                row = this.onSanitize(row)
+                let callback = ($: T[]) => {
+                    this.push(...$)
+                    this.onChange()
+                    this.onEdit()
+                }
+                return new InsertBuilder([row], core(this), callback).notify(
+                    'Created!'
+                )
+            }
+
+            insertMany(rows: Partial<R>[]) {
+                rows = rows.map(this.onSanitize)
+                let callback = ($: T[]) => {
+                    this.push(...$)
+                    this.onChange()
+                    this.onEdit()
+                }
+                return new InsertBuilder(rows, core(this), callback).notify(
+                    'Created!'
+                )
+            }
+
+            update(idVal: R[K], row: Partial<R>) {
+                row = this.onSanitize(row)
+                let callback = ($: T[]) => {
+                    this.merge($, idKey)
+                    this.onChange()
+                    this.onEdit()
+                }
+                return new UpdateBuilder(
+                    idVal,
+                    row,
+                    core(this),
+                    callback
+                ).notify('Updated!')
+            }
+
+            delete(idVal: R[K]) {
+                let callback = ($: T[]) => {
+                    this.remove($ => $[idKey] === idVal)
+                    this.onChange()
+                    this.onEdit()
+                }
+                return new DeleteBuilder(idVal, core(this), callback).notify(
+                    'Deleted!'
+                )
+            }
+
+            upsert(row: Partial<R>, conflictKeys: Key<R>[]) {
+                row = this.onSanitize(row)
+                let callback = ($: T[]) => {
+                    this.absorb($, idKey)
+                    this.onChange()
+                    this.onEdit()
+                }
+                return new UpsertBuilder(
+                    row,
+                    conflictKeys,
+                    core(this),
+                    callback
+                ).notify('Updated!')
+            }
+        }
+
+        return TableClass
+    }
+
+    console.dev(
+        `Create Table [${tableName}] idKey [${idKey}] entity [${E.name}]`
+    )
+
+    return { Entity: E, Table: getTable }
+}
+
+if (process.env.DEBUGGING) {
+    // @ts-ignore
+    globalThis.TABLES = []
+}

package/src/templates/src/utils/puppets/test.ts

@@ -1,4 +1,4 @@
-import { ORM } from './ORM'
+import { ORM } from './index'
 
 // example
 

package/src/templates/src/utils/puppets/ORM.ts

@@ -1,214 +0,0 @@
-import {
-    DeleteBuilder,
-    InsertBuilder,
-    SelectBuilder,
-    SelectInBuilder,
-    SelectRPCBuilder,
-    UpdateBuilder,
-    UpsertBuilder,
-} from './builder'
-import { Constructor, Key, BooleanKeys } from './type'
-import { Core } from './core'
-import { reactive } from 'vue'
-
-export function ORM<
-    RBase extends Constructor,
-    K extends Key<InstanceType<RBase>>
->(RClass: RBase, tableName: string, idKey: K) {
-    type R = InstanceType<RBase>
-
-    class E extends RClass {
-        private _hostTable: InstanceType<ReturnType<typeof getTable>>
-
-        constructor(...args: any[]) {
-            super()
-            let [row, hostTable] = args
-            Object.assign(this, row)
-            this._hostTable = hostTable
-        }
-
-        update(this: E & R, row: Partial<R>) {
-            return this._hostTable.update(this[idKey], row)
-        }
-
-        delete(this: E & R) {
-            return this._hostTable.delete(this[idKey])
-        }
-
-        toggle(this: E & R, key: BooleanKeys<R>) {
-            let val = !this[key]
-            let obj = { [key]: val } as Partial<R>
-            return this._hostTable.update(this[idKey], obj)
-        }
-    }
-
-    function getTable<EBase extends RBase>(EClass: EBase) {
-        type T = InstanceType<EBase>
-
-        function convertor(host: TableClass) {
-            return ($: R) => new EClass($, host) as T
-        }
-
-        function core(host: TableClass) {
-            return new Core<T, R>(
-                tableName,
-                idKey,
-                Object.keys(new RClass()) as Key<R>[],
-                convertor(host)
-            )
-        }
-
-        class TableClass extends Array<InstanceType<EBase>> {
-            /** make reactive */
-            reactive(): this {
-                const rec = reactive(this) as this
-                if (process.env.DEBUGGING) {
-                    // @ts-ignore
-                    globalThis.TABLES.push(rec)
-                }
-                return rec
-            }
-
-            protected onChange(): void {}
-            protected onEdit(): void {}
-            protected onSanitize(row: Partial<R>): Partial<R> {
-                return row
-            }
-
-            select() {
-                let callback = ($: T[]) => {
-                    this.set($)
-                    this.onChange()
-                }
-                return new SelectBuilder(core(this), callback)
-            }
-
-            patch() {
-                let callback = ($: T[]) => {
-                    this.absorb($, idKey)
-                    this.onChange()
-                }
-                return new SelectBuilder(core(this), callback)
-            }
-
-            selectIn<K extends Key<R>>(key: K, vals: R[K][]) {
-                let callback = ($: T[]) => {
-                    this.set($)
-                    this.sortBy($ => vals.indexOf($[key]))
-                    this.onChange()
-                }
-                return new SelectInBuilder(key, vals, core(this), callback)
-            }
-
-            patchIn<K extends Key<R>>(key: K, vals: R[K][]) {
-                let callback = ($: T[]) => {
-                    this.absorb($, idKey)
-                    this.sortBy($ => vals.indexOf($[key]))
-                    this.onChange()
-                }
-                return new SelectInBuilder(key, vals, core(this), callback)
-            }
-
-            selectRPC(param: object = {}) {
-                let callback = ($: T[]) => {
-                    this.set($)
-                    this.onChange()
-                }
-                return new SelectRPCBuilder(param, core(this), callback)
-            }
-
-            patchRPC(param: object = {}) {
-                let callback = ($: T[]) => {
-                    this.absorb($, idKey)
-                    this.onChange()
-                }
-                return new SelectRPCBuilder(param, core(this), callback)
-            }
-
-            selectCustom(rows: R[]) {
-                let convert = core(this).convertor
-                let entities = rows.map(convert)
-                this.set(entities)
-                this.onChange()
-            }
-
-            insert(row: Partial<R>) {
-                row = this.onSanitize(row)
-                let callback = ($: T[]) => {
-                    this.push(...$)
-                    this.onChange()
-                    this.onEdit()
-                }
-                return new InsertBuilder([row], core(this), callback).notify(
-                    'Created!'
-                )
-            }
-
-            insertMany(rows: Partial<R>[]) {
-                rows = rows.map(this.onSanitize)
-                let callback = ($: T[]) => {
-                    this.push(...$)
-                    this.onChange()
-                    this.onEdit()
-                }
-                return new InsertBuilder(rows, core(this), callback).notify(
-                    'Created!'
-                )
-            }
-
-            update(idVal: R[K], row: Partial<R>) {
-                row = this.onSanitize(row)
-                let callback = ($: T[]) => {
-                    this.merge($, idKey)
-                    this.onChange()
-                    this.onEdit()
-                }
-                return new UpdateBuilder(
-                    idVal,
-                    row,
-                    core(this),
-                    callback
-                ).notify('Updated!')
-            }
-
-            delete(idVal: R[K]) {
-                let callback = ($: T[]) => {
-                    this.remove($ => $[idKey] === idVal)
-                    this.onChange()
-                    this.onEdit()
-                }
-                return new DeleteBuilder(idVal, core(this), callback).notify(
-                    'Deleted!'
-                )
-            }
-
-            upsert(row: Partial<R>, conflictKeys: Key<R>[]) {
-                row = this.onSanitize(row)
-                let callback = ($: T[]) => {
-                    this.absorb($, idKey)
-                    this.onChange()
-                    this.onEdit()
-                }
-                return new UpsertBuilder(
-                    row,
-                    conflictKeys,
-                    core(this),
-                    callback
-                ).notify('Updated!')
-            }
-        }
-
-        return TableClass
-    }
-
-    console.dev(
-        `Create Table [${tableName}] idKey [${idKey}] entity [${E.name}]`
-    )
-
-    return { Entity: E, Table: getTable }
-}
-
-if (process.env.DEBUGGING) {
-    // @ts-ignore
-    globalThis.TABLES = []
-}