/**
* normalized value is a tuple of the actual normalized options
* and an array of prop keys that need value casting (booleans and defaults)
- * @internal
*/
export type NormalizedProps = Record<string, NormalizedProp>
-/**
- * @internal
- */
+
export type NormalizedPropsOptions = [NormalizedProps, string[]] | []
export function initProps(
// **IMPORTANT** These APIs are exposed solely for @vue/runtime-vapor and may
// change without notice between versions. User code should never rely on them.
+/**
+ * these types cannot be marked internal because runtime-vapor's type relies on
+ * them, but they should be considered internal
+ * @private
+ */
+export {
+ type ComponentInternalOptions,
+ type GenericComponentInstance,
+ type LifecycleHook,
+} from './component'
+export { type NormalizedPropsOptions } from './componentProps'
+
/**
* @internal
*/
export {
- type NormalizedPropsOptions,
baseNormalizePropsOptions,
resolvePropValue,
validateProps,
/**
* @internal
*/
-export {
- type ComponentInternalOptions,
- type GenericComponentInstance,
- type LifecycleHook,
- expose,
- nextUid,
- validateComponentName,
-} from './component'
+export { expose, nextUid, validateComponentName } from './component'
/**
* @internal
*/
-import { Fragment, insert, normalizeBlock, prepend, remove } from '../src/block'
+import {
+ VaporFragment,
+ insert,
+ normalizeBlock,
+ prepend,
+ remove,
+} from '../src/block'
const node1 = document.createTextNode('node1')
const node2 = document.createTextNode('node2')
node2,
node3,
])
- const frag = new Fragment(node2)
+ const frag = new VaporFragment(node2)
frag.anchor = anchor
expect(normalizeBlock([node1, frag, [node3]])).toEqual([
node1,
test('prepend', () => {
const container = document.createElement('div')
prepend(container, [node1], node2)
- prepend(container, new Fragment(node3))
+ prepend(container, new VaporFragment(node3))
expect(Array.from(container.childNodes)).toEqual([node3, node1, node2])
})
test('remove', () => {
const container = document.createElement('div')
container.append(node1, node2, node3)
- const frag = new Fragment(node3)
+ const frag = new VaporFragment(node3)
remove([node1], container)
remove(frag, container)
expect(Array.from(container.childNodes)).toEqual([node2])
import { resolveDynamicComponent } from '@vue/runtime-dom'
-import { DynamicFragment, type Fragment } from './block'
+import { DynamicFragment, type VaporFragment } from './block'
import { createComponentWithFallback } from './component'
import { renderEffect } from './renderEffect'
import type { RawProps } from './componentProps'
rawProps?: RawProps | null,
rawSlots?: RawSlots | null,
isSingleRoot?: boolean,
-): Fragment {
+): VaporFragment {
const frag = __DEV__
? new DynamicFragment('dynamic-component')
: new DynamicFragment()
} from '@vue/reactivity'
import { getSequence, isArray, isObject, isString } from '@vue/shared'
import { createComment, createTextNode } from './dom/node'
-import { type Block, Fragment, insert, remove as removeBlock } from './block'
+import {
+ type Block,
+ VaporFragment,
+ insert,
+ remove as removeBlock,
+} from './block'
import { warn } from '@vue/runtime-dom'
import { currentInstance, isVaporComponent } from './component'
import type { DynamicSlot } from './componentSlots'
import { renderEffect } from './renderEffect'
-class ForBlock extends Fragment {
+class ForBlock extends VaporFragment {
scope: EffectScope | undefined
key: any
isComponent = false,
once?: boolean,
// hydrationNode?: Node,
-): Fragment => {
+): VaporFragment => {
let isMounted = false
let oldBlocks: ForBlock[] = []
let newBlocks: ForBlock[]
let parent: ParentNode | undefined | null
const parentAnchor = __DEV__ ? createComment('for') : createTextNode()
- const ref = new Fragment(oldBlocks)
+ const ref = new VaporFragment(oldBlocks)
const instance = currentInstance!
if (__DEV__ && !instance) {
export type Block =
| Node
- | Fragment
+ | VaporFragment
| DynamicFragment
| VaporComponentInstance
| Block[]
export type BlockFn = (...args: any[]) => Block
-export class Fragment {
+export class VaporFragment {
nodes: Block
anchor?: Node
}
}
-export class DynamicFragment extends Fragment {
+export class DynamicFragment extends VaporFragment {
anchor: Node
scope: EffectScope | undefined
current?: BlockFn
}
}
-export function isFragment(val: NonNullable<unknown>): val is Fragment {
- return val instanceof Fragment
+export function isFragment(val: NonNullable<unknown>): val is VaporFragment {
+ return val instanceof VaporFragment
}
export function isBlock(val: NonNullable<unknown>): val is Block {
import {
type DynamicSlotSource,
type RawSlots,
- type Slot,
type StaticSlots,
+ type VaporSlot,
dynamicSlotsProxyHandlers,
getSlot,
} from './componentSlots'
props?: any,
emit?: EmitFn,
attrs?: any,
- slots?: Record<string, Slot>,
+ slots?: Record<string, VaporSlot>,
): Block
name?: string
$?: DynamicPropsSource[]
}
-type LooseRawSlots = Record<string, Slot | DynamicSlotSource[]> & {
+type LooseRawSlots = Record<string, VaporSlot | DynamicSlotSource[]> & {
$?: DynamicSlotSource[]
}
import type { LooseRawProps, VaporComponentInstance } from './component'
import { renderEffect } from './renderEffect'
-export type RawSlots = Record<string, Slot> & {
+export type RawSlots = Record<string, VaporSlot> & {
$?: DynamicSlotSource[]
}
-export type StaticSlots = Record<string, Slot>
+export type StaticSlots = Record<string, VaporSlot>
-export type Slot = BlockFn
-export type DynamicSlot = { name: string; fn: Slot }
+export type VaporSlot = BlockFn
+export type DynamicSlot = { name: string; fn: VaporSlot }
export type DynamicSlotFn = () => DynamicSlot | DynamicSlot[]
export type DynamicSlotSource = StaticSlots | DynamicSlotFn
export function getSlot(
target: RawSlots,
key: string,
-): (Slot & { _bound?: Slot }) | undefined {
+): (VaporSlot & { _bound?: VaporSlot }) | undefined {
if (key === '$') return
const dynamicSources = target.$
if (dynamicSources) {
export function createSlot(
name: string | (() => string),
rawProps?: LooseRawProps | null,
- fallback?: Slot,
+ fallback?: VaporSlot,
): Block {
const instance = currentInstance as VaporComponentInstance
const rawSlots = instance.rawSlots
// public APIs
export { createVaporApp } from './apiCreateApp'
export { defineVaporComponent } from './apiDefineComponent'
+export { vaporInteropPlugin } from './vdomInterop'
// compiler-use only
export { insert, prepend, remove } from './block'
-export {
- createComponent,
- createComponentWithFallback,
- mountComponent,
- unmountComponent,
- type VaporComponentInstance,
-} from './component'
+export { createComponent, createComponentWithFallback } from './component'
export { renderEffect } from './renderEffect'
export { createSlot } from './componentSlots'
export { template, children, next } from './dom/template'
applySelectModel,
applyDynamicModel,
} from './directives/vModel'
-export { vaporInteropPlugin } from './vdomInterop'
--- /dev/null
+// for type generation only
+export * from './index'
+export * from '@vue/runtime-vapor'
/** @returns {import('rollup').RollupOptions} */
pkg => {
return {
- input: `./temp/packages/${pkg}/src/index.d.ts`,
+ input: `./temp/packages/${pkg}/src/index${pkg === 'vue' ? '-with-vapor' : ''}.d.ts`,
output: {
file: `packages/${pkg}/dist/${pkg}.d.ts`,
format: 'es',