frappe-ui 0.1.98 → 0.1.101

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "frappe-ui",
-  "version": "0.1.98",
+  "version": "0.1.101",
   "description": "A set of components and utilities for rapid UI development",
   "main": "./src/index.js",
   "scripts": {
@@ -60,7 +60,7 @@
     "typescript": "^5.0.2"
   },
   "peerDependencies": {
-    "vue": ">=3.3.0",
+    "vue": ">=3.5.0",
     "vue-router": "^4.1.6"
   },
   "devDependencies": {

package/src/components/FormControl.vue

@@ -29,7 +29,11 @@
       :id="id"
       v-bind="{ ...controlAttrs, size }"
     />
-    <TextInput v-else :id="id" v-bind="{ ...controlAttrs, type, size }">
+    <TextInput
+      v-else
+      :id="id"
+      v-bind="{ ...controlAttrs, type, size, required }"
+    >
       <template #prefix v-if="$slots.prefix">
         <slot name="prefix" />
       </template>

package/src/components/{ListView.story.vue → ListView/ListView.story.vue}

@@ -1,17 +1,16 @@
 <script setup>
 import { reactive, h, ref } from 'vue'
-import Avatar from './Avatar.vue'
-import Badge from './Badge.vue'
-import { Button } from './Button'
-import FeatherIcon from './FeatherIcon.vue'
-import ListHeader from './ListView/ListHeader.vue'
-import ListHeaderItem from './ListView/ListHeaderItem.vue'
-import ListRow from './ListView/ListRow.vue'
-import ListRowItem from './ListView/ListRowItem.vue'
-import ListRows from './ListView/ListRows.vue'
-import ListGroups from './ListView/ListGroups.vue'
-import ListSelectBanner from './ListView/ListSelectBanner.vue'
-import ListView from './ListView/ListView.vue'
+import Avatar from '../Avatar.vue'
+import Badge from '../Badge.vue'
+import { Button } from '../Button'
+import FeatherIcon from '../FeatherIcon.vue'
+import ListHeader from './ListHeader.vue'
+import ListHeaderItem from './ListHeaderItem.vue'
+import ListRow from './ListRow.vue'
+import ListRowItem from './ListRowItem.vue'
+import ListRows from './ListRows.vue'
+import ListSelectBanner from './ListSelectBanner.vue'
+import ListView from './ListView.vue'
 
 const state = reactive({
   selectable: true,

package/src/components/ListView/ListView.vue

@@ -143,4 +143,11 @@ provide(
     toggleAllRows,
   })),
 )
+
+defineExpose({
+  selections,
+  allRowsSelected,
+  toggleRow,
+  toggleAllRows,
+})
 </script>

package/src/components/Tabs/TabList.vue

@@ -0,0 +1,81 @@
+<template>
+  <TabList
+    class="relative flex"
+    :class="
+      vertical
+        ? 'flex-col border-r overflow-y-auto'
+        : 'gap-7.5 border-b overflow-x-auto items-center px-5'
+    "
+  >
+    <Tab
+      ref="tabRef"
+      as="template"
+      v-for="(tab, i) in tabs"
+      :key="i"
+      v-slot="{ selected }"
+      class="focus:outline-none focus:transition-none"
+    >
+      <slot v-bind="{ tab, selected }">
+        <button
+          class="flex items-center gap-1.5 text-base text-ink-gray-5 duration-300 ease-in-out hover:text-ink-gray-9"
+          :class="[
+            selected ? 'text-ink-gray-9' : '',
+            vertical
+              ? 'py-2.5 px-4 border-r border-transparent hover:border-outline-gray-3'
+              : 'py-3 border-b border-transparent hover:border-outline-gray-3',
+          ]"
+        >
+          <component v-if="tab.icon" :is="tab.icon" class="size-4" />
+          {{ tab.label }}
+        </button>
+      </slot>
+    </Tab>
+    <div
+      ref="indicator"
+      class="tab-indicator absolute bg-surface-gray-7"
+      :class="[vertical ? 'right-0 w-px' : 'bottom-0 h-px', transitionClass]"
+    />
+  </TabList>
+</template>
+<script setup>
+import { TabList, Tab } from '@headlessui/vue'
+import { ref, watch, computed, onMounted, nextTick, inject } from 'vue'
+
+const tabIndex = inject('tabIndex')
+const tabs = inject('tabs')
+const vertical = inject('vertical')
+
+const tabRef = ref([])
+const indicator = ref(null)
+const tabsLength = computed(() => tabs.value?.length)
+
+const transitionClass = ref('')
+
+function moveIndicator(index) {
+  if (index >= tabsLength.value) {
+    index = tabsLength.value - 1
+  }
+  const selectedTab = tabRef.value[index].el
+  if (vertical) {
+    indicator.value.style.height = `${selectedTab.offsetHeight}px`
+    indicator.value.style.top = `${selectedTab.offsetTop}px`
+  } else {
+    indicator.value.style.width = `${selectedTab.offsetWidth}px`
+    indicator.value.style.left = `${selectedTab.offsetLeft}px`
+  }
+}
+
+watch(tabIndex, (index) => {
+  if (index >= tabsLength.value) {
+    tabIndex.value = tabsLength.value - 1
+  }
+  transitionClass.value = 'transition-all duration-300 ease-in-out'
+  nextTick(() => moveIndicator(index))
+})
+
+onMounted(() => {
+  nextTick(() => moveIndicator(tabIndex.value))
+  // Fix for indicator not moving on initial load
+  setTimeout(() => moveIndicator(tabIndex.value), 100)
+})
+</script>

package/src/components/Tabs/TabPanel.vue

@@ -0,0 +1,17 @@
+<template>
+  <TabPanels class="flex flex-1 overflow-hidden">
+    <TabPanel
+      class="flex flex-1 flex-col overflow-y-auto focus:outline-none"
+      v-for="(tab, i) in tabs"
+      :key="i"
+    >
+      <slot v-bind="{ tab }" />
+    </TabPanel>
+  </TabPanels>
+</template>
+<script setup>
+import { TabPanels, TabPanel } from '@headlessui/vue'
+import { inject } from 'vue'
+
+const tabs = inject('tabs')
+</script>

package/src/components/Tabs/Tabs.story.md

@@ -0,0 +1,97 @@
+## Props
+
+### tabs
+
+It is an array of objects which contains the following attributes:
+
+1. `label` is the name of the tab, it is required.
+2. `icon` is the icon to be shown in the tab, it accept component and it is
+   optional.
+3. You can add more attributes which can be used for custom rendering in the tab
+   header or content.
+
+### v-model
+
+It is used to set the active tab or change the active tab. It is required.
+
+### vertical
+
+It is used to show the tabs vertically. It is optional.
+
+### as
+
+You can set it to `div` to wrap tabs in a `div`. It can be any valid HTML tag.
+This is useful to control the layout of the tabs. It is optional.
+
+1. `as="div"` or any valid HTML tag
+
+```html
+<div>
+  <!-- container div -->
+  <div>
+    <div active>Tab 1</div>
+    <div>Tab 2</div>
+    <div>Tab 3</div>
+  </div>
+  <div>
+    <div active>Content 1</div>
+    <div>Content 2</div>
+    <div>Content 3</div>
+  </div>
+</div>
+```
+
+2. `as` is not set
+
+```html
+<div>
+  <div active>Tab 1</div>
+  <div>Tab 2</div>
+  <div>Tab 3</div>
+</div>
+<div>
+  <div active>Content 1</div>
+  <div>Content 2</div>
+  <div>Content 3</div>
+</div>
+```
+
+## Slots
+
+1. **tab-item:** You can use this slot to render custom tab items. It is
+   optional.
+2. **tab-panel:** You can use this slot to render custom tab panels. It is
+   required. Example:
+
+```vue
+<Tabs v-model="tabIndex" :tabs="tabs">
+   <template #tab-item="{ tab, selected }">
+      <div :class="{ 'text-gray-900 font-semibold': selected }">
+         <span>{{ tab.label }}</span>
+         <span>{{ tab.icon }}</span>
+      </div>
+   </template>
+   <template #tab-panel="{ tab }">
+      <div>{{ tab.content }}</div>
+   </template>
+</Tabs>
+```
+
+## Layout Customization
+
+You can customize the layout of the tabs by using `<TabList />` and `<TabPanels />`
+components.
+
+```vue
+<Tabs v-model="tabIndex" :tabs="tabs">
+   <TabList v-slot="{ tab, selected }">
+      <div :class="{ 'text-gray-900 font-semibold': selected }">
+         <span>{{ tab.label }}</span>
+         <span>{{ tab.icon }}</span>
+      </div>
+   </TabList>
+   <TabPanel v-slot="{ tab }">
+      <div>{{ tab.content }}</div>
+   </TabPanel>
+</Tabs>
+```

package/src/components/{Tabs.story.vue → Tabs/Tabs.story.vue}

@@ -1,7 +1,7 @@
 <script setup lang="ts">
 import { h, reactive } from 'vue'
 import Tabs from './Tabs.vue'
-import FeatherIcon from './FeatherIcon.vue'
+import FeatherIcon from '../FeatherIcon.vue'
 const state = reactive({
   index: 0,
   tabs_without_icon: [
@@ -48,20 +48,45 @@ const state = reactive({
   <Story :layout="{ type: 'grid', width: '80%' }">
     <Variant title="Without Icon">
       <Tabs
-        v-slot="{ tab }"
+        as="div"
+        class="border rounded"
         v-model="state.index"
         :tabs="state.tabs_without_icon"
       >
-        <div class="p-5">
-          {{ tab.content }}
-        </div>
+        <template #tab-panel="{ tab }">
+          <div class="p-5">
+            {{ tab.content }}
+          </div>
+        </template>
       </Tabs>
     </Variant>
     <Variant title="With Icon">
-      <Tabs v-slot="{ tab }" v-model="state.index" :tabs="state.tabs_with_icon">
-        <div class="p-5">
-          {{ tab.content }}
-        </div>
+      <Tabs
+        as="div"
+        class="border rounded"
+        v-model="state.index"
+        :tabs="state.tabs_with_icon"
+      >
+        <template #tab-panel="{ tab }">
+          <div class="p-5">
+            {{ tab.content }}
+          </div>
+        </template>
+      </Tabs>
+    </Variant>
+    <Variant title="Vertical Tabs">
+      <Tabs
+        as="div"
+        class="border rounded"
+        v-model="state.index"
+        :tabs="state.tabs_with_icon"
+        vertical
+      >
+        <template #tab-panel="{ tab }">
+          <div class="p-5">
+            {{ tab.content }}
+          </div>
+        </template>
       </Tabs>
     </Variant>
 

package/src/components/Tabs/Tabs.vue

@@ -0,0 +1,52 @@
+<template>
+  <TabGroup
+    v-bind="
+      as !== 'template'
+        ? {
+            as,
+            class: ['flex flex-1 overflow-hidden', vertical ? '' : 'flex-col '],
+          }
+        : {}
+    "
+    :defaultIndex="tabIndex"
+    :selectedIndex="tabIndex"
+    @change="(idx) => (tabIndex = idx)"
+  >
+    <slot>
+      <TabList v-slot="{ tab, selected }">
+        <slot name="tab-item" v-bind="{ tab, selected }" />
+      </TabList>
+      <TabPanel v-slot="{ tab }">
+        <slot name="tab-panel" v-bind="{ tab }" />
+      </TabPanel>
+    </slot>
+  </TabGroup>
+</template>
+
+<script setup>
+import TabList from './TabList.vue'
+import TabPanel from './TabPanel.vue'
+import { TabGroup } from '@headlessui/vue'
+import { provide } from 'vue'
+
+const props = defineProps({
+  as: {
+    type: String,
+    default: 'template',
+  },
+  tabs: {
+    type: Array,
+    required: true,
+  },
+  vertical: {
+    type: Boolean,
+    default: false,
+  },
+})
+
+const tabIndex = defineModel()
+
+provide('tabIndex', tabIndex)
+provide('tabs', props.tabs)
+provide('vertical', props.vertical)
+</script>

package/src/components/TextInput.vue

@@ -22,6 +22,7 @@
       :disabled="disabled"
       :id="id"
       :value="modelValue"
+      :required="required"
       @input="handleChange"
       @change="handleChange"
       v-bind="attrsWithoutClassStyle"
@@ -53,6 +54,7 @@ interface TextInputProps {
   id?: string
   modelValue?: string | number
   debounce?: number
+  required?: boolean
 }
 
 defineOptions({

package/src/data-fetching/docStore.ts

@@ -1,4 +1,4 @@
-import { type Ref, type ComputedRef, unref, ref } from 'vue'
+import { Ref, ref, MaybeRefOrGetter, toValue } from 'vue'
 import { idbStore } from './idbStore'
 
 type Doc = {
@@ -49,11 +49,8 @@ class DocStore {
     }
   }
 
-  getDoc(
-    doctype: string,
-    name: string | Ref<string> | ComputedRef<string>,
-  ): Ref<Doc | null> {
-    const nameStr = unref(name)
+  getDoc(doctype: string, name: MaybeRefOrGetter<string>): Ref<Doc | null> {
+    const nameStr = toValue(name)
     if (!doctype || !nameStr) {
       throw new Error('doctype and name are required')
     }
@@ -114,6 +111,10 @@ class DocStore {
     await this.cleanup(key)
   }
 
+  removeDoc(doctype: string, name: string) {
+    return this.invalidateDoc(doctype, name)
+  }
+
   private getKey(doctype: string, name: string): DocKey {
     return `${doctype.trim()}/${name.trim()}` as DocKey
   }

package/src/data-fetching/useCall/useCall.test.ts

@@ -145,7 +145,7 @@ describe('useCall', () => {
     const call = useCall<Response>({
       url: url('/api/v2/method/post'),
       method: 'POST',
-      refetch: true,
+      refetch: false,
       immediate: false,
     })
 

package/src/data-fetching/useCall/useCall.ts

@@ -88,11 +88,15 @@ export function useCall<TResponse, TParams extends BasicParams = undefined>(
     canAbort,
     aborted,
     abort,
-    execute,
+    execute: _execute,
     onFetchResponse,
     onFetchError,
   } = result
 
+  function execute(): Promise<TResponse | null> {
+    return _execute().then((r) => data.value)
+  }
+
   onFetchResponse(() => {
     resolve()
     promise.value = makePromise()
@@ -107,7 +111,9 @@ export function useCall<TResponse, TParams extends BasicParams = undefined>(
     if (beforeSubmit) {
       beforeSubmit(params)
     }
-    submitParams.value = params
+    if (params != null) {
+      submitParams.value = params
+    }
     if (!refetch) {
       return execute()
     }
@@ -122,14 +128,14 @@ export function useCall<TResponse, TParams extends BasicParams = undefined>(
 
   const _data = computed(() => {
     if (normalizedCacheKey && (out.loading || !out.isFinished)) {
-      let data = cachedResponse.value as TResponse
+      let cachedData = cachedResponse.value as TResponse
       if (transform) {
-        let returnValue = transform(data)
+        let returnValue = transform(cachedData)
         if (returnValue !== undefined) {
-          data = returnValue
+          cachedData = returnValue
         }
       }
-      return data
+      return cachedData
     }
     return data.value
   })

package/src/data-fetching/useDoc/useDoc.ts

@@ -1,4 +1,11 @@
-import { computed, MaybeRef, reactive, readonly, unref, Ref } from 'vue'
+import {
+  computed,
+  reactive,
+  readonly,
+  Ref,
+  MaybeRefOrGetter,
+  toValue,
+} from 'vue'
 import { UseFetchOptions } from '@vueuse/core'
 import { useFrappeFetch } from '../useFrappeFetch'
 import { useCall } from '../useCall/useCall'
@@ -24,7 +31,7 @@ interface DocMethodOption<T = any>
 
 interface UseDocOptions {
   doctype: string
-  name: string | MaybeRef<string>
+  name: MaybeRefOrGetter<string>
   baseUrl?: string
   methods?: Record<string, string | DocMethodOption>
   immediate?: boolean
@@ -42,15 +49,28 @@ export function useDoc<TDoc extends { name: string }, TMethods = {}>(
   } = options
 
   const url = computed(
-    () => `${baseUrl}/api/v2/document/${doctype}/${unref(name)}`,
+    () => `${baseUrl}/api/v2/document/${doctype}/${toValue(name)}`,
   )
 
+  type SuccessCallback = (doc: TDoc) => void
+  const successCallbacks: SuccessCallback[] = []
+  const triggerSuccessCallbacks = (doc: TDoc) => {
+    for (let cb of successCallbacks) {
+      try {
+        cb(doc)
+      } catch (e) {
+        console.error('Error in onSuccess hook:', e)
+      }
+    }
+  }
+
   const fetchOptions: UseFetchOptions = {
     immediate,
     refetch: true,
     afterFetch(ctx) {
       docStore.setDoc({ doctype, ...ctx.data })
       listStore.updateRow(doctype, ctx.data)
+      triggerSuccessCallbacks(ctx.data)
       return ctx
     },
   }
@@ -80,13 +100,13 @@ export function useDoc<TDoc extends { name: string }, TMethods = {}>(
 
       let callOptions: UseCallOptions = {
         immediate: false,
-        refetch: true,
+        refetch: false,
         method: 'POST',
         ...option,
         baseUrl,
         url: computed(
           () =>
-            `/api/v2/document/${doctype}/${unref(name)}/method/${option.name}`,
+            `/api/v2/document/${doctype}/${toValue(name)}/method/${option.name}`,
         ),
       }
 
@@ -95,17 +115,30 @@ export function useDoc<TDoc extends { name: string }, TMethods = {}>(
   }
 
   let setValue = useCall<TDoc, Partial<TDoc>>({
-    immediate: false,
-    refetch: false,
+    url: computed(() => `/api/v2/document/${doctype}/${toValue(name)}`),
     method: 'PUT',
     baseUrl,
-    url: computed(() => `/api/v2/document/${doctype}/${unref(name)}`),
+    immediate: false,
+    refetch: false,
     onSuccess(data) {
       docStore.setDoc({ doctype, ...data })
       listStore.updateRow(doctype, data)
     },
   })
 
+  type DeleteResponse = 'ok'
+  const delete_ = useCall<DeleteResponse>({
+    url: computed(() => `/api/v2/document/${doctype}/${toValue(name)}`),
+    method: 'DELETE',
+    baseUrl,
+    immediate: false,
+    refetch: false,
+    onSuccess() {
+      docStore.removeDoc(doctype, toValue(name))
+      listStore.removeRow(doctype, toValue(name))
+    },
+  })
+
   const doc = docStore.getDoc(doctype, name) as Ref<TDoc | null>
 
   let out = reactive({
@@ -121,6 +154,17 @@ export function useDoc<TDoc extends { name: string }, TMethods = {}>(
     reload: execute,
     abort,
     setValue,
+    delete: delete_,
+    onSuccess: (callback: SuccessCallback) => {
+      successCallbacks.push(callback)
+      return () => {
+        // unsubscribe function
+        const index = successCallbacks.indexOf(callback)
+        if (index > -1) {
+          successCallbacks.splice(index, 1)
+        }
+      }
+    },
     ...docMethods,
   })
 

package/src/data-fetching/useDoctype/useDoctype.ts

@@ -13,14 +13,16 @@ export function useDoctype<T>(
 ) {
   const insert = useInsert<T>(doctype, options)
   const delete_ = useDelete(doctype, options)
-  const runDocMethod = useRunDocMethod(doctype, options)
   const setValue = useSetValue<T>(doctype, options)
+  const runDocMethod = useRunDocMethod(doctype, options)
+  const runMethod = useRunMethod(doctype, options)
 
   return reactive({
     insert,
     delete: delete_,
     setValue,
     runDocMethod,
+    runMethod,
   })
 }
 
@@ -107,6 +109,54 @@ function useRunDocMethod(doctype: string, options: UseDoctypeOptions = {}) {
   } as RunDocMethodReturnValue)
 }
 
+function useRunMethod(doctype: string, options: UseDoctypeOptions = {}) {
+  let { baseUrl = '' } = options
+  let url = ref(`/api/v2/method/${doctype}/<method>`)
+
+  interface RunMethodParams {
+    method: string
+    validate?: () => string | void
+    params?: Record<string, any>
+  }
+
+  type RunMethodReturnValue = ReturnType<typeof useCall> & {
+    submit: (params: RunMethodParams) => Promise<any>
+    isLoading: (method: string) => boolean
+  }
+
+  let runMethod = useCall<any, RunMethodParams['params']>({
+    url,
+    method: 'POST',
+    immediate: false,
+    baseUrl,
+  })
+
+  let validateError = ref<Error | null>(null)
+
+  return reactive({
+    ...runMethod,
+    error: computed(() => validateError.value || runMethod.error),
+    submit: ({ method, validate, params }: RunMethodParams) => {
+      url.value = `/api/v2/method/${doctype}/${method}`
+      if (validate) {
+        const errorMessage = validate()
+        if (errorMessage) {
+          validateError.value = new Error(errorMessage)
+          return Promise.reject(validateError.value)
+        } else {
+          validateError.value = null
+        }
+      }
+      return runMethod.submit(params)
+    },
+    isLoading: (method: string) => {
+      return (
+        runMethod.loading && url.value === `/api/v2/method/${doctype}/${method}`
+      )
+    },
+  } as RunMethodReturnValue)
+}
+
 function useSetValue<T>(doctype: string, options: UseDoctypeOptions = {}) {
   let { baseUrl = '' } = options
   let url = ref(`/api/v2/document/${doctype}/<name>`)

package/src/data-fetching/useList/listStore.ts

@@ -30,6 +30,13 @@ class ListStore {
     })
   }
 
+  removeRow(doctype: string, name: string) {
+    this.ensureList(doctype)
+    this.byDocType[doctype].forEach((list) => {
+      list.removeRow(name)
+    })
+  }
+
   ensureList(docType: string) {
     if (!this.byDocType[docType]) {
       this.byDocType[docType] = []

package/src/data-fetching/useList/types.ts

@@ -1,7 +1,9 @@
-import { Reactive, Ref } from 'vue'
+import { MaybeRefOrGetter, Reactive, Ref } from 'vue'
 import { CacheKey } from '../useCall/types'
 
 export type Field = string
+export type LinkField = `${Field}.${Field}` | `${Field}.${Field} as ${string}`
+export type FieldWithAlias = `${Field} as ${string}`
 
 export type ChildTableField = {
   [key: string]: Field[]
@@ -13,7 +15,7 @@ export type FilterValue =
   | boolean
   | [string, string | number | boolean | Ref<string | number | boolean>]
 
-export interface ListFilters {
+export interface Filters {
   [key: Field]: FilterValue
 }
 
@@ -25,9 +27,9 @@ export type OrderBy =
 
 export interface UseListOptions<T> {
   doctype: string
-  fields?: Array<keyof T | ChildTableField>
-  filters?: Reactive<ListFilters>
-  orderBy?: OrderBy
+  fields?: Array<keyof T | ChildTableField | LinkField | FieldWithAlias | '*'>
+  filters?: MaybeRefOrGetter<Filters>
+  orderBy?: MaybeRefOrGetter<OrderBy>
   start?: number
   limit?: number
   groupBy?: Field
@@ -38,12 +40,10 @@ export interface UseListOptions<T> {
   immediate?: boolean
   refetch?: boolean
   baseUrl?: string
+  url?: `/${string}`
   transform?: (data: T[]) => T[]
   onSuccess?: (data: T[]) => void
   onError?: (error: Error) => void
 }
 
-export interface UseListResponse<T> {
-  result: T[]
-  has_next_page: boolean
-}
+export type UseListResponse<T> = T[]

package/src/data-fetching/useList/useList.test.ts

@@ -27,7 +27,7 @@ describe('useList', () => {
     // Verify initial state
     expect(users.data).toBe(null)
     expect(users.error).toBe(null)
-    expect(users.hasNextPage).toBe(false)
+    expect(users.hasNextPage).toBe(true)
     expect(typeof users.fetch).toBe('function')
 
     // fetch
@@ -64,6 +64,8 @@ describe('useList', () => {
     expect(users.start).toBe(2)
     expect(users.hasPreviousPage).toBe(true)
     expect(users.data).toStrictEqual([
+      { name: 'User1', email: 'user1@example.com' },
+      { name: 'User2', email: 'user2@example.com' },
       { name: 'User3', email: 'user3@example.com' },
       { name: 'User4', email: 'user4@example.com' },
     ])

package/src/data-fetching/useList/useList.ts

@@ -1,4 +1,12 @@
-import { computed, reactive, readonly, ref, triggerRef } from 'vue'
+import {
+  computed,
+  MaybeRefOrGetter,
+  reactive,
+  readonly,
+  Ref,
+  ref,
+  toValue,
+} from 'vue'
 import {
   AfterFetchContext,
   OnFetchErrorContext,
@@ -10,6 +18,7 @@ import { parseFilters, makeGetParams, normalizeCacheKey } from '../utils'
 import { UseListOptions, UseListResponse } from './types'
 import { idbStore } from '../idbStore'
 import { listStore } from './listStore'
+import { docStore } from '../docStore'
 
 export function useList<T extends { name: string }>(
   options: UseListOptions<T>,
@@ -29,34 +38,47 @@ export function useList<T extends { name: string }>(
     refetch = true,
     cacheKey,
     baseUrl = '',
+    url = '',
     transform,
   } = options
 
   const _start = ref(start || 0)
   const _limit = ref(limit || 20)
 
-  const url = computed(() => {
-    const parsedFilters = parseFilters(filters || {})
+  const _url = computed(() => {
+    const parsedFilters = parseFilters(filters ? toValue(filters) : {})
+    const _fields = fields ? toValue(fields) : []
     const params = makeGetParams({
-      fields: fields?.length ? JSON.stringify(fields) : null,
+      fields: _fields.length ? JSON.stringify(_fields) : null,
       filters: parsedFilters ? JSON.stringify(parsedFilters) : null,
-      order_by: orderBy,
+      order_by: toValue(orderBy),
       start: _start.value,
       limit: _limit.value,
       group_by: groupBy,
       parent: parent,
       debug: debug,
     })
+    if (url) {
+      return `${baseUrl}${url}?${params}`
+    }
     return `${baseUrl}/api/v2/document/${doctype}?${params}`
   })
 
+  const allData: Ref<T[] | null> = ref(null)
+  const hasNextPage = ref(true)
+  const hasPreviousPage = computed(() => _start.value > 0)
+
   const fetchOptions: UseFetchOptions = {
     immediate,
     refetch,
-    initialData: initialData
-      ? { result: initialData, has_next_page: false }
-      : null,
-    afterFetch: handleAfterFetch<T>(options),
+    initialData: initialData || null,
+    afterFetch: handleAfterFetch<T>({
+      ...options,
+      allData,
+      _start,
+      _limit,
+      hasNextPage,
+    }),
     onFetchError: handleFetchError<T>(options),
   }
 
@@ -69,7 +91,7 @@ export function useList<T extends { name: string }>(
     aborted,
     abort,
     execute,
-  } = useFrappeFetch<UseListResponse<T>>(url, fetchOptions).get()
+  } = useFrappeFetch<UseListResponse<T>>(_url, fetchOptions).get()
 
   let normalizedCacheKey = normalizeCacheKey(cacheKey, 'useList')
   let cachedResponse = ref<UseListResponse<T> | null>(null)
@@ -79,24 +101,16 @@ export function useList<T extends { name: string }>(
       let data = cachedResponse.value
       if (data) {
         if (transform) {
-          let returnValue = transform(data.result as T[])
+          let returnValue = transform(data as T[])
           if (returnValue !== undefined) {
             return returnValue
           }
         }
-        return data.result
+        return data
       }
     }
-    return data.value?.result ?? null
-  })
-  const hasNextPage = computed(() => {
-    if (normalizedCacheKey && (out.loading || !out.isFinished)) {
-      let data = cachedResponse.value
-      return data?.has_next_page ?? false
-    }
-    return data.value?.has_next_page ?? false
+    return allData.value
   })
-  const hasPreviousPage = computed(() => _start.value > 0)
 
   if (normalizedCacheKey) {
     idbStore.get(normalizedCacheKey).then((data) => {
@@ -119,24 +133,31 @@ export function useList<T extends { name: string }>(
   type PartialDoc = Partial<T extends { name: string } ? T : { name: string }>
 
   const updateRow = (doc: PartialDoc) => {
-    if (data.value?.result) {
-      let changed = false
-      for (let row of data.value.result) {
-        if (doc.name && doc.name === row.name) {
-          for (let key in doc) {
-            if (key in row) {
-              row[key] = doc[key]
-              changed = true
-            }
+    if (allData.value == null) return
+    let changed = false
+    for (let row of allData.value) {
+      if (doc.name && doc.name === row.name) {
+        for (let key in doc) {
+          if (key in row) {
+            row[key] = doc[key]
+            changed = true
           }
-          break
         }
-      }
-      if (changed) {
-        data.value.result = [...data.value.result]
-        triggerRef(data)
+        break
       }
     }
+    if (changed) {
+      allData.value = [...allData.value]
+    }
+  }
+
+  const removeRow = (name: string) => {
+    if (allData.value == null) return
+    const index = allData.value.findIndex((row) => row.name === name)
+    if (index > -1) {
+      allData.value.splice(index, 1)
+      allData.value = [...allData.value]
+    }
   }
 
   const insert = useCall<T, Partial<T>>({
@@ -149,6 +170,26 @@ export function useList<T extends { name: string }>(
     },
   })
 
+  const setValueUrl = ref(`/api/v2/document/${doctype}/<name>`)
+
+  const setValue = useCall<T, Partial<T>>({
+    url: setValueUrl,
+    method: 'PUT',
+    baseUrl,
+    immediate: false,
+    refetch: false,
+    beforeSubmit(params) {
+      if (params?.name) {
+        setValueUrl.value = `/api/v2/document/${doctype}/${params.name}`
+      }
+    },
+    onSuccess(data) {
+      docStore.setDoc({ doctype, ...data })
+      listStore.updateRow(doctype, data)
+      if (refetch) execute()
+    },
+  })
+
   let deleteUrl = ref(`/api/v2/document/${doctype}/<name>`)
   type DeleteResponse = 'ok'
   type DeleteParams = { name: string }
@@ -167,9 +208,45 @@ export function useList<T extends { name: string }>(
     },
   })
 
+  function useEdit(name: MaybeRefOrGetter<string>) {
+    if (!allData.value) {
+      throw new Error('Data not found')
+    }
+    let row = allData.value.find((row) => row.name === toValue(name))
+    if (!row) {
+      throw new Error(`Couldn't find row with name ${toValue(name)}`)
+    }
+
+    let originalRow = JSON.parse(JSON.stringify(row))
+    let doc = reactive(row)
+
+    const setValue = useCall<T, Partial<T>>({
+      url: `/api/v2/document/${doctype}/${toValue(name)}`,
+      method: 'PUT',
+      baseUrl,
+      immediate: false,
+      refetch: false,
+      onSuccess(data) {
+        docStore.setDoc({ doctype, ...data })
+        listStore.updateRow(doctype, data)
+      },
+    })
+
+    return {
+      doc,
+      reset: () => {
+        for (let key in originalRow) {
+          doc[key] = originalRow[key]
+        }
+      },
+      setValue,
+      update: () => setValue.submit(doc),
+    }
+  }
+
   let out = reactive({
     data: result,
-    hasNextPage,
+    hasNextPage: readonly(hasNextPage),
     hasPreviousPage,
     start: readonly(_start),
     limit: readonly(_limit),
@@ -179,7 +256,7 @@ export function useList<T extends { name: string }>(
     isFinished,
     canAbort,
     aborted,
-    url,
+    url: _url,
     abort,
     next,
     previous,
@@ -187,8 +264,11 @@ export function useList<T extends { name: string }>(
     fetch: execute,
     reload: execute,
     updateRow,
+    removeRow,
     insert,
+    setValue,
     delete: delete_,
+    edit: useEdit,
   })
 
   listStore.addList(doctype, out)
@@ -196,19 +276,44 @@ export function useList<T extends { name: string }>(
   return out
 }
 
-function handleAfterFetch<T>({
+function handleAfterFetch<T extends { name: string }>({
   transform,
   onSuccess,
   cacheKey,
-}: UseListOptions<T>) {
+  allData,
+  _start,
+  _limit,
+  hasNextPage,
+}: UseListOptions<T> & {
+  allData: Ref<T[] | null>
+  _start: Ref<number>
+  _limit: Ref<number>
+  hasNextPage: Ref<boolean>
+}) {
   return function (ctx: AfterFetchContext) {
+    let resultData = ctx.data
+    if (resultData[0]?.name) {
+      resultData = resultData.map((item) => ({
+        ...item,
+        name: String(item.name),
+      }))
+    }
+    hasNextPage.value = resultData.length < _limit.value ? false : true
+
     if (transform) {
-      const returnValue = transform(ctx.data.result)
+      const returnValue = transform(resultData)
       if (Array.isArray(returnValue)) {
-        ctx.data.result = returnValue
+        resultData = returnValue
       }
     }
 
+    if (_start.value === 0) {
+      allData.value = resultData as T[]
+    } else {
+      allData.value = [...(allData.value || []), ...resultData]
+    }
+    ctx.data = allData.value
+
     let normalizedCacheKey = normalizeCacheKey(cacheKey, 'useList')
     if (normalizedCacheKey) {
       idbStore.set(normalizedCacheKey, ctx.data)
@@ -216,7 +321,7 @@ function handleAfterFetch<T>({
 
     if (onSuccess) {
       try {
-        onSuccess(ctx.data.result)
+        onSuccess(allData.value)
       } catch (e) {
         console.error('Error in onSuccess hook:', e)
       }

package/src/data-fetching/useNewDoc/useNewDoc.ts

@@ -1,6 +1,7 @@
 import { reactive, unref } from 'vue'
 import { useCall } from '../useCall/useCall'
 import { UseCallOptions } from '../useCall/types'
+import { docStore } from '../docStore'
 
 type UseNewDocOptions = Omit<
   UseCallOptions,
@@ -18,7 +19,11 @@ export function useNewDoc<T extends object>(
 ) {
   let doc = reactive<NewDoc<T>>(initialValues)
 
-  const out = useCall<T>({
+  type DocResponse = T & {
+    name: string
+  }
+
+  const out = useCall<DocResponse>({
     url: `/api/v2/document/${doctype}`,
     method: 'POST',
     params() {
@@ -34,8 +39,19 @@ export function useNewDoc<T extends object>(
     ...options,
   })
 
+  function submit() {
+    return out
+      .submit()
+      .then((doc) =>
+        docStore
+          .setDoc({ doctype, ...(doc as DocResponse) })
+          .then(() => docStore.getDoc(doctype, doc.name.toString()).value as T),
+      )
+  }
+
   return reactive({
     ...out,
+    submit,
     doc,
   })
 }

package/src/data-fetching/utils.ts

@@ -1,5 +1,5 @@
 import { MaybeRef, unref } from 'vue'
-import { ListFilters } from './useList/types'
+import { Filters } from './useList/types'
 
 export function makeGetParams(params: Record<string, any>) {
   let url = new URLSearchParams()
@@ -16,8 +16,8 @@ export function isEmptyObject(obj: any) {
   return Object.keys(obj).length === 0 && obj.constructor === Object
 }
 
-export function parseFilters(filters: ListFilters): ListFilters | null {
-  let parsedFilters: ListFilters = {}
+export function parseFilters(filters: Filters): Filters | null {
+  let parsedFilters: Filters = {}
   for (let key in filters) {
     let value = filters[key]
     if (Array.isArray(value)) {

package/src/index.js

@@ -32,7 +32,9 @@ export { default as Select } from './components/Select.vue'
 export { default as Spinner } from './components/Spinner.vue'
 export { default as Switch } from './components/Switch.vue'
 export { default as TabButtons } from './components/TabButtons.vue'
-export { default as Tabs } from './components/Tabs.vue'
+export { default as Tabs } from './components/Tabs/Tabs.vue'
+export { default as TabList } from './components/Tabs/TabList.vue'
+export { default as TabPanel } from './components/Tabs/TabPanel.vue'
 export { default as TextInput } from './components/TextInput.vue'
 export { default as Textarea } from './components/Textarea.vue'
 export {

package/src/mocks/handlers.ts

@@ -59,10 +59,7 @@ export const handlers = [
     let result = getUsers(listParams)
 
     return HttpResponse.json({
-      data: {
-        result,
-        has_next_page: true,
-      },
+      data: result,
     })
   }),
 

package/src/components/Tabs.story.md

@@ -1,15 +0,0 @@
-## Props
-
-### Tabs
-
-It is an array of objects which contains the following attributes:
-
-1. `label` is the name of the tab, it is required.
-2. `icon` is the icon to be shown in the tab, it accept component and it is
-   optional.
-3. You can add more attributes which can be used for custom rendering in the tab
-   header or content.
-
-## v-model
-
-It is used to set the active tab or change the active tab. It is required.

package/src/components/Tabs.vue

@@ -1,110 +0,0 @@
-<template>
-  <TabGroup
-    as="div"
-    class="flex flex-1 flex-col overflow-y-hidden"
-    :style="`height: calc(100vh - ${tabListRef?.$el.offsetTop}px)`"
-    :defaultIndex="changedIndex"
-    :selectedIndex="changedIndex"
-    @change="(idx) => (changedIndex = idx)"
-  >
-    <TabList
-      ref="tabListRef"
-      class="relative flex items-center gap-7.5 overflow-x-auto border-b px-5"
-      :class="tablistClass"
-    >
-      <Tab
-        ref="tabRef"
-        as="template"
-        v-for="(tab, i) in tabs"
-        :key="i"
-        v-slot="{ selected }"
-        class="focus:outline-none focus:transition-none"
-      >
-        <slot name="tab" v-bind="{ tab, selected }">
-          <button
-            class="flex items-center gap-1.5 border-b border-transparent py-3 text-base text-ink-gray-5 duration-300 ease-in-out hover:border-outline-gray-3 hover:text-ink-gray-9"
-            :class="{ 'text-ink-gray-9': selected }"
-          >
-            <component v-if="tab.icon" :is="tab.icon" class="size-4" />
-            {{ tab.label }}
-          </button>
-        </slot>
-      </Tab>
-      <div
-        ref="indicator"
-        class="tab-indicator absolute bottom-0 h-px bg-surface-gray-7"
-        :class="transitionClass"
-      />
-    </TabList>
-    <TabPanels class="flex flex-1 overflow-hidden" :class="tabPanelClass">
-      <TabPanel
-        class="flex flex-1 flex-col overflow-y-auto focus:outline-none"
-        v-for="(tab, i) in tabs"
-        :key="i"
-      >
-        <slot v-bind="{ tab }" />
-      </TabPanel>
-    </TabPanels>
-  </TabGroup>
-</template>
-
-<script setup>
-import { TabGroup, TabList, Tab, TabPanels, TabPanel } from '@headlessui/vue'
-import { ref, watch, computed, onMounted, nextTick } from 'vue'
-
-const props = defineProps({
-  tabs: {
-    type: Array,
-    required: true,
-  },
-  modelValue: {
-    type: Number,
-    default: 0,
-  },
-  tablistClass: {
-    type: String,
-    default: '',
-  },
-  tabPanelClass: {
-    type: String,
-    default: '',
-  },
-})
-
-const emit = defineEmits(['update:modelValue'])
-
-const changedIndex = computed({
-  get: () => props.modelValue,
-  set: (index) => emit('update:modelValue', index),
-})
-
-const tabListRef = ref(null)
-const tabRef = ref([])
-const indicator = ref(null)
-const tabsLength = computed(() => props.tabs?.length)
-
-const transitionClass = ref('')
-
-function moveIndicator(index) {
-  if (index >= tabsLength.value) {
-    index = tabsLength.value - 1
-  }
-  const selectedTab = tabRef.value[index].el
-  indicator.value.style.width = `${selectedTab.offsetWidth}px`
-  indicator.value.style.left = `${selectedTab.offsetLeft}px`
-}
-
-watch(changedIndex, (index) => {
-  if (index >= tabsLength.value) {
-    changedIndex.value = tabsLength.value - 1
-  }
-  transitionClass.value = 'transition-all duration-300 ease-in-out'
-  nextTick(() => moveIndicator(index))
-})
-
-onMounted(() => {
-  nextTick(() => moveIndicator(changedIndex.value))
-  // Fix for indicator not moving on initial load
-  setTimeout(() => moveIndicator(changedIndex.value), 100)
-})
-</script>