@globalbrain/sefirot 0.72.0 → 2.0.0-draft.4

package/lib/composables/Markdown.ts

@@ -1,138 +0,0 @@
-import MarkdownIt from 'markdown-it'
-import { onUnmounted, Ref } from '@vue/composition-api'
-import { isCallbackUrl, isExternalUrl, LinkAttrs, linkPlugin } from './markdown/LinkPlugin'
-import { useRouter } from './Router'
-
-export type UseMarkdown = (source: string, inline: boolean) => string
-
-export interface UseMarkdownOptions extends MarkdownIt.Options {
-  linkAttrs?: LinkAttrs
-  config?: (md: MarkdownIt) => void
-}
-
-export function useMarkdown(options: UseMarkdownOptions = {}): UseMarkdown {
-  const md = new MarkdownIt({
-    linkify: true,
-    ...options
-  })
-
-  md.use(linkPlugin, {
-    target: '_blank',
-    rel: 'noopener noreferrer',
-    ...options.linkAttrs
-  })
-
-  if (options.config) {
-    options.config(md)
-  }
-
-  return (source, inline) => {
-    return inline ? md.renderInline(source) : md.render(source)
-  }
-}
-
-export interface UseLink {
-  addListeners(): void
-  removeListeners(): void
-  subscribe(cb: LinkSubscriber): () => void
-}
-
-export interface UseLinkOptions {
-  container: Ref<Element | null>
-  callbacks?: LinkCallback[]
-}
-
-export interface LinkSubscriberPayload {
-  event: Event
-  target: HTMLAnchorElement
-  isExternal: boolean
-  isCallback: boolean
-}
-
-export type LinkSubscriber = (payload: LinkSubscriberPayload) => void
-
-export type LinkCallback = () => void
-
-export function useLink({ container, callbacks }: UseLinkOptions): UseLink {
-  const router = useRouter()
-  const subscribers: LinkSubscriber[] = []
-
-  onUnmounted(() => removeListeners())
-
-  function handler(event: Event): void {
-    const target = event.target as HTMLAnchorElement
-    const href = target.getAttribute('href')!
-
-    if (!href) {
-      return
-    }
-
-    const isExternal = isExternalUrl(href)
-    const isCallback = isCallbackUrl(href)
-
-    subscribers.forEach(sub => sub({
-      event,
-      target,
-      isExternal,
-      isCallback
-    }))
-
-    if (isExternal) {
-      return
-    }
-
-    if (!event.defaultPrevented) {
-      event.preventDefault()
-    }
-
-    if (isCallback) {
-      const idx = parseInt(target.dataset.callbackId || '')
-      const callback = (callbacks ?? [])[idx]
-
-      if (!callback) {
-        throw new Error(`Callback not found at index: ${idx}`)
-      }
-
-      return callback()
-    }
-
-    router.push(href)
-  }
-
-  function addListeners(): void {
-    removeListeners()
-
-    if (container.value) {
-      findLinks(container.value).forEach((element) => {
-        element.addEventListener('click', handler)
-      })
-    }
-  }
-
-  function removeListeners(): void {
-    if (container.value) {
-      findLinks(container.value).forEach((element) => {
-        element.removeEventListener('click', handler)
-      })
-    }
-  }
-
-  function subscribe(fn: LinkSubscriber): () => void {
-    subscribers.push(fn)
-
-    return () => {
-      const idx = subscribers.indexOf(fn)
-      idx > -1 && subscribers.splice(idx, 1)
-    }
-  }
-
-  return {
-    addListeners,
-    removeListeners,
-    subscribe
-  }
-}
-
-function findLinks(target: Element) {
-  return target.querySelectorAll('a.SMarkdown-link')
-}

package/lib/composables/Router.ts

@@ -1,20 +0,0 @@
-import { computed, ComputedRef, getCurrentInstance } from '@vue/composition-api'
-import VueRouter, { Route } from 'vue-router'
-
-export function useRouter(): VueRouter {
-  const { proxy } = getCurrentInstance()!
-
-  return proxy.$router
-}
-
-export function useRoute(): ComputedRef<Route> {
-  const { proxy } = getCurrentInstance()!
-
-  return computed(() => proxy.$route)
-}
-
-export function useParams(): ComputedRef<Record<string, string>> {
-  const { proxy } = getCurrentInstance()!
-
-  return computed(() => proxy.$route.params)
-}

package/lib/composables/Step.ts

@@ -1,7 +0,0 @@
-export interface Step {
-  status: StepStatus
-  text?: string
-}
-
-export type StepStatus = 'upcoming' | 'active' | 'done' | 'failed'
-export type BarMode = 'mute' | 'active'

package/lib/composables/Store.ts

@@ -1,9 +0,0 @@
-import { getCurrentInstance } from '@vue/composition-api'
-import { Store } from 'vuex'
-import { State } from '../store/Sefirot'
-
-export function useStore(): Store<State> {
-  const { proxy } = getCurrentInstance()!
-
-  return proxy.$store
-}

package/lib/composables/Tag.ts

@@ -1,32 +0,0 @@
-import { Values } from '../types/Utils'
-
-export interface Tag {
-  size?: Size
-  mode?: Mode
-  icon?: any
-  text?: string
-  link?: string
-}
-
-export type Size = Values<typeof Sizes>
-
-export const Sizes = {
-  Small: 'small',
-  Medium: 'medium',
-  Large: 'large'
-} as const
-
-export type Mode = Values<typeof Modes>
-
-export const Modes = {
-  Neutral: 'neutral',
-  Info: 'info',
-  Success: 'success',
-  Warning: 'warning',
-  Danger: 'danger',
-  Mute: 'mute'
-} as const
-
-export function useTag(tag: Tag): Tag {
-  return tag
-}

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
-}