@builder.io/sdk-vue 0.6.1-1 → 0.6.1

package/vue2/node_modules/vue/src/shared/util.ts

@@ -1,372 +0,0 @@
-export const emptyObject: Record<string, any> = Object.freeze({})
-
-export const isArray = Array.isArray
-
-// These helpers produce better VM code in JS engines due to their
-// explicitness and function inlining.
-export function isUndef(v: any): v is undefined | null {
-  return v === undefined || v === null
-}
-
-export function isDef<T>(v: T): v is NonNullable<T> {
-  return v !== undefined && v !== null
-}
-
-export function isTrue(v: any): boolean {
-  return v === true
-}
-
-export function isFalse(v: any): boolean {
-  return v === false
-}
-
-/**
- * Check if value is primitive.
- */
-export function isPrimitive(value: any): boolean {
-  return (
-    typeof value === 'string' ||
-    typeof value === 'number' ||
-    // $flow-disable-line
-    typeof value === 'symbol' ||
-    typeof value === 'boolean'
-  )
-}
-
-export function isFunction(value: any): value is (...args: any[]) => any {
-  return typeof value === 'function'
-}
-
-/**
- * Quick object check - this is primarily used to tell
- * objects from primitive values when we know the value
- * is a JSON-compliant type.
- */
-export function isObject(obj: any): boolean {
-  return obj !== null && typeof obj === 'object'
-}
-
-/**
- * Get the raw type string of a value, e.g., [object Object].
- */
-const _toString = Object.prototype.toString
-
-export function toRawType(value: any): string {
-  return _toString.call(value).slice(8, -1)
-}
-
-/**
- * Strict object type check. Only returns true
- * for plain JavaScript objects.
- */
-export function isPlainObject(obj: any): boolean {
-  return _toString.call(obj) === '[object Object]'
-}
-
-export function isRegExp(v: any): v is RegExp {
-  return _toString.call(v) === '[object RegExp]'
-}
-
-/**
- * Check if val is a valid array index.
- */
-export function isValidArrayIndex(val: any): boolean {
-  const n = parseFloat(String(val))
-  return n >= 0 && Math.floor(n) === n && isFinite(val)
-}
-
-export function isPromise(val: any): val is Promise<any> {
-  return (
-    isDef(val) &&
-    typeof val.then === 'function' &&
-    typeof val.catch === 'function'
-  )
-}
-
-/**
- * Convert a value to a string that is actually rendered.
- */
-export function toString(val: any): string {
-  return val == null
-    ? ''
-    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
-    ? JSON.stringify(val, null, 2)
-    : String(val)
-}
-
-/**
- * Convert an input value to a number for persistence.
- * If the conversion fails, return original string.
- */
-export function toNumber(val: string): number | string {
-  const n = parseFloat(val)
-  return isNaN(n) ? val : n
-}
-
-/**
- * Make a map and return a function for checking if a key
- * is in that map.
- */
-export function makeMap(
-  str: string,
-  expectsLowerCase?: boolean
-): (key: string) => true | undefined {
-  const map = Object.create(null)
-  const list: Array<string> = str.split(',')
-  for (let i = 0; i < list.length; i++) {
-    map[list[i]] = true
-  }
-  return expectsLowerCase ? val => map[val.toLowerCase()] : val => map[val]
-}
-
-/**
- * Check if a tag is a built-in tag.
- */
-export const isBuiltInTag = makeMap('slot,component', true)
-
-/**
- * Check if an attribute is a reserved attribute.
- */
-export const isReservedAttribute = makeMap('key,ref,slot,slot-scope,is')
-
-/**
- * Remove an item from an array.
- */
-export function remove(arr: Array<any>, item: any): Array<any> | void {
-  const len = arr.length
-  if (len) {
-    // fast path for the only / last item
-    if (item === arr[len - 1]) {
-      arr.length = len - 1
-      return
-    }
-    const index = arr.indexOf(item)
-    if (index > -1) {
-      return arr.splice(index, 1)
-    }
-  }
-}
-
-/**
- * Check whether an object has the property.
- */
-const hasOwnProperty = Object.prototype.hasOwnProperty
-export function hasOwn(obj: Object | Array<any>, key: string): boolean {
-  return hasOwnProperty.call(obj, key)
-}
-
-/**
- * Create a cached version of a pure function.
- */
-export function cached<R>(fn: (str: string) => R): (sr: string) => R {
-  const cache: Record<string, R> = Object.create(null)
-  return function cachedFn(str: string) {
-    const hit = cache[str]
-    return hit || (cache[str] = fn(str))
-  }
-}
-
-/**
- * Camelize a hyphen-delimited string.
- */
-const camelizeRE = /-(\w)/g
-export const camelize = cached((str: string): string => {
-  return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''))
-})
-
-/**
- * Capitalize a string.
- */
-export const capitalize = cached((str: string): string => {
-  return str.charAt(0).toUpperCase() + str.slice(1)
-})
-
-/**
- * Hyphenate a camelCase string.
- */
-const hyphenateRE = /\B([A-Z])/g
-export const hyphenate = cached((str: string): string => {
-  return str.replace(hyphenateRE, '-$1').toLowerCase()
-})
-
-/**
- * Simple bind polyfill for environments that do not support it,
- * e.g., PhantomJS 1.x. Technically, we don't need this anymore
- * since native bind is now performant enough in most browsers.
- * But removing it would mean breaking code that was able to run in
- * PhantomJS 1.x, so this must be kept for backward compatibility.
- */
-
-/* istanbul ignore next */
-function polyfillBind(fn: Function, ctx: Object): Function {
-  function boundFn(a: any) {
-    const l = arguments.length
-    return l
-      ? l > 1
-        ? fn.apply(ctx, arguments)
-        : fn.call(ctx, a)
-      : fn.call(ctx)
-  }
-
-  boundFn._length = fn.length
-  return boundFn
-}
-
-function nativeBind(fn: Function, ctx: Object): Function {
-  return fn.bind(ctx)
-}
-
-// @ts-expect-error bind cannot be `undefined`
-export const bind = Function.prototype.bind ? nativeBind : polyfillBind
-
-/**
- * Convert an Array-like object to a real Array.
- */
-export function toArray(list: any, start?: number): Array<any> {
-  start = start || 0
-  let i = list.length - start
-  const ret: Array<any> = new Array(i)
-  while (i--) {
-    ret[i] = list[i + start]
-  }
-  return ret
-}
-
-/**
- * Mix properties into target object.
- */
-export function extend(
-  to: Record<PropertyKey, any>,
-  _from?: Record<PropertyKey, any>
-): Record<PropertyKey, any> {
-  for (const key in _from) {
-    to[key] = _from[key]
-  }
-  return to
-}
-
-/**
- * Merge an Array of Objects into a single Object.
- */
-export function toObject(arr: Array<any>): object {
-  const res = {}
-  for (let i = 0; i < arr.length; i++) {
-    if (arr[i]) {
-      extend(res, arr[i])
-    }
-  }
-  return res
-}
-
-/* eslint-disable no-unused-vars */
-
-/**
- * Perform no operation.
- * Stubbing args to make Flow happy without leaving useless transpiled code
- * with ...rest (https://flow.org/blog/2017/05/07/Strict-Function-Call-Arity/).
- */
-export function noop(a?: any, b?: any, c?: any) {}
-
-/**
- * Always return false.
- */
-export const no = (a?: any, b?: any, c?: any) => false
-
-/* eslint-enable no-unused-vars */
-
-/**
- * Return the same value.
- */
-export const identity = (_: any) => _
-
-/**
- * Generate a string containing static keys from compiler modules.
- */
-export function genStaticKeys(
-  modules: Array<{ staticKeys?: string[] } /* ModuleOptions */>
-): string {
-  return modules
-    .reduce((keys, m) => {
-      return keys.concat(m.staticKeys || [])
-    }, [] as string[])
-    .join(',')
-}
-
-/**
- * Check if two values are loosely equal - that is,
- * if they are plain objects, do they have the same shape?
- */
-export function looseEqual(a: any, b: any): boolean {
-  if (a === b) return true
-  const isObjectA = isObject(a)
-  const isObjectB = isObject(b)
-  if (isObjectA && isObjectB) {
-    try {
-      const isArrayA = Array.isArray(a)
-      const isArrayB = Array.isArray(b)
-      if (isArrayA && isArrayB) {
-        return (
-          a.length === b.length &&
-          a.every((e: any, i: any) => {
-            return looseEqual(e, b[i])
-          })
-        )
-      } else if (a instanceof Date && b instanceof Date) {
-        return a.getTime() === b.getTime()
-      } else if (!isArrayA && !isArrayB) {
-        const keysA = Object.keys(a)
-        const keysB = Object.keys(b)
-        return (
-          keysA.length === keysB.length &&
-          keysA.every(key => {
-            return looseEqual(a[key], b[key])
-          })
-        )
-      } else {
-        /* istanbul ignore next */
-        return false
-      }
-    } catch (e: any) {
-      /* istanbul ignore next */
-      return false
-    }
-  } else if (!isObjectA && !isObjectB) {
-    return String(a) === String(b)
-  } else {
-    return false
-  }
-}
-
-/**
- * Return the first index at which a loosely equal value can be
- * found in the array (if value is a plain object, the array must
- * contain an object of the same shape), or -1 if it is not present.
- */
-export function looseIndexOf(arr: Array<unknown>, val: unknown): number {
-  for (let i = 0; i < arr.length; i++) {
-    if (looseEqual(arr[i], val)) return i
-  }
-  return -1
-}
-
-/**
- * Ensure a function is called only once.
- */
-export function once<T extends (...args: any[]) => any>(fn: T): T {
-  let called = false
-  return function () {
-    if (!called) {
-      called = true
-      fn.apply(this, arguments as any)
-    }
-  } as any
-}
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is#polyfill
-export function hasChanged(x: unknown, y: unknown): boolean {
-  if (x === y) {
-    return x === 0 && 1 / x !== 1 / (y as number)
-  } else {
-    return x === x || y === y
-  }
-}

package/vue2/node_modules/vue/src/v3/apiAsyncComponent.ts

@@ -1,117 +0,0 @@
-import { warn, isFunction, isObject } from 'core/util'
-
-interface AsyncComponentOptions {
-  loader: Function
-  loadingComponent?: any
-  errorComponent?: any
-  delay?: number
-  timeout?: number
-  suspensible?: boolean
-  onError?: (
-    error: Error,
-    retry: () => void,
-    fail: () => void,
-    attempts: number
-  ) => any
-}
-
-type AsyncComponentFactory = () => {
-  component: Promise<any>
-  loading?: any
-  error?: any
-  delay?: number
-  timeout?: number
-}
-
-/**
- * v3-compatible async component API.
- * @internal the type is manually declared in <root>/types/v3-define-async-component.d.ts
- * because it relies on existing manual types
- */
-export function defineAsyncComponent(
-  source: (() => any) | AsyncComponentOptions
-): AsyncComponentFactory {
-  if (isFunction(source)) {
-    source = { loader: source } as AsyncComponentOptions
-  }
-
-  const {
-    loader,
-    loadingComponent,
-    errorComponent,
-    delay = 200,
-    timeout, // undefined = never times out
-    suspensible = false, // in Vue 3 default is true
-    onError: userOnError
-  } = source
-
-  if (__DEV__ && suspensible) {
-    warn(
-      `The suspensiblbe option for async components is not supported in Vue2. It is ignored.`
-    )
-  }
-
-  let pendingRequest: Promise<any> | null = null
-
-  let retries = 0
-  const retry = () => {
-    retries++
-    pendingRequest = null
-    return load()
-  }
-
-  const load = (): Promise<any> => {
-    let thisRequest: Promise<any>
-    return (
-      pendingRequest ||
-      (thisRequest = pendingRequest =
-        loader()
-          .catch(err => {
-            err = err instanceof Error ? err : new Error(String(err))
-            if (userOnError) {
-              return new Promise((resolve, reject) => {
-                const userRetry = () => resolve(retry())
-                const userFail = () => reject(err)
-                userOnError(err, userRetry, userFail, retries + 1)
-              })
-            } else {
-              throw err
-            }
-          })
-          .then((comp: any) => {
-            if (thisRequest !== pendingRequest && pendingRequest) {
-              return pendingRequest
-            }
-            if (__DEV__ && !comp) {
-              warn(
-                `Async component loader resolved to undefined. ` +
-                  `If you are using retry(), make sure to return its return value.`
-              )
-            }
-            // interop module default
-            if (
-              comp &&
-              (comp.__esModule || comp[Symbol.toStringTag] === 'Module')
-            ) {
-              comp = comp.default
-            }
-            if (__DEV__ && comp && !isObject(comp) && !isFunction(comp)) {
-              throw new Error(`Invalid async component load result: ${comp}`)
-            }
-            return comp
-          }))
-    )
-  }
-
-  return () => {
-    const component = load()
-
-    return {
-      component,
-      delay,
-      timeout,
-      error: errorComponent,
-      loading: loadingComponent
-    }
-  }
-}

package/vue2/node_modules/vue/src/v3/apiInject.ts

@@ -1,71 +0,0 @@
-import { isFunction, warn } from 'core/util'
-import { currentInstance } from './currentInstance'
-import type { Component } from 'types/component'
-
-export interface InjectionKey<T> extends Symbol {}
-
-export function provide<T>(key: InjectionKey<T> | string | number, value: T) {
-  if (!currentInstance) {
-    if (__DEV__) {
-      warn(`provide() can only be used inside setup().`)
-    }
-  } else {
-    // TS doesn't allow symbol as index type
-    resolveProvided(currentInstance)[key as string] = value
-  }
-}
-
-export function resolveProvided(vm: Component): Record<string, any> {
-  // by default an instance inherits its parent's provides object
-  // but when it needs to provide values of its own, it creates its
-  // own provides object using parent provides object as prototype.
-  // this way in `inject` we can simply look up injections from direct
-  // parent and let the prototype chain do the work.
-  const existing = vm._provided
-  const parentProvides = vm.$parent && vm.$parent._provided
-  if (parentProvides === existing) {
-    return (vm._provided = Object.create(parentProvides))
-  } else {
-    return existing
-  }
-}
-
-export function inject<T>(key: InjectionKey<T> | string): T | undefined
-export function inject<T>(
-  key: InjectionKey<T> | string,
-  defaultValue: T,
-  treatDefaultAsFactory?: false
-): T
-export function inject<T>(
-  key: InjectionKey<T> | string,
-  defaultValue: T | (() => T),
-  treatDefaultAsFactory: true
-): T
-export function inject(
-  key: InjectionKey<any> | string,
-  defaultValue?: unknown,
-  treatDefaultAsFactory = false
-) {
-  // fallback to `currentRenderingInstance` so that this can be called in
-  // a functional component
-  const instance = currentInstance
-  if (instance) {
-    // #2400
-    // to support `app.use` plugins,
-    // fallback to appContext's `provides` if the instance is at root
-    const provides = instance.$parent && instance.$parent._provided
-
-    if (provides && (key as string | symbol) in provides) {
-      // TS doesn't allow symbol as index type
-      return provides[key as string]
-    } else if (arguments.length > 1) {
-      return treatDefaultAsFactory && isFunction(defaultValue)
-        ? defaultValue.call(instance)
-        : defaultValue
-    } else if (__DEV__) {
-      warn(`injection "${String(key)}" not found.`)
-    }
-  } else if (__DEV__) {
-    warn(`inject() can only be used inside setup() or functional components.`)
-  }
-}

package/vue2/node_modules/vue/src/v3/apiLifecycle.ts

@@ -1,68 +0,0 @@
-import { DebuggerEvent } from './debug'
-import { Component } from 'types/component'
-import { mergeLifecycleHook, warn } from '../core/util'
-import { currentInstance } from './currentInstance'
-
-function createLifeCycle<T extends (...args: any[]) => any = () => void>(
-  hookName: string
-) {
-  return (fn: T, target: any = currentInstance) => {
-    if (!target) {
-      __DEV__ &&
-        warn(
-          `${formatName(
-            hookName
-          )} is called when there is no active component instance to be ` +
-            `associated with. ` +
-            `Lifecycle injection APIs can only be used during execution of setup().`
-        )
-      return
-    }
-    return injectHook(target, hookName, fn)
-  }
-}
-
-function formatName(name: string) {
-  if (name === 'beforeDestroy') {
-    name = 'beforeUnmount'
-  } else if (name === 'destroyed') {
-    name = 'unmounted'
-  }
-  return `on${name[0].toUpperCase() + name.slice(1)}`
-}
-
-function injectHook(instance: Component, hookName: string, fn: () => void) {
-  const options = instance.$options
-  options[hookName] = mergeLifecycleHook(options[hookName], fn)
-}
-
-export const onBeforeMount = createLifeCycle('beforeMount')
-export const onMounted = createLifeCycle('mounted')
-export const onBeforeUpdate = createLifeCycle('beforeUpdate')
-export const onUpdated = createLifeCycle('updated')
-export const onBeforeUnmount = createLifeCycle('beforeDestroy')
-export const onUnmounted = createLifeCycle('destroyed')
-export const onActivated = createLifeCycle('activated')
-export const onDeactivated = createLifeCycle('deactivated')
-export const onServerPrefetch = createLifeCycle('serverPrefetch')
-
-export const onRenderTracked =
-  createLifeCycle<(e: DebuggerEvent) => any>('renderTracked')
-export const onRenderTriggered =
-  createLifeCycle<(e: DebuggerEvent) => any>('renderTriggered')
-
-export type ErrorCapturedHook<TError = unknown> = (
-  err: TError,
-  instance: any,
-  info: string
-) => boolean | void
-
-const injectErrorCapturedHook =
-  createLifeCycle<ErrorCapturedHook<any>>('errorCaptured')
-
-export function onErrorCaptured<TError = Error>(
-  hook: ErrorCapturedHook<TError>,
-  target: any = currentInstance
-) {
-  injectErrorCapturedHook(hook, target)
-}