@globalbrain/sefirot 3.50.0 → 4.0.0-0

package/lib/components/SSheetTitle.vue

@@ -1,13 +0,0 @@
-<template>
-  <div class="SSheetTitle">
-    <p class="title"><slot /></p>
-  </div>
-</template>
-
-<style scoped lang="postcss">
-.SSheetTitle {
-  padding: 32px 32px 16px;
-  font-size: 20px;
-  font-weight: 600;
-}
-</style>

package/lib/components/STableHeaderActions.vue

@@ -1,20 +0,0 @@
-<script setup lang="ts">
-import { type TableHeaderAction } from '../composables/Table'
-import STableHeaderActionItem from './STableHeaderActionItem.vue'
-
-defineProps<{ actions: TableHeaderAction[] }>()
-</script>
-
-<template>
-  <div class="STableHeaderActions">
-    <STableHeaderActionItem v-for="action in actions" :key="action.label" v-bind="action" />
-  </div>
-</template>
-
-<style scoped lang="postcss">
-.STableHeaderActions {
-  display: flex;
-  flex-grow: 1;
-  gap: 8px;
-}
-</style>

package/lib/composables/D.ts

@@ -1,21 +0,0 @@
-import { type Ref, ref } from 'vue'
-
-export interface D<T extends Record<string, any>> {
-  data: Ref<T>
-  init(): void
-}
-
-export function useD<T extends Record<string, any>>(data: T): D<T> {
-  const initialData = JSON.stringify(data)
-
-  const refData = ref(data) as Ref<T>
-
-  function init(): void {
-    refData.value = JSON.parse(initialData) as T
-  }
-
-  return {
-    data: refData,
-    init
-  }
-}

package/lib/composables/Form.ts

@@ -1,109 +0,0 @@
-/**
- * @deprecated Use `composables/D` and `composables/V` modules instead.
- */
-
-import { type Ref, computed, reactive, toRefs } from 'vue'
-import { type Snackbar, useSnackbars } from '../stores/Snackbars'
-import { type UseDataInput, useData } from './Data'
-import { type Validation, useValidation } from './Validation'
-
-export interface Form<T extends Record<string, any>> {
-  data: T
-  validation: Ref<Validation<any, T>>
-  init(): void
-  reset(): void
-  validate(): Promise<boolean>
-  validateAndNotify(message?: Snackbar): Promise<boolean>
-}
-
-export type ComputedData<T extends Record<string, () => any>> = {
-  [K in keyof T]: ReturnType<T[K]>
-}
-
-export type AllData<
-  D extends Record<string, any>,
-  C extends Record<string, () => any>
-> = D & ComputedData<C>
-
-export interface UseFormOptions<
-  D extends Record<string, any>,
-  C extends Record<string, () => any>
-> {
-  data: UseDataInput<D>
-  computed?: (data: D) => C
-  rules?: Record<string, any> | ((data: AllData<D, C>) => Record<string, any>)
-}
-
-export function useForm<
-  D extends Record<string, any> = Record<string, any>,
-  C extends Record<string, () => any> = Record<string, () => any>
->(options: UseFormOptions<D, C>): Form<AllData<D, C>> {
-  const snackbars = useSnackbars()
-
-  const data = useData(options.data)
-  const dataStateRef = toRefs(data.state)
-
-  const computedData = options.computed
-    ? createComputedData(options.computed(data.state))
-    : {}
-
-  const allData = reactive({
-    ...dataStateRef,
-    ...computedData
-  }) as AllData<D, C>
-
-  const rules = computed(() => {
-    return options.rules
-      ? typeof options.rules === 'function' ? options.rules(allData) : options.rules
-      : {}
-  })
-
-  const validation = useValidation(allData, rules)
-
-  function init(): void {
-    data.init()
-    reset()
-  }
-
-  function reset(): void {
-    validation.value.$reset()
-  }
-
-  function validate(): Promise<boolean> {
-    return validation.value.$validate()
-  }
-
-  async function validateAndNotify(message?: Snackbar): Promise<boolean> {
-    const valid = await validate()
-
-    if (!valid) {
-      snackbars.push(message ?? {
-        mode: 'danger',
-        text: 'Form contains errors. Please correct them and try again.'
-      })
-    }
-
-    return valid
-  }
-
-  return {
-    data: allData,
-    init,
-    reset,
-    validation,
-    validate,
-    validateAndNotify
-  }
-}
-
-function createComputedData<
-  C extends Record<string, () => any>
->(input: C): ComputedData<C> {
-  const computedData = {} as any
-
-  for (const [key, fn] of Object.entries(input)) {
-    computedData[key] = computed(() => fn())
-  }
-
-  return computedData
-}

package/lib/composables/V.ts

@@ -1,97 +0,0 @@
-import {
-  type Validation,
-  type ValidationArgs,
-  type GlobalConfig as VuelidateConfig,
-  useVuelidate
-} from '@vuelidate/core'
-import { type MaybeRefOrGetter, type Ref, computed, toValue } from 'vue'
-import { type Snackbar, useSnackbars } from '../stores/Snackbars'
-import { useTrans } from './Lang'
-
-export interface V<
-  Data extends { [key in keyof Rules]: any },
-  Rules extends ValidationArgs = ValidationArgs
-> {
-  validation: Ref<Validation<Rules, Data>>
-  validate(): Promise<boolean>
-  validateAndNotify(message?: Snackbar): Promise<boolean>
-  notify(message?: Snackbar): void
-  reset(): void
-}
-
-export interface Validatable {
-  readonly $dirty: boolean
-  readonly $invalid: boolean
-  readonly $errors: ValidatableError[]
-  readonly $touch: () => void
-}
-
-export interface ValidatableError {
-  readonly $message: string | Ref<string>
-}
-
-export interface VNotification {
-  notify(message?: Snackbar): void
-}
-
-export function useV<
-  Data extends { [key in keyof Rules]: any },
-  Rules extends ValidationArgs = ValidationArgs
->(
-  data?: MaybeRefOrGetter<Data>,
-  rules?: MaybeRefOrGetter<Rules>,
-  config?: VuelidateConfig
-): V<Data, Rules> {
-  const { notify } = useVNotification()
-
-  const d = computed(() => toValue(data) ?? {})
-  const r = computed(() => toValue(rules) ?? {})
-
-  const validation = useVuelidate(r, d, config) as any
-
-  function reset(): void {
-    validation.value.$reset()
-  }
-
-  function validate(): Promise<boolean> {
-    return validation.value.$validate()
-  }
-
-  async function validateAndNotify(message?: Snackbar): Promise<boolean> {
-    const valid = await validate()
-
-    if (!valid) {
-      notify(message)
-    }
-
-    return valid
-  }
-
-  return {
-    validation,
-    validate,
-    validateAndNotify,
-    notify,
-    reset
-  }
-}
-
-export function useVNotification(): VNotification {
-  const { t } = useTrans({
-    en: { notify: 'Form contains errors. Please correct them and try again.' },
-    ja: { notify: 'フォームにエラーがあります。内容を確認し、再度お試しください。' }
-  })
-
-  const snackbars = useSnackbars()
-
-  function notify(message?: Snackbar): void {
-    snackbars.push(message ?? {
-      mode: 'danger',
-      text: t.notify
-    })
-  }
-
-  return {
-    notify
-  }
-}

package/lib/mixins/Sheet.ts

@@ -1,30 +0,0 @@
-import { type App } from 'vue'
-import SSheet from '../components/SSheet.vue'
-import SSheetFooter from '../components/SSheetFooter.vue'
-import SSheetFooterAction from '../components/SSheetFooterAction.vue'
-import SSheetFooterActions from '../components/SSheetFooterActions.vue'
-import SSheetForm from '../components/SSheetForm.vue'
-import SSheetMedium from '../components/SSheetMedium.vue'
-import SSheetTitle from '../components/SSheetTitle.vue'
-
-export function mixin(app: App): void {
-  app.component('SSheet', SSheet)
-  app.component('SSheetFooter', SSheetFooter)
-  app.component('SSheetFooterAction', SSheetFooterAction)
-  app.component('SSheetFooterActions', SSheetFooterActions)
-  app.component('SSheetForm', SSheetForm)
-  app.component('SSheetMedium', SSheetMedium)
-  app.component('SSheetTitle', SSheetTitle)
-}
-
-declare module 'vue' {
-  export interface GlobalComponents {
-    SSheet: typeof SSheet
-    SSheetFooter: typeof SSheetFooter
-    SSheetFooterAction: typeof SSheetFooterAction
-    SSheetFooterActions: typeof SSheetFooterActions
-    SSheetForm: typeof SSheetForm
-    SSheetMedium: typeof SSheetMedium
-    SSheetTitle: typeof SSheetTitle
-  }
-}