@globalbrain/sefirot 0.71.0 → 2.0.0-draft.3

package/lib/composables/Tooltip.ts

@@ -1,91 +0,0 @@
-import { Ref, ref } from '@vue/composition-api'
-
-export type Position = 'top' | 'right' | 'bottom' | 'left'
-
-const SCREEN_PADDING = 16
-
-/**
- * Prevent tooltip going off-screen by adjusting the position depending on
- * the current window size. This only applies to position `top` and
- * `bottom` since we only care about left and right of the screen.
- */
-export function useTooltip(
-  content: Ref<HTMLElement | null>,
-  tip: Ref<HTMLElement | null>,
-  position: Position
-) {
-  const on = ref(false)
-
-  function show(): void {
-    setPosition()
-    setTimeout(() => { on.value = true })
-  }
-
-  function hide(): void {
-    setTimeout(() => { on.value = false })
-  }
-
-  function setPosition(): void {
-    if (shouldPosition()) {
-      doSetPosition()
-    }
-  }
-
-  function doSetPosition(): void {
-    // Reset position first so that we can get the original position.
-    resetPosition()
-
-    // Temporally show tip to get its size.
-    tip.value!.style.display = 'block'
-
-    const contentRect = content.value!.getBoundingClientRect()
-    const tipRect = tip.value!.getBoundingClientRect()
-
-    const contentRightX = contentRect.x + contentRect.width
-    const tipRightX = tipRect.x + tipRect.width
-
-    if (tipRect.x < 0) {
-      adjustLeftPosition(contentRect.x)
-    } else if (tipRightX > window.outerWidth) {
-      adjustRightPosition(contentRightX)
-    }
-
-    tip.value!.style.display = 'none'
-  }
-
-  function adjustLeftPosition(contentRectX: number): void {
-    tip.value!.style.left = '0'
-    tip.value!.style.right = 'auto'
-    setTransform(-contentRectX + SCREEN_PADDING)
-  }
-
-  function adjustRightPosition(contentRightX: number): void {
-    tip.value!.style.left = 'auto'
-    tip.value!.style.right = '0'
-    setTransform((window.outerWidth - contentRightX) - SCREEN_PADDING)
-  }
-
-  function resetPosition(): void {
-    tip.value!.style.left = ''
-    tip.value!.style.right = ''
-    tip.value!.style.transform = ''
-  }
-
-  function setTransform(x: number): void {
-    tip.value!.style.transform = `translate(${x}px, ${position === 'top' ? -100 : 100}%)`
-  }
-
-  function shouldPosition(): boolean {
-    if (!tip.value || !content.value) {
-      return false
-    }
-
-    return position === 'top' || position === 'bottom'
-  }
-
-  return {
-    on,
-    show,
-    hide
-  }
-}

package/lib/composables/Utils.ts

@@ -1,115 +0,0 @@
-import {
-  Ref,
-  ComputedRef,
-  WatchSource,
-  shallowRef,
-  computed,
-  watch,
-  isRef
-} from '@vue/composition-api'
-
-export type Refish<T = any> = T | Ref<T> | ComputedRef<T>
-
-export type Source<S> = Ref<S> | ComputedRef<S>
-
-export function get<T>(refish: Refish<T> | (() => T)): T {
-  if (isRef(refish)) {
-    return refish.value
-  }
-
-  if (refish instanceof Function) {
-    return refish()
-  }
-
-  return refish
-}
-
-export function computedOnly<T, S>(
-  source: WatchSource<S>,
-  fn: (value: S, oldValue?: S) => T
-): Ref<T> {
-  const value = shallowRef() as Ref<T>
-
-  watch(source, (newValue, oldValue) => {
-    value.value = fn(newValue, oldValue)
-  }, { immediate: true })
-
-  return value
-}
-
-export function computedIf<T, R, E>(
-  refish: Refish<T | null>,
-  callback: (value: T) => R,
-  empty: E
-): ComputedRef<R | E> {
-  return computed(() => {
-    const value = get(refish)
-
-    return value ? callback(value) : empty
-  })
-}
-
-export function computedIfOnly<T, E, S>(
-  source: WatchSource<S>,
-  fn: (value: Exclude<S, undefined | null | false>) => T,
-  empty: E
-): Ref<T | E> {
-  return computedOnly(source, (value) => {
-    return value
-      ? fn(value as Exclude<S, undefined | null | false>)
-      : empty
-  })
-}
-
-export function computedArray<T>(callback: (carry: T) => void): ComputedRef<T> {
-  return computed(() => {
-    const carry = [] as any
-
-    callback(carry)
-
-    return carry
-  })
-}
-
-export function computedArrayOnly<T extends any[], S>(
-  source: Source<S>,
-  callback: (carry: T) => void
-): Ref<T> {
-  return computedOnly(source, () => {
-    const carry = [] as any
-
-    callback(carry)
-
-    return carry
-  })
-}
-
-export function computedArrayIf<T, D extends any[]>(
-  refish: Refish<T | null>,
-  callback: (carry: D, value: T) => void
-): ComputedRef<D> {
-  return computed(() => {
-    const carry = [] as any
-
-    const value = get(refish)
-
-    value && callback(carry, value)
-
-    return carry
-  })
-}
-
-export function computedArrayIfNot<T, D extends any[]>(
-  refish: Refish<T | null>,
-  callback: (carry: D) => void
-): ComputedRef<D> {
-  return computed(() => {
-    const carry = [] as any
-
-    const value = get(refish)
-
-    value || callback(carry)
-
-    return carry
-  })
-}

package/lib/composables/markdown/LinkPlugin.ts

@@ -1,45 +0,0 @@
-import MarkdownIt from 'markdown-it'
-
-export type LinkAttrs = Record<string, string>
-
-const EXTERNAL_REGEX = /^https?:/
-const CALLBACK_REGEX = /\{([\d}]+)\}/
-const CALLBACK_HREF = '#callback'
-
-export function linkPlugin(md: MarkdownIt, linkAttrs: LinkAttrs = {}): void {
-  md.renderer.rules.link_open = (tokens, idx, options, _env, self) => {
-    const token = tokens[idx]
-    const hrefIndex = token.attrIndex('href')
-
-    if (hrefIndex >= 0) {
-      const hrefAttr = token.attrs![hrefIndex]
-      const url = decodeURIComponent(hrefAttr[1])
-
-      if (isExternalUrl(url)) {
-        Object.entries(linkAttrs).forEach(([key, val]) => {
-          token.attrSet(key, val)
-        })
-      }
-
-      if (isCallbackUrl(url)) {
-        const matched = url.match(CALLBACK_REGEX)![1]
-
-        token.attrSet('data-callback-id', matched)
-
-        hrefAttr[1] = CALLBACK_HREF
-      }
-
-      token.attrSet('class', 'SMarkdown-link')
-    }
-
-    return self.renderToken(tokens, idx, options)
-  }
-}
-
-export function isExternalUrl(url: string): boolean {
-  return EXTERNAL_REGEX.test(url)
-}
-
-export function isCallbackUrl(url: string): boolean {
-  return url === CALLBACK_HREF || CALLBACK_REGEX.test(decodeURIComponent(url))
-}

package/lib/compositions/useForm.ts

@@ -1,17 +0,0 @@
-import { reactive, markRaw } from '@vue/composition-api'
-import { createValidation, Data, Rules } from '../validation/Validation'
-
-export interface FormDefinition {
-  data: Data
-  rules: Rules
-}
-
-export default function useForm(definition: FormDefinition) {
-  const data = reactive(definition.data)
-  const validation = markRaw(createValidation(data, definition.rules))
-
-  return {
-    data,
-    validation
-  }
-}

package/lib/compositions/useResizeObserver.ts

@@ -1,25 +0,0 @@
-import { ResizeObserver } from '@juggle/resize-observer'
-import { reactive, toRefs, onMounted, onUnmounted, Ref } from '@vue/composition-api'
-
-export interface EL {
-  w: number
-  h: number
-}
-
-export default function useResizeObserver(target: Ref<HTMLElement | null>) {
-  const el = reactive({ w: 0, h: 0 })
-
-  const ro = new ResizeObserver((entries) => {
-    const entry = entries[0]
-    el.w = entry.contentBoxSize[0].inlineSize
-    el.h = entry.contentBoxSize[0].blockSize
-  })
-
-  onMounted(() => { ro.observe(target.value!) })
-  onUnmounted(() => { ro.disconnect() })
-
-  return {
-    el: toRefs(el),
-    ro
-  }
-}

package/lib/compositions/useTime.ts

@@ -1,26 +0,0 @@
-function pad(n: number, width: number): string {
-  const number = String(n)
-  return number.length >= width ? number : new Array(width - number.length + 1).join('0') + number
-}
-
-function createTimes(from: number, to: number): string[] {
-  const hours: string[] = []
-
-  for (let h = from; h <= to; h++) {
-    hours.push(pad(h, 2))
-  }
-
-  return hours
-}
-
-export default function useTime() {
-  const hours = createTimes(0, 23)
-  const minutes = createTimes(0, 59)
-  const seconds = createTimes(0, 59)
-
-  return {
-    hours,
-    minutes,
-    seconds
-  }
-}

package/lib/store/alert/index.ts

@@ -1,32 +0,0 @@
-import { ActionTree, ActionContext } from 'vuex'
-import SAlert from '../../components/SAlert.vue'
-import { Alert } from '../../composables/Alert'
-import { State as RootState } from '../Sefirot'
-
-export type AlertPayload = Alert & { uid?: number }
-
-export const actions: ActionTree<any, RootState> = {
-  open(context: ActionContext<any, RootState>, alert: AlertPayload): void {
-    const { uid } = alert
-
-    delete alert.uid
-
-    context.dispatch('modal/open', {
-      uid,
-      component: SAlert,
-      data: alert,
-      options: {
-        closable: false
-      }
-    }, { root: true })
-  },
-
-  close(context: ActionContext<any, RootState>, uid?: number): void {
-    context.dispatch('modal/close', uid, { root: true })
-  }
-}
-
-export default {
-  namespaced: true,
-  actions
-}

package/lib/store/screen/index.ts

@@ -1,46 +0,0 @@
-import { ActionTree, ActionContext, MutationTree } from 'vuex'
-import { State as RootState } from '../Sefirot'
-
-export interface State {
-  name: string | null
-  data: Record<string, any>
-}
-
-export interface PayloadOpen {
-  name: string
-  data?: Record<string, any>
-}
-
-export function state(): State {
-  return {
-    name: null,
-    data: {}
-  }
-}
-
-export const actions: ActionTree<State, RootState> = {
-  open(context: ActionContext<State, RootState>, { name, data }: PayloadOpen): void {
-    context.commit('set', { name, data })
-  },
-
-  close(context: ActionContext<State, RootState>): void {
-    context.commit('set', {
-      name: null,
-      data: {}
-    })
-  }
-}
-
-export const mutations: MutationTree<State> = {
-  set(state: State, { name, data = {} }: PayloadOpen): void {
-    state.name = name
-    state.data = data
-  }
-}
-
-export default {
-  namespaced: true,
-  state,
-  actions,
-  mutations
-}

package/lib/types/v-calendar.d.ts

@@ -1,5 +0,0 @@
-declare module 'v-calendar' {
-  const VCalendar: any
-
-  export default VCalendar
-}

package/lib/validation/Validation.ts

@@ -1,151 +0,0 @@
-import { ref, computed, toRefs, Ref } from '@vue/composition-api'
-import { Rule } from './rules'
-
-export interface Validation {
-  _isValidation: boolean
-  $data: Ref<any>
-  $initData: any
-  $isDirty: Ref<boolean>
-  $isValid: Ref<boolean>
-  $errors: Ref<readonly Error[]>
-  $touch: () => void
-  $reset: () => void
-  $init: () => void
-  $validate: () => boolean
-  [name: string]: MaybeValidation
-}
-
-export type Data = Record<string, any>
-export type Rules = Record<string, Rule[] | Record<string, any>>
-export type InitData = any
-export type Error = [string, string]
-export type MaybeValidation = any | boolean | Ref<boolean> | Ref<readonly Error[]> | Function | Validation
-
-export function createValidation(data: Data, rules: Rules, rootData?: Data): Validation {
-  const validation = createInitialValidation()
-  setNestedValidations(validation, data, rootData ?? data, rules)
-  setValidation(validation)
-  return validation
-}
-
-function createInitialValidation(): Validation {
-  return {
-    _isValidation: true,
-    $data: ref(null),
-    $initData: null,
-    $isDirty: ref(false),
-    $isValid: ref(false),
-    $errors: ref([]),
-    $touch: () => {},
-    $reset: () => {},
-    $init: () => {},
-    $validate: () => false
-  }
-}
-
-function createNestedValidation(name: string, data: Data, rootData: Data, validators: Rule[]): Validation {
-  const initData = data[name]
-  const dataRef = toRefs(data)[name]
-
-  const isDirty = ref(false)
-
-  const errors = computed(() => {
-    return validators.reduce<Error[]>((errors, validator) => {
-      const d = data[name]
-
-      if (validator.optional && (d === undefined || d === null || d === '')) {
-        return errors
-      }
-
-      if (!validator.validate(d, rootData)) {
-        errors.push([validator.name, validator.message])
-      }
-
-      return errors
-    }, [])
-  })
-
-  const isValid = computed(() => errors.value.length === 0)
-
-  const touch = () => { isDirty.value = true }
-  const reset = () => { isDirty.value = false }
-
-  const init = () => {
-    reset()
-    dataRef.value = initData
-  }
-
-  const validate = () => {
-    touch()
-    return isValid.value
-  }
-
-  return {
-    _isValidation: true,
-    $data: dataRef,
-    $initData: initData,
-    $isDirty: isDirty,
-    $errors: errors,
-    $isValid: isValid,
-    $touch: touch,
-    $reset: reset,
-    $init: init,
-    $validate: validate
-  }
-}
-
-function setValidation(validation: Validation): void {
-  const isDirty = computed(() => {
-    return Object.keys(validation).every((field) => {
-      const v = validation[field]
-      return isValidation(v) ? v.$isDirty.value : true
-    }, [])
-  })
-
-  const errors = computed(() => {
-    return Object.keys(validation).reduce<Error[]>((errors, field) => {
-      const v = validation[field]
-      return isValidation(v) ? errors.concat(v.$errors.value) : errors
-    }, [])
-  })
-
-  const isValid = computed(() => errors.value.length === 0)
-
-  const touch = () => { callAll(validation, 'touch') }
-  const reset = () => { callAll(validation, 'reset') }
-  const init = () => { callAll(validation, 'init') }
-
-  const validate = () => {
-    touch()
-    return isValid.value
-  }
-
-  validation.$isDirty = isDirty
-  validation.$errors = errors
-  validation.$isValid = isValid
-  validation.$touch = touch
-  validation.$reset = reset
-  validation.$init = init
-  validation.$validate = validate
-}
-
-function setNestedValidations(validation: Validation, data: Data, rootData: Data, rules: Rules): void {
-  for (const name in rules) {
-    const validators = rules[name]
-
-    validation[name] = Array.isArray(validators)
-      ? createNestedValidation(name, data, rootData, validators)
-      : createValidation(data[name], validators, rootData)
-  }
-}
-
-function callAll(validation: Validation, method: 'touch' | 'reset' | 'init'): void {
-  for (const field in validation) {
-    const v = validation[field]
-    isValidation(v) && v[`$${method}`]()
-  }
-}
-
-function isValidation(value: MaybeValidation): value is Validation {
-  return value !== null && typeof value === 'object' && !Array.isArray(value) && value._isValidation
-}

package/lib/validation/rules/day.ts

@@ -1,11 +0,0 @@
-import { day as baseDay } from '../validators'
-import { Rule } from './'
-
-export default function day(year?: string, month?: string, message?: string): Rule {
-  return {
-    name: 'day',
-    message: message ?? 'The Date is invalid.',
-    optional: true,
-    validate: (value, data) => baseDay(value, data[year!], data[month!])
-  }
-}

package/lib/validation/rules/email.ts

@@ -1,11 +0,0 @@
-import { email as baseEmail } from '../validators'
-import { Rule } from './'
-
-export default function email(message?: string): Rule {
-  return {
-    name: 'email',
-    message: message ?? 'The Email address is invalid.',
-    optional: true,
-    validate: baseEmail
-  }
-}

package/lib/validation/rules/every.ts

@@ -1,38 +0,0 @@
-import { Rule } from './'
-
-interface Options {
-  [name: string]: Rule[]
-}
-
-export default function every(options: Options): Rule {
-  return {
-    name: 'each',
-    message: 'Error found in items.',
-    optional: true,
-    validate(value: Record<string, any>[], data): boolean {
-      return value.every(item => check(options, item, data))
-    }
-  }
-}
-
-function check(
-  options: Options,
-  item: Record<string, any>,
-  data: any
-): boolean {
-  for (const key in item) {
-    const rules = options[key]
-
-    if (!rules) {
-      continue
-    }
-
-    const result = rules.every(rule => rule.validate(item[key], data))
-
-    if (!result) {
-      return false
-    }
-  }
-
-  return true
-}

package/lib/validation/rules/include.ts

@@ -1,11 +0,0 @@
-import { include as baseInclude } from '../validators'
-import { Rule } from './'
-
-export default function required(other: string, message?: string): Rule {
-  return {
-    name: 'include',
-    message: message ?? `The value must include ${other}.`,
-    optional: true,
-    validate: (value, data) => baseInclude(value, data[other])
-  }
-}

package/lib/validation/rules/includeSome.ts

@@ -1,11 +0,0 @@
-import { includeSome as baseIncludeSome } from '../validators'
-import { Rule } from './'
-
-export default function required(other: string, message?: string): Rule {
-  return {
-    name: 'includeSome',
-    message: message ?? `The value must include some of ${other}.`,
-    optional: true,
-    validate: (value, data) => baseIncludeSome(value, data[other])
-  }
-}

package/lib/validation/rules/integer.ts

@@ -1,11 +0,0 @@
-import { integer as baseInteger } from '../validators'
-import { Rule } from './'
-
-export default function integer(message?: string): Rule {
-  return {
-    name: 'maxValue',
-    message: message ?? 'The value must not contain decimals.',
-    optional: true,
-    validate: baseInteger
-  }
-}

package/lib/validation/rules/maxValue.ts

@@ -1,11 +0,0 @@
-import { maxValue as baseMaxValue } from '../validators'
-import { Rule } from './'
-
-export default function maxValue(max: number, message?: string): Rule {
-  return {
-    name: 'maxValue',
-    message: message ?? `The value must be ${max} or less.`,
-    optional: true,
-    validate: value => baseMaxValue(value, max)
-  }
-}

package/lib/validation/rules/minValue.ts

@@ -1,11 +0,0 @@
-import { minValue as baseMinValue } from '../validators'
-import { Rule } from './'
-
-export default function minValue(min: number, message?: string): Rule {
-  return {
-    name: 'minValue',
-    message: message ?? `The value must be ${min} or more.`,
-    optional: true,
-    validate: value => baseMinValue(value, min)
-  }
-}

package/lib/validation/rules/month.ts

@@ -1,11 +0,0 @@
-import { month as baseMonth } from '../validators'
-import { Rule } from './'
-
-export default function month(message?: string): Rule {
-  return {
-    name: 'month',
-    message: message ?? 'The month is invalid.',
-    optional: true,
-    validate: baseMonth
-  }
-}