@d-mok/quasar-app-extension-quasar-axe 2.0.5 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@d-mok/quasar-app-extension-quasar-axe",
-    "version": "2.0.5",
+    "version": "2.0.6",
     "description": "A Quasar App Extension",
     "author": "d-mok <49301824+d-mok@users.noreply.github.com>",
     "license": "MIT",

package/src/templates/src/boot/axe/components/QxSelect.vue

@@ -19,12 +19,12 @@ const props = withDefaults(
     defineProps<{
         options: any[]
         modelValue: any
-        optionLabel: string | ((_: any) => string)
+        optionLabel?: string | ((_: any) => string)
         ticker?: number
     }>(),
     {
-        ticker: 0,
         optionLabel: $ => String($),
+        ticker: 0,
     }
 )
 const emits = defineEmits(['update:modelValue'])

package/src/templates/src/utils/puppets/core/db.ts

@@ -1,19 +1,11 @@
-import { supabase, HANDLE_ERROR, PostgrestFilterBuilder, PostgrestSingleResponse } from '../../supabase'
+import {
+    supabase,
+    HANDLE_ERROR,
+    PostgrestFilterBuilder,
+    PostgrestSingleResponse,
+} from '../../supabase'
 import { Filter } from '../type'
-
-
-
-
-function chunk<T>(arr: T[], size: number): T[][] {
-    if (size <= 0) return []
-    let newArr = []
-    for (let i = 0; i < arr.length; i += size) {
-        newArr.push(arr.slice(i, i + size))
-    }
-    return newArr
-}
-
-
+import _ from 'lodash'
 
 async function send<R>(q: PostgrestFilterBuilder<R>): Promise<R[]> {
     let { data, error } = await q
@@ -21,73 +13,67 @@ async function send<R>(q: PostgrestFilterBuilder<R>): Promise<R[]> {
     return data
 }
 
-
-async function sendSingle<R>(q: PromiseLike<PostgrestSingleResponse<R>>): Promise<R[]> {
+async function sendSingle<R>(
+    q: PromiseLike<PostgrestSingleResponse<R>>
+): Promise<R[]> {
     let { data, error } = await q
     HANDLE_ERROR(data, error)
     return [data]
 }
 
-
-
-
-function parseFilter<R>(q: PostgrestFilterBuilder<R>, filter: Filter<R>): PostgrestFilterBuilder<R> {
+function parseFilter<R>(
+    q: PostgrestFilterBuilder<R>,
+    filter: Filter<R>
+): PostgrestFilterBuilder<R> {
     if (filter.type === 'eq') q = q.eq(filter.payload.key, filter.payload.val)
     if (filter.type === 'in') q = q.in(filter.payload.key, filter.payload.vals)
-    if (filter.type === 'like') q = q.like(filter.payload.key, filter.payload.pattern)
+    if (filter.type === 'like')
+        q = q.like(filter.payload.key, filter.payload.pattern)
     return q
 }
 
-
-function parseLimit<R>(q: PostgrestFilterBuilder<R>, filter: Filter<R>): PostgrestFilterBuilder<R> {
-    if (filter.type === 'limit')
-        q = q.limit(filter.payload)
+function parseLimit<R>(
+    q: PostgrestFilterBuilder<R>,
+    filter: Filter<R>
+): PostgrestFilterBuilder<R> {
+    if (filter.type === 'limit') q = q.limit(filter.payload)
     return q
 }
 
-
-function parseOrder<R>(q: PostgrestFilterBuilder<R>, filter: Filter<R>): PostgrestFilterBuilder<R> {
+function parseOrder<R>(
+    q: PostgrestFilterBuilder<R>,
+    filter: Filter<R>
+): PostgrestFilterBuilder<R> {
     if (filter.type === 'order')
         q = q.order(filter.payload.key, { ascending: filter.payload.asc })
     return q
 }
 
-
 function parseFilters<R>(
     q: PostgrestFilterBuilder<R>,
     filters: Filter<R>[]
 ): PostgrestFilterBuilder<R> {
-    for (const filter of filters)
-        q = parseFilter(q, filter)
-    for (const filter of filters)
-        q = parseOrder(q, filter)
-    for (const filter of filters)
-        q = parseLimit(q, filter)
+    for (const filter of filters) q = parseFilter(q, filter)
+    for (const filter of filters) q = parseOrder(q, filter)
+    for (const filter of filters) q = parseLimit(q, filter)
     return q
 }
 
-
-
-
 /**
  * I am responsible for providing database operation.
  * Purely functional.
  */
 class DB {
-
     async select<R>(
         table: string,
         fields: (keyof R)[],
         filters: Filter<R>[]
     ): Promise<R[]> {
-        let q = supabase
-            .from<R>(table)
-            .select(fields.join(','))
+        let q = supabase.from<R>(table).select(fields.join(','))
         q = parseFilters(q, filters)
         return send(q)
     }
 
-
     async selectIn<R, K extends keyof R>(
         table: string,
         fields: (keyof R)[],
@@ -103,78 +89,57 @@ class DB {
             q = parseFilters(q, filters)
             return send(q)
         }
-        let promises = chunk(vals, 100).map(getRows)
+        let promises = _.chunk(vals, 100).map(getRows)
         let result = await Promise.all(promises)
         return result.flat()
     }
 
-
     async rpc<R>(
         fn: string,
         param: object,
         filters: Filter<R>[]
     ): Promise<R[]> {
-        let q = supabase
-            .rpc<R>(fn, param)
+        let q = supabase.rpc<R>(fn, param)
         q = parseFilters(q, filters)
         return send(q)
     }
 
-
-
-    async insert<R>(
-        table: string,
-        rows: Partial<R>[]
-    ): Promise<R[]> {
-        let q = supabase
-            .from<R>(table)
-            .insert(rows)
+    async insert<R>(table: string, rows: Partial<R>[]): Promise<R[]> {
+        let q = supabase.from<R>(table).insert(rows)
         return send(q)
     }
 
-
     async update<R, K extends keyof R>(
         table: string,
         idKey: K,
         idVal: R[K],
         row: Partial<R>
     ): Promise<R[]> {
-        let q = supabase
-            .from<R>(table)
-            .update(row)
-            .eq(idKey, idVal)
-            .single()
+        let q = supabase.from<R>(table).update(row).eq(idKey, idVal).single()
         return sendSingle(q)
     }
 
-
     async delete<R, K extends keyof R>(
         table: string,
         idKey: K,
         idVal: R[K]
     ): Promise<R[]> {
-        let q = supabase
-            .from<R>(table)
-            .delete()
-            .eq(idKey, idVal)
-            .single()
+        let q = supabase.from<R>(table).delete().eq(idKey, idVal).single()
         return sendSingle(q)
     }
 
-
     async upsert<R, K extends keyof R>(
         table: string,
         idKey: K,
         row: Partial<R>,
         conflictKeys: (keyof R)[]
     ): Promise<R[]> {
-
         let conflict: any = {}
         for (let f of conflictKeys) {
             conflict[f] = row[f]
         }
 
-        let q = supabase.from<R>(table).select("*").match(conflict)
+        let q = supabase.from<R>(table).select('*').match(conflict)
         let data = await send(q)
 
         if (data.length > 1)
@@ -186,11 +151,7 @@ class DB {
         } else {
             return await this.insert(table, [row])
         }
-
     }
-
-
 }
 
-
-export const db = new DB()
+export const db = new DB()

package/src/templates/src/boot/axe/components/QxSelectText.vue

@@ -1,34 +0,0 @@
-<template>
-    <q-select
-        v-model="selected"
-        :options="options"
-        v-bind="$attrs"
-    />
-</template>
-
-<script
-    lang="ts"
-    setup
->
-import { watch } from 'vue'
-import { useVModel } from '@vueuse/core'
-
-const props = defineProps<{
-    options: string[]
-    modelValue: string
-}>()
-
-const emits = defineEmits(['update:modelValue'])
-
-const selected = useVModel(props, 'modelValue', emits)
-
-function rePick() {
-    if (props.options.length === 0) return
-
-    if (!props.options.includes(selected.value))
-        selected.value = props.options[0]
-}
-
-rePick()
-watch(() => props.options, rePick)
-</script>