@reactive-vscode/reactivity 0.2.0-beta.1 → 0.2.0-beta.2

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@reactive-vscode/reactivity",
   "type": "module",
-  "version": "0.2.0-beta.1",
+  "version": "0.2.0-beta.2",
   "description": "Full Vue Reactivity API without DOM",
   "author": "_Kerman <kermanx@qq.com>",
   "license": "MIT",
@@ -18,25 +18,25 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./src/index.ts",
-      "import": "./src/index.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
     }
   },
-  "main": "./src/index.ts",
-  "types": "./src/index.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "README.md",
-    "shim.d.ts",
-    "src",
-    "tsconfig.json"
+    "dist"
   ],
-  "dependencies": {},
   "devDependencies": {
     "@vue/reactivity": "^3.4.27",
     "@vue/shared": "^3.4.27",
-    "typescript": "^5.4.5"
+    "typescript": "^5.4.5",
+    "vite": "^5.2.12",
+    "vite-plugin-dts": "^3.9.1"
   },
   "scripts": {
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "build": "vite build"
   }
 }

package/shim.d.ts

@@ -1,4 +0,0 @@
-export {}
-declare global {
-  const __DEV__: boolean
-}

package/src/apiWatch.ts

@@ -1,415 +0,0 @@
-import {
-  type ComputedRef,
-  type DebuggerOptions,
-  type EffectScheduler,
-  ReactiveEffect,
-  ReactiveFlags,
-  type Ref,
-  getCurrentScope,
-  isReactive,
-  isRef,
-  isShallow,
-} from '@vue/reactivity'
-import { type SchedulerJob, queueJob } from './scheduler'
-import {
-  EMPTY_OBJ,
-  NOOP,
-  extend,
-  hasChanged,
-  isArray,
-  isFunction,
-  isMap,
-  isObject,
-  isPlainObject,
-  isSet,
-  remove,
-} from '@vue/shared'
-import {
-  ErrorCodes,
-  callWithAsyncErrorHandling,
-  callWithErrorHandling,
-} from './errorHandling'
-import { warn } from './warning'
-
-export type WatchEffect = (onCleanup: OnCleanup) => void
-
-export type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T)
-
-export type WatchCallback<V = any, OV = any> = (
-  value: V,
-  oldValue: OV,
-  onCleanup: OnCleanup,
-) => any
-
-type MapSources<T, Immediate> = {
-  [K in keyof T]: T[K] extends WatchSource<infer V>
-    ? Immediate extends true
-      ? V | undefined
-      : V
-    : T[K] extends object
-      ? Immediate extends true
-        ? T[K] | undefined
-        : T[K]
-      : never
-}
-
-export type OnCleanup = (cleanupFn: () => void) => void
-
-export interface WatchOptionsBase extends DebuggerOptions {
-  flush?: 'pre' | 'post' | 'sync'
-}
-
-export interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
-  immediate?: Immediate
-  deep?: boolean
-  once?: boolean
-}
-
-export type WatchStopHandle = () => void
-
-// Simple effect.
-export function watchEffect(
-  effect: WatchEffect,
-  options?: WatchOptionsBase,
-): WatchStopHandle {
-  return doWatch(effect, null, options)
-}
-
-export function watchPostEffect(
-  effect: WatchEffect,
-  options?: DebuggerOptions,
-) {
-  return doWatch(
-    effect,
-    null,
-    __DEV__ ? extend({}, options as any, { flush: 'post' }) : { flush: 'post' },
-  )
-}
-
-export function watchSyncEffect(
-  effect: WatchEffect,
-  options?: DebuggerOptions,
-) {
-  return doWatch(
-    effect,
-    null,
-    __DEV__ ? extend({}, options as any, { flush: 'sync' }) : { flush: 'sync' },
-  )
-}
-
-// initial value for watchers to trigger on undefined initial values
-const INITIAL_WATCHER_VALUE = {}
-
-type MultiWatchSources = (WatchSource<unknown> | object)[]
-
-// overload: single source + cb
-export function watch<T, Immediate extends Readonly<boolean> = false>(
-  source: WatchSource<T>,
-  cb: WatchCallback<T, Immediate extends true ? T | undefined : T>,
-  options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-// overload: array of multiple sources + cb
-export function watch<
-  T extends MultiWatchSources,
-  Immediate extends Readonly<boolean> = false,
->(
-  sources: [...T],
-  cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,
-  options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-// overload: multiple sources w/ `as const`
-// watch([foo, bar] as const, () => {})
-// somehow [...T] breaks when the type is readonly
-export function watch<
-  T extends Readonly<MultiWatchSources>,
-  Immediate extends Readonly<boolean> = false,
->(
-  source: T,
-  cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,
-  options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-// overload: watching reactive object w/ cb
-export function watch<
-  T extends object,
-  Immediate extends Readonly<boolean> = false,
->(
-  source: T,
-  cb: WatchCallback<T, Immediate extends true ? T | undefined : T>,
-  options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-// implementation
-export function watch<T = any, Immediate extends Readonly<boolean> = false>(
-  source: T | WatchSource<T>,
-  cb: any,
-  options?: WatchOptions<Immediate>,
-): WatchStopHandle {
-  if (__DEV__ && !isFunction(cb)) {
-    warn(
-      `\`watch(fn, options?)\` signature has been moved to a separate API. ` +
-        `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` +
-        `supports \`watch(source, cb, options?) signature.`,
-    )
-  }
-  return doWatch(source as any, cb, options)
-}
-
-function doWatch(
-  source: WatchSource | WatchSource[] | WatchEffect | object,
-  cb: WatchCallback | null,
-  {
-    immediate,
-    deep,
-    flush,
-    once,
-    onTrack,
-    onTrigger,
-  }: WatchOptions = EMPTY_OBJ,
-): WatchStopHandle {
-  if (cb && once) {
-    const _cb = cb
-    cb = (...args) => {
-      _cb(...args)
-      unwatch()
-    }
-  }
-
-  // TODO remove in 3.5
-  if (__DEV__ && deep !== void 0 && typeof deep === 'number') {
-    warn(
-      `watch() "deep" option with number value will be used as watch depth in future versions. ` +
-        `Please use a boolean instead to avoid potential breakage.`,
-    )
-  }
-
-  if (__DEV__ && !cb) {
-    if (immediate !== undefined) {
-      warn(
-        `watch() "immediate" option is only respected when using the ` +
-          `watch(source, callback, options?) signature.`,
-      )
-    }
-    if (deep !== undefined) {
-      warn(
-        `watch() "deep" option is only respected when using the ` +
-          `watch(source, callback, options?) signature.`,
-      )
-    }
-    if (once !== undefined) {
-      warn(
-        `watch() "once" option is only respected when using the ` +
-          `watch(source, callback, options?) signature.`,
-      )
-    }
-  }
-
-  const warnInvalidSource = (s: unknown) => {
-    warn(
-      `Invalid watch source: `,
-      s,
-      `A watch source can only be a getter/effect function, a ref, ` +
-        `a reactive object, or an array of these types.`,
-    )
-  }
-
-  const instance = null
-  const reactiveGetter = (source: object) =>
-    deep === true
-      ? source // traverse will happen in wrapped getter below
-      : // for deep: false, only traverse root-level properties
-        traverse(source, deep === false ? 1 : undefined)
-
-  let getter: () => any
-  let forceTrigger = false
-  let isMultiSource = false
-
-  if (isRef(source)) {
-    getter = () => source.value
-    forceTrigger = isShallow(source)
-  } else if (isReactive(source)) {
-    getter = () => reactiveGetter(source)
-    forceTrigger = true
-  } else if (isArray(source)) {
-    isMultiSource = true
-    forceTrigger = source.some(s => isReactive(s) || isShallow(s))
-    getter = () =>
-      source.map(s => {
-        if (isRef(s)) {
-          return s.value
-        } else if (isReactive(s)) {
-          return reactiveGetter(s)
-        } else if (isFunction(s)) {
-          return callWithErrorHandling(s, instance, ErrorCodes.WATCH_GETTER)
-        } else {
-          __DEV__ && warnInvalidSource(s)
-        }
-      })
-  } else if (isFunction(source)) {
-    if (cb) {
-      // getter with cb
-      getter = () =>
-        callWithErrorHandling(source, instance, ErrorCodes.WATCH_GETTER)
-    } else {
-      // no cb -> simple effect
-      getter = () => {
-        if (cleanup) {
-          cleanup()
-        }
-        return callWithAsyncErrorHandling(
-          source,
-          instance,
-          ErrorCodes.WATCH_CALLBACK,
-          [onCleanup],
-        )
-      }
-    }
-  } else {
-    getter = NOOP
-    __DEV__ && warnInvalidSource(source)
-  }
-
-  if (cb && deep) {
-    const baseGetter = getter
-    getter = () => traverse(baseGetter())
-  }
-
-  let cleanup: (() => void) | undefined
-  let onCleanup: OnCleanup = (fn: () => void) => {
-    cleanup = effect.onStop = () => {
-      callWithErrorHandling(fn, instance, ErrorCodes.WATCH_CLEANUP)
-      cleanup = effect.onStop = undefined
-    }
-  }
-
-  let oldValue: any = isMultiSource
-    ? new Array((source as []).length).fill(INITIAL_WATCHER_VALUE)
-    : INITIAL_WATCHER_VALUE
-  const job: SchedulerJob = () => {
-    if (!effect.active || !effect.dirty) {
-      return
-    }
-    if (cb) {
-      // watch(source, cb)
-      const newValue = effect.run()
-      if (
-        deep ||
-        forceTrigger ||
-        (isMultiSource
-          ? (newValue as any[]).some((v, i) => hasChanged(v, oldValue[i]))
-          : hasChanged(newValue, oldValue))
-      ) {
-        // cleanup before running cb again
-        if (cleanup) {
-          cleanup()
-        }
-        callWithAsyncErrorHandling(cb, instance, ErrorCodes.WATCH_CALLBACK, [
-          newValue,
-          // pass undefined as the old value when it's changed for the first time
-          oldValue === INITIAL_WATCHER_VALUE
-            ? undefined
-            : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE
-              ? []
-              : oldValue,
-          onCleanup,
-        ])
-        oldValue = newValue
-      }
-    } else {
-      // watchEffect
-      effect.run()
-    }
-  }
-
-  // important: mark the job as a watcher callback so that scheduler knows
-  // it is allowed to self-trigger (#1727)
-  job.allowRecurse = !!cb
-
-  let scheduler: EffectScheduler
-  if (flush === 'sync') {
-    scheduler = job as any // the scheduler function gets called directly
-  } else {
-    // default: 'pre'
-    job.pre = true
-    scheduler = () => queueJob(job)
-  }
-
-  const effect = new ReactiveEffect(getter, NOOP, scheduler)
-
-  const scope = getCurrentScope()
-  const unwatch = () => {
-    effect.stop()
-    if (scope) {
-      // @ts-ignore for internal use
-      remove(scope.effects, effect)
-    }
-  }
-
-  if (__DEV__) {
-    effect.onTrack = onTrack
-    effect.onTrigger = onTrigger
-  }
-
-  // initial run
-  if (cb) {
-    if (immediate) {
-      job()
-    } else {
-      oldValue = effect.run()
-    }
-  } else {
-    effect.run()
-  }
-  return unwatch
-}
-
-export function createPathGetter(ctx: any, path: string) {
-  const segments = path.split('.')
-  return () => {
-    let cur = ctx
-    for (let i = 0; i < segments.length && cur; i++) {
-      cur = cur[segments[i]]
-    }
-    return cur
-  }
-}
-
-export function traverse(
-  value: unknown,
-  depth = Infinity,
-  seen?: Set<unknown>,
-) {
-  if (depth <= 0 || !isObject(value) || (value as any)[ReactiveFlags.SKIP]) {
-    return value
-  }
-
-  seen = seen || new Set()
-  if (seen.has(value)) {
-    return value
-  }
-  seen.add(value)
-  depth--
-  if (isRef(value)) {
-    traverse(value.value, depth, seen)
-  } else if (isArray(value)) {
-    for (let i = 0; i < value.length; i++) {
-      traverse(value[i], depth, seen)
-    }
-  } else if (isSet(value) || isMap(value)) {
-    value.forEach((v: any) => {
-      traverse(v, depth, seen)
-    })
-  } else if (isPlainObject(value)) {
-    for (const key in value) {
-      traverse(value[key], depth, seen)
-    }
-    for (const key of Object.getOwnPropertySymbols(value)) {
-      if (Object.prototype.propertyIsEnumerable.call(value, key)) {
-        traverse(value[key as any], depth, seen)
-      }
-    }
-  }
-  return value
-}

package/src/enums.ts

@@ -1,4 +0,0 @@
-export enum LifecycleHooks {
-  ACTIVATED = 'a',
-  DEACTIVATED = 'da',
-}

package/src/errorHandling.ts

@@ -1,120 +0,0 @@
-import { warn } from './warning'
-import { isArray, isFunction, isPromise } from '@vue/shared'
-import { LifecycleHooks } from './enums'
-
-// contexts where user provided function may be executed, in addition to
-// lifecycle hooks.
-export enum ErrorCodes {
-  SETUP_FUNCTION,
-  RENDER_FUNCTION,
-  WATCH_GETTER,
-  WATCH_CALLBACK,
-  WATCH_CLEANUP,
-  NATIVE_EVENT_HANDLER,
-  COMPONENT_EVENT_HANDLER,
-  VNODE_HOOK,
-  DIRECTIVE_HOOK,
-  TRANSITION_HOOK,
-  APP_ERROR_HANDLER,
-  APP_WARN_HANDLER,
-  FUNCTION_REF,
-  ASYNC_COMPONENT_LOADER,
-  SCHEDULER,
-}
-
-export const ErrorTypeStrings: Record<LifecycleHooks | ErrorCodes, string> = {
-  [LifecycleHooks.ACTIVATED]: 'activated hook',
-  [LifecycleHooks.DEACTIVATED]: 'deactivated hook',
-  [ErrorCodes.SETUP_FUNCTION]: 'setup function',
-  [ErrorCodes.RENDER_FUNCTION]: 'render function',
-  [ErrorCodes.WATCH_GETTER]: 'watcher getter',
-  [ErrorCodes.WATCH_CALLBACK]: 'watcher callback',
-  [ErrorCodes.WATCH_CLEANUP]: 'watcher cleanup function',
-  [ErrorCodes.NATIVE_EVENT_HANDLER]: 'native event handler',
-  [ErrorCodes.COMPONENT_EVENT_HANDLER]: 'component event handler',
-  [ErrorCodes.VNODE_HOOK]: 'vnode hook',
-  [ErrorCodes.DIRECTIVE_HOOK]: 'directive hook',
-  [ErrorCodes.TRANSITION_HOOK]: 'transition hook',
-  [ErrorCodes.APP_ERROR_HANDLER]: 'app errorHandler',
-  [ErrorCodes.APP_WARN_HANDLER]: 'app warnHandler',
-  [ErrorCodes.FUNCTION_REF]: 'ref function',
-  [ErrorCodes.ASYNC_COMPONENT_LOADER]: 'async component loader',
-  [ErrorCodes.SCHEDULER]:
-    'scheduler flush. This is likely a Vue internals bug. ' +
-    'Please open an issue at https://github.com/vuejs/core .',
-}
-
-export type ErrorTypes = LifecycleHooks | ErrorCodes
-
-export function callWithErrorHandling(
-  fn: Function,
-  instance: null,
-  type: ErrorTypes,
-  args?: unknown[],
-) {
-  try {
-    return args ? fn(...args) : fn()
-  } catch (err) {
-    handleError(err, instance, type)
-  }
-}
-
-export function callWithAsyncErrorHandling(
-  fn: Function | Function[],
-  instance: null,
-  type: ErrorTypes,
-  args?: unknown[],
-): any {
-  if (isFunction(fn)) {
-    const res = callWithErrorHandling(fn, instance, type, args)
-    if (res && isPromise(res)) {
-      res.catch(err => {
-        handleError(err, instance, type)
-      })
-    }
-    return res
-  }
-
-  if (isArray(fn)) {
-    const values = []
-    for (let i = 0; i < fn.length; i++) {
-      values.push(callWithAsyncErrorHandling(fn[i], instance, type, args))
-    }
-    return values
-  } else if (__DEV__) {
-    warn(
-      `Invalid value type passed to callWithAsyncErrorHandling(): ${typeof fn}`,
-    )
-  }
-}
-
-export function handleError(
-  err: unknown,
-  instance: null,
-  type: ErrorTypes,
-  throwInDev = true,
-) {
-  const contextVNode = null
-  logError(err, type, contextVNode, throwInDev)
-}
-
-function logError(
-  err: unknown,
-  type: ErrorTypes,
-  contextVNode: null,
-  throwInDev = true,
-) {
-  if (__DEV__) {
-    const info = ErrorTypeStrings[type]
-    warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`)
-    // crash in dev by default so it's more noticeable
-    if (throwInDev) {
-      throw err
-    } else {
-      console.error(err)
-    }
-  } else {
-    // recover in prod to reduce the impact on end-user
-    console.error(err)
-  }
-}

package/src/index.ts

@@ -1,5 +0,0 @@
-export { nextTick } from './scheduler'
-export type { WatchEffect, WatchSource, WatchCallback, WatchOptionsBase, WatchOptions, WatchStopHandle } from './apiWatch'
-export { watchEffect, watchSyncEffect, watch } from './apiWatch'
-
-export * from '@vue/reactivity'