@globalbrain/sefirot 0.72.0 → 2.0.0-draft.1

package/lib/composables/Action.ts

@@ -1,141 +0,0 @@
-import { Values, OmitType } from '../types/Utils'
-import { Refish } from './Utils'
-
-export type Action = Values<Actions>
-
-export interface Actions {
-  ButtonAction: ButtonAction
-  PillAction: PillAction
-  AvatarAction: AvatarAction
-  SwitchAction: SwitchAction
-}
-
-export interface ActionBase {
-  type: Type
-  size?: Size
-  gap?: number
-  callback?(): void
-}
-
-export type Type = Values<typeof Types>
-
-export const Types = {
-  Button: 'button',
-  Avatar: 'avatar',
-  Pill: 'pill',
-  Switch: 'switch'
-} as const
-
-export type Size = Values<typeof Sizes>
-
-export const Sizes = {
-  Small: 'small',
-  Medium: 'medium'
-} as const
-
-export interface ButtonAction extends ActionBase {
-  type: typeof Types.Button
-  kind?: ButtonActionKind
-  mode?: ButtonActionMode
-  icon?: any
-  label?: string
-  link?: string
-  rounded?: boolean
-  inverse?: boolean
-  loading?: boolean
-}
-
-export type ButtonActionKind = Values<typeof ButtonActionKinds>
-
-export const ButtonActionKinds = {
-  Primary: 'primary',
-  Secondary: 'secondary',
-  Tertiary: 'tertiary',
-  Text: 'text',
-  Mute: 'mute'
-} as const
-
-export type ButtonActionMode = Values<typeof ButtonActionModes>
-
-export const ButtonActionModes = {
-  Neutral: 'neutral',
-  Info: 'info',
-  Success: 'success',
-  Warning: 'warning',
-  Danger: 'danger'
-} as const
-
-export interface PillAction extends ActionBase {
-  type: typeof Types.Pill
-  mode?: PillActionMode
-  label: string
-}
-
-export type PillActionMode = Values<typeof PillActionModes>
-
-export const PillActionModes = {
-  Neutral: 'neutral',
-  Info: 'info',
-  Success: 'success',
-  Warning: 'warning',
-  Danger: 'danger'
-} as const
-
-export interface AvatarAction extends ActionBase {
-  type: typeof Types.Avatar
-  avatars: AvatarActionAvatar[]
-}
-
-export interface AvatarActionAvatar {
-  avatar: string
-  name?: string
-}
-
-export interface SwitchAction extends ActionBase {
-  type: typeof Types.Switch
-  value: Refish<boolean>
-  mode?: SwitchActionMode
-  text?: string
-  textMode?: SwitchActionTextMode
-}
-
-export type SwitchActionMode = Values<typeof SwitchActionModes>
-
-export const SwitchActionModes = {
-  Neutral: 'neutral',
-  Info: 'info',
-  Success: 'success',
-  Warning: 'warning',
-  Danger: 'danger'
-} as const
-
-export type SwitchActionTextMode = Values<typeof SwitchActionTextModes>
-
-export const SwitchActionTextModes = {
-  Neutral: 'neutral',
-  Mute: 'mute',
-  Info: 'info',
-  Success: 'success',
-  Warning: 'warning',
-  Danger: 'danger'
-} as const
-
-export function useAction<T extends Action>(action: T): T {
-  return action
-}
-
-export function useButtonAction(action: OmitType<ButtonAction>): ButtonAction {
-  return { type: Types.Button, ...action }
-}
-
-export function usePillAction(action: OmitType<PillAction>): PillAction {
-  return { type: Types.Pill, ...action }
-}
-
-export function useAvatarAction(action: OmitType<AvatarAction>): AvatarAction {
-  return { type: Types.Avatar, ...action }
-}
-
-export function useSwitchAction(action: OmitType<SwitchAction>): SwitchAction {
-  return { type: Types.Switch, ...action }
-}

package/lib/composables/Alert.ts

@@ -1,50 +0,0 @@
-import { Values } from '../types/Utils'
-import { useStore } from './Store'
-import { useModalUid } from './Modal'
-
-export interface Alert {
-  open(alert: AlertOptions): Promise<any>
-  close(): Promise<any>
-}
-
-export interface AlertOptions {
-  type?: AlertMode
-  title: string
-  text: string
-  actions: Action[]
-}
-
-export type AlertMode = Values<typeof AlertModes>
-
-export const AlertModes = {
-  Info: 'info',
-  Success: 'success',
-  Warning: 'warning',
-  Danger: 'danger'
-} as const
-
-export interface Action {
-  type: 'primary' | 'secondary' | 'tertiary' | 'text' | 'mute'
-  mode: 'neutral' | 'info' | 'success' | 'warning' | 'danger'
-  icon?: any
-  label: string
-  callback(): void
-}
-
-export function useAlert(): Alert {
-  const store = useStore()
-  const uid = useModalUid()
-
-  function open(alert: AlertOptions) {
-    return store.dispatch('alert/open', { ...alert, uid })
-  }
-
-  function close() {
-    return store.dispatch('alert/close', uid)
-  }
-
-  return {
-    open,
-    close
-  }
-}

package/lib/composables/Card.ts

@@ -1,46 +0,0 @@
-import { Values } from '../types/Utils'
-import { Refish } from './Utils'
-
-export interface Card {
-  header?: Header
-  footer?: Footer
-  mode?: Mode
-  round?: number
-  depth?: number
-  collapsable?: boolean
-}
-
-export interface Header {
-  title?: string
-  actions?: Refish<Action[]>
-}
-
-export interface Footer {
-  actions: Refish<Action[]>
-}
-
-export interface Action {
-  type: 'primary' | 'secondary' | 'tertiary' | 'text' | 'mute'
-  mode?: Mode
-  icon?: ActionIconType | object
-  label?: string
-  link?: string
-  disabled?: string | null
-  callback?(): void
-}
-
-export type ActionIconType = 'edit-3' | 'plus' | 'trash-2'
-
-export type Mode = Values<typeof Modes>
-
-export const Modes = {
-  Neutral: 'neutral',
-  Info: 'info',
-  Success: 'success',
-  Warning: 'warning',
-  Danger: 'danger'
-} as const
-
-export function useCard(card: Card): Card {
-  return card
-}

package/lib/composables/FormValidation.ts

@@ -1,150 +0,0 @@
-import { Ref, ComputedRef, ref, computed } from '@vue/composition-api'
-import { required } from '../validation/validators'
-import { Rule } from '../validation/rules'
-
-export interface Validation {
-  $isValidation: boolean
-  $isDirty: Ref<boolean> | ComputedRef<boolean>
-  $isValid: ComputedRef<boolean>
-  $errors: ComputedRef<Error[]>
-  $touch (): void
-  $reset (): void
-  $validate (): boolean
-  [key: string]: any
-}
-
-export type Rules = NestedRules | Validators
-
-export interface NestedRules {
-  [key: string]: Rules | any
-}
-
-export interface Validators {
-  [key: string]: Rule[]
-}
-
-export type Error = [string, string]
-
-export function useFormValidation<T extends Record<string, any>>(data: T, rules: Rules, rootData?: T): Validation {
-  const validation = {} as Validation
-
-  setValidations(validation, data, rules, rootData ?? data)
-
-  setupValidation(validation)
-
-  return validation
-}
-
-function setValidations<T extends Record<string, any>>(validation: Validation, data: T, rules: Rules, rootData: T): void {
-  for (const name in rules) {
-    const rule = rules[name]
-
-    if (isValidation(rule)) {
-      validation[name] = rule
-      continue
-    }
-
-    if (Array.isArray(rule)) {
-      validation[name] = createValidation(name, data, rule, rootData)
-      continue
-    }
-
-    validation[name] = useFormValidation(data[name], rule, rootData)
-  }
-}
-
-function createValidation<T extends Record<string, any>>(name: string, data: T, rules: Rule[], rootData: T): Validation {
-  const isDirty = ref(false)
-  const isValid = computed(() => errors.value.length === 0)
-  const errors = computed(() => getErrors(name, data, rules, rootData))
-
-  function touch(): void {
-    isDirty.value = true
-  }
-
-  function reset(): void {
-    isDirty.value = false
-  }
-
-  function validate(): boolean {
-    touch()
-    return isValid.value
-  }
-
-  return {
-    $isValidation: true,
-    $isDirty: isDirty,
-    $isValid: isValid,
-    $errors: errors,
-    $touch: touch,
-    $reset: reset,
-    $validate: validate
-  }
-}
-
-function setupValidation(validation: Validation): void {
-  const isDirty = computed(() => {
-    return Object.keys(validation).every((field) => {
-      const v = validation[field]
-
-      return isValidation(v) ? v.$isDirty.value : true
-    })
-  })
-
-  const isValid = computed(() => errors.value.length === 0)
-
-  const errors = computed(() => {
-    return Object.keys(validation).reduce<Error[]>((errors, field) => {
-      const v = validation[field]
-      return isValidation(v) ? errors.concat(v.$errors.value) : errors
-    }, [])
-  })
-
-  function touch(): void {
-    callAll(validation, 'touch')
-  }
-
-  function reset(): void {
-    callAll(validation, 'reset')
-  }
-
-  const validate = () => {
-    touch()
-    return isValid.value
-  }
-
-  validation.$isValidation = true
-  validation.$isDirty = isDirty
-  validation.$errors = errors
-  validation.$isValid = isValid
-  validation.$touch = touch
-  validation.$reset = reset
-  validation.$validate = validate
-}
-
-function getErrors<T extends Record<string, any>>(name: string, data: T, rules: Rule[], rootData: T): Error[] {
-  return rules.reduce<Error[]>((errors, rule) => {
-    const value = data[name]
-
-    if (rule.optional && !required(value)) {
-      return errors
-    }
-
-    if (!rule.validate(value, rootData)) {
-      errors.push([rule.name, rule.message])
-    }
-
-    return errors
-  }, [])
-}
-
-function callAll(validation: Validation, method: 'touch' | 'reset'): void {
-  for (const field in validation) {
-    const v = validation[field]
-    isValidation(v) && v[`$${method}`]()
-  }
-}
-
-function isValidation(obj: any): obj is Validation {
-  return obj !== null && typeof obj === 'object' && !Array.isArray(obj) && !!obj.$isValidation
-}

package/lib/composables/Header.ts

@@ -1,72 +0,0 @@
-import { ComputedRef } from '@vue/composition-api'
-import { Values } from '../types/Utils'
-import { Refish } from './Utils'
-import { Action } from './Action'
-import { Tag } from './Tag'
-import { Dropdown, UseDropdownOptions, useDropdown } from './Dropdown'
-
-export * from './Action'
-export * from './Tag'
-
-export interface Header {
-  size?: Size
-  mode?: Mode
-  icon?: any
-  title?: Refish<string>
-  search?: Search
-  actions?: Refish<Action[]>
-  tags?: Refish<Tag[]>
-}
-
-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'
-} as const
-
-export interface Search {
-  placeholder: string
-  presets?: SearchPresets
-  value: ComputedRef<string>
-  onEnter(text: string): void
-}
-
-export interface SearchPresets {
-  title: string
-  dropdown: Dropdown
-}
-
-export interface UseSearchPresetsOptions {
-  title: string
-  dropdown: UseDropdownOptions
-}
-
-export function useHeader(header: Header): Header {
-  return header
-}
-
-export function useSearch(search: Search): Search {
-  return search
-}
-
-export function useSearchPresets(presets: UseSearchPresetsOptions): SearchPresets {
-  return {
-    title: presets.title,
-    dropdown: useDropdown({
-      closeOnClick: true,
-      ...presets.dropdown
-    })
-  }
-}

package/lib/composables/InputDropdown.ts

@@ -1,6 +0,0 @@
-export type { Search, Item, TextItem, UserItem } from './Dropdown'
-export {
-  useSearch,
-  useTextItem as useTextOption,
-  useUserItem as useUserOption
-} from './Dropdown'

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