feat(reactivity-transform/types): restructure macro types + export types for all shorthand methods

packages/reactivity/src/index.ts

@@ -14,7 +14,8 @@ export {
   UnwrapRef,
   ShallowRef,
   ShallowUnwrapRef,
-  RefUnwrapBailTypes
+  RefUnwrapBailTypes,
+  CustomRefFactory
 } from './ref'
 export {
   reactive,

packages/reactivity/src/ref.ts

@@ -151,7 +151,7 @@ export function proxyRefs<T extends object>(
     : new Proxy(objectWithRefs, shallowUnwrapHandlers)
 }
 
-type CustomRefFactory<T> = (
+export type CustomRefFactory<T> = (
   track: () => void,
   trigger: () => void
 ) => {

packages/runtime-core/src/index.ts

@@ -151,18 +151,28 @@ export {
   Ref,
   ToRef,
   ToRefs,
-  ReactiveEffectOptions,
+  UnwrapRef,
-  DebuggerEvent,
+  ShallowRef,
-  DebuggerOptions,
+  ShallowUnwrapRef,
-  TrackOpTypes,
+  RefUnwrapBailTypes,
-  TriggerOpTypes,
+  CustomRefFactory,
+  ReactiveFlags,
+  DeepReadonly,
+  ShallowReactive,
+  UnwrapNestedRefs,
   ComputedRef,
   WritableComputedRef,
-  UnwrapRef,
-  ShallowUnwrapRef,
   WritableComputedOptions,
-  DeepReadonly,
+  ComputedGetter,
-  ShallowReactive
+  ComputedSetter,
+  ReactiveEffectRunner,
+  ReactiveEffectOptions,
+  EffectScheduler,
+  DebuggerOptions,
+  DebuggerEvent,
+  DebuggerEventExtraInfo,
+  TrackOpTypes,
+  TriggerOpTypes
 } from '@vue/reactivity'
 export {
   WatchEffect,

packages/vue/macros-global.d.ts

@@ -0,0 +1,19 @@
+import {
+  $ as _$,
+  $$ as _$$,
+  $ref as _$ref,
+  $shallowRef as _$shallowRef,
+  $computed as _$computed,
+  $customRef as _$customRef,
+  $toRef as _$toRef
+} from './macros'
+
+declare global {
+  const $: typeof _$
+  const $$: typeof _$$
+  const $ref: typeof _$ref
+  const $shallowRef: typeof _$shallowRef
+  const $computed: typeof _$computed
+  const $customRef: typeof _$customRef
+  const $toRef: typeof _$toRef
+}

packages/vue/macros.d.ts

@@ -0,0 +1,106 @@
+import {
+  Ref,
+  UnwrapRef,
+  ComputedRef,
+  WritableComputedOptions,
+  DebuggerOptions,
+  WritableComputedRef,
+  CustomRefFactory
+} from '@vue/runtime-dom'
+
+export declare const RefType: unique symbol
+
+export declare const enum RefTypes {
+  Ref = 1,
+  ComputedRef = 2,
+  WritableComputedRef = 3
+}
+
+type RefValue<T> = T extends null | undefined
+  ? T
+  : T & { [RefType]?: RefTypes.Ref }
+
+type ComputedRefValue<T> = T extends null | undefined
+  ? T
+  : T & { [RefType]?: RefTypes.ComputedRef }
+
+type WritableComputedRefValue<T> = T extends null | undefined
+  ? T
+  : T & { [RefType]?: RefTypes.WritableComputedRef }
+
+type NormalObject<T extends object> = T & { [RefType]?: never }
+
+/**
+ * Vue ref transform macro for binding refs as reactive variables.
+ */
+export declare function $<T>(arg: ComputedRef<T>): ComputedRefValue<T>
+export declare function $<T>(
+  arg: WritableComputedRef<T>
+): WritableComputedRefValue<T>
+export declare function $<T>(arg: Ref<T>): RefValue<T>
+export declare function $<T extends object>(arg?: T): DestructureRefs<T>
+
+type DestructureRefs<T extends object> = {
+  [K in keyof T]: T[K] extends ComputedRef<infer V>
+    ? ComputedRefValue<V>
+    : T[K] extends WritableComputedRef<infer V>
+    ? WritableComputedRefValue<V>
+    : T[K] extends Ref<infer V>
+    ? RefValue<V>
+    : T[K]
+}
+
+/**
+ * Vue ref transform macro for accessing underlying refs of reactive varaibles.
+ */
+export declare function $$<T extends object>(arg: NormalObject<T>): ToRawRefs<T>
+export declare function $$<T>(value: RefValue<T>): Ref<T>
+export declare function $$<T>(value: ComputedRefValue<T>): ComputedRef<T>
+export declare function $$<T>(
+  value: WritableComputedRefValue<T>
+): WritableComputedRef<T>
+
+type ToRawRefs<T extends object> = {
+  [K in keyof T]: T[K] extends RefValue<infer V>
+    ? Ref<V>
+    : T[K] extends ComputedRefValue<infer V>
+    ? ComputedRef<V>
+    : T[K] extends WritableComputedRefValue<infer V>
+    ? WritableComputedRef<V>
+    : T[K] extends object
+    ? T[K] extends
+        | Function
+        | Map<any, any>
+        | Set<any>
+        | WeakMap<any, any>
+        | WeakSet<any>
+      ? T[K]
+      : ToRawRefs<T[K]>
+    : T[K]
+}
+
+export declare function $ref<T>(arg?: T | Ref<T>): RefValue<UnwrapRef<T>>
+
+export declare function $shallowRef<T>(arg?: T): RefValue<T>
+
+export declare function $toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K
+): RefValue<T[K]>
+
+export declare function $toRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K,
+  defaultValue: T[K]
+): RefValue<Exclude<T[K], undefined>>
+
+export declare function $customRef<T>(factory: CustomRefFactory<T>): RefValue<T>
+
+export declare function $computed<T>(
+  getter: () => T,
+  debuggerOptions?: DebuggerOptions
+): ComputedRefValue<T>
+export declare function $computed<T>(
+  options: WritableComputedOptions<T>,
+  debuggerOptions?: DebuggerOptions
+): WritableComputedRefValue<T>

packages/vue/package.json

@@ -34,6 +34,8 @@
     },
     "./dist/*": "./dist/*",
     "./package.json": "./package.json",
+    "./macros": "./macros.d.ts",
+    "./macros-global": "./macros-global.d.ts",
     "./ref-macros": "./ref-macros.d.ts"
   },
   "buildOptions": {

packages/vue/ref-macros.d.ts

@@ -1,98 +1,2 @@
-import {
+// TODO deprecated file - to be removed when out of experimental
-  Ref,
+import './macros-global'
-  UnwrapRef,
-  ComputedRef,
-  WritableComputedOptions,
-  DebuggerOptions,
-  WritableComputedRef
-} from '@vue/runtime-dom'
-
-declare const RefType: unique symbol
-
-declare const enum RefTypes {
-  Ref = 1,
-  ComputedRef = 2,
-  WritableComputedRef = 3
-}
-
-type RefValue<T> = T extends null | undefined
-  ? T
-  : T & { [RefType]?: RefTypes.Ref }
-
-type ComputedRefValue<T> = T extends null | undefined
-  ? T
-  : T & { [RefType]?: RefTypes.ComputedRef }
-
-type WritableComputedRefValue<T> = T extends null | undefined
-  ? T
-  : T & { [RefType]?: RefTypes.WritableComputedRef }
-
-type NormalObject<T extends object> = T & { [RefType]?: never }
-
-/**
- * Vue ref transform macro for binding refs as reactive variables.
- */
-declare function _$<T>(arg: ComputedRef<T>): ComputedRefValue<T>
-declare function _$<T>(arg: WritableComputedRef<T>): WritableComputedRefValue<T>
-declare function _$<T>(arg: Ref<T>): RefValue<T>
-declare function _$<T extends object>(arg?: T): DestructureRefs<T>
-
-type DestructureRefs<T extends object> = {
-  [K in keyof T]: T[K] extends ComputedRef<infer V>
-    ? ComputedRefValue<V>
-    : T[K] extends WritableComputedRef<infer V>
-    ? WritableComputedRefValue<V>
-    : T[K] extends Ref<infer V>
-    ? RefValue<V>
-    : T[K]
-}
-
-/**
- * Vue ref transform macro for accessing underlying refs of reactive varaibles.
- */
-declare function _$$<T extends object>(arg: NormalObject<T>): ToRawRefs<T>
-declare function _$$<T>(value: RefValue<T>): Ref<T>
-declare function _$$<T>(value: ComputedRefValue<T>): ComputedRef<T>
-declare function _$$<T>(
-  value: WritableComputedRefValue<T>
-): WritableComputedRef<T>
-
-type ToRawRefs<T extends object> = {
-  [K in keyof T]: T[K] extends RefValue<infer V>
-    ? Ref<V>
-    : T[K] extends ComputedRefValue<infer V>
-    ? ComputedRef<V>
-    : T[K] extends WritableComputedRefValue<infer V>
-    ? WritableComputedRef<V>
-    : T[K] extends object
-    ? T[K] extends
-        | Function
-        | Map<any, any>
-        | Set<any>
-        | WeakMap<any, any>
-        | WeakSet<any>
-      ? T[K]
-      : ToRawRefs<T[K]>
-    : T[K]
-}
-
-declare function _$ref<T>(arg?: T | Ref<T>): RefValue<UnwrapRef<T>>
-
-declare function _$shallowRef<T>(arg?: T): RefValue<T>
-
-declare function _$computed<T>(
-  getter: () => T,
-  debuggerOptions?: DebuggerOptions
-): ComputedRefValue<T>
-declare function _$computed<T>(
-  options: WritableComputedOptions<T>,
-  debuggerOptions?: DebuggerOptions
-): WritableComputedRefValue<T>
-
-declare global {
-  const $: typeof _$
-  const $$: typeof _$$
-  const $ref: typeof _$ref
-  const $shallowRef: typeof _$shallowRef
-  const $computed: typeof _$computed
-}