"tsdocMessageReporting": {
"default": {
"logLevel": "warning"
+ },
+
+ "tsdoc-undefined-tag": {
+ "logLevel": "none"
}
}
}
/**
* Compiler runtime helper for creating dynamic slots object
- * @internal
+ * @private
*/
export function createSlots(
slots: Record<string, Slot>,
/**
* v-for string
- * @internal
+ * @private
*/
export function renderList(
source: string,
/**
* v-for number
- * @internal
*/
export function renderList(
source: number,
/**
* v-for array
- * @internal
*/
export function renderList<T>(
source: T[],
/**
* v-for iterable
- * @internal
*/
export function renderList<T>(
source: Iterable<T>,
/**
* v-for object
- * @internal
*/
export function renderList<T>(
source: T,
) => VNodeChild
): VNodeChild[]
-// actual implementation
+/**
+ * Actual implementation
+ */
export function renderList(
source: any,
renderItem: (...args: any[]) => VNodeChild
/**
* Compiler runtime helper for rendering <slot/>
- * @internal
+ * @private
*/
export function renderSlot(
slots: Slots,
const COMPONENTS = 'components'
const DIRECTIVES = 'directives'
+/**
+ * @private
+ */
export function resolveComponent(name: string): Component | string | undefined {
return resolveAsset(COMPONENTS, name) || name
}
export const NULL_DYNAMIC_COMPONENT = Symbol()
+/**
+ * @private
+ */
export function resolveDynamicComponent(
component: unknown
): Component | string | typeof NULL_DYNAMIC_COMPONENT {
}
}
+/**
+ * @private
+ */
export function resolveDirective(name: string): Directive | undefined {
return resolveAsset(DIRECTIVES, name)
}
-// overload 1: components
+/**
+ * @private
+ * overload 1: components
+ */
function resolveAsset(
type: typeof COMPONENTS,
name: string,
type: typeof DIRECTIVES,
name: string
): Directive | undefined
-
+// implementation
function resolveAsset(
type: typeof COMPONENTS | typeof DIRECTIVES,
name: string,
const scopeIdStack: string[] = []
/**
- * @internal
+ * @private
*/
export function pushScopeId(id: string) {
scopeIdStack.push((currentScopeId = id))
}
/**
- * @internal
+ * @private
*/
export function popScopeId() {
scopeIdStack.pop()
}
/**
- * @internal
+ * @private
*/
export function withScopeId(id: string): <T extends Function>(fn: T) => T {
return ((fn: Function) =>
/**
* For prefixing keys in v-on="obj" with "on"
- * @internal
+ * @private
*/
export function toHandlers(obj: Record<string, any>): Record<string, any> {
const ret: Record<string, any> = {}
/**
* Wrap a slot function to memoize current rendering instance
- * @internal
+ * @private
*/
export function withCtx(
fn: Slot,
// them in @vue/shared's typings
import { toDisplayString, camelize } from '@vue/shared'
/**
- * @internal
+ * @private
*/
const _toDisplayString = toDisplayString
/**
- * @internal
+ * @private
*/
const _camelize = camelize
export { _toDisplayString as toDisplayString, _camelize as camelize }
* disableTracking is true when creating a v-for fragment block, since a v-for
* fragment always diffs its children.
*
- * @internal
+ * @private
*/
export function openBlock(disableTracking = false) {
blockStack.push((currentBlock = disableTracking ? null : []))
* )
* ```
*
- * @internal
+ * @private
*/
export function setBlockTracking(value: number) {
shouldTrack += value
* A block root keeps track of dynamic nodes within the block in the
* `dynamicChildren` array.
*
- * @internal
+ * @private
*/
export function createBlock(
type: VNodeTypes | ClassComponent,
}
/**
- * @internal
+ * @private
*/
export function createTextVNode(text: string = ' ', flag: number = 0): VNode {
return createVNode(Text, null, text, flag)
}
/**
- * @internal
+ * @private
*/
export function createStaticVNode(
content: string,
}
/**
- * @internal
+ * @private
*/
export function createCommentVNode(
text: string = '',
type ModelDirective<T> = ObjectDirective<T & { _assign: AssignerFn }>
// We are exporting the v-model runtime directly as vnode hooks so that it can
-// be tree-shaken in case v-model is never used. These are used by compilers
-// only and userland code should avoid relying on them.
-/**
- * @internal
- */
+// be tree-shaken in case v-model is never used.
export const vModelText: ModelDirective<
HTMLInputElement | HTMLTextAreaElement
> = {
}
}
-/**
- * @internal
- */
export const vModelCheckbox: ModelDirective<HTMLInputElement> = {
beforeMount(el, binding, vnode) {
setChecked(el, binding, vnode)
}
}
-/**
- * @internal
- */
export const vModelRadio: ModelDirective<HTMLInputElement> = {
beforeMount(el, { value }, vnode) {
el.checked = looseEqual(value, vnode.props!.value)
}
}
-/**
- * @internal
- */
export const vModelSelect: ModelDirective<HTMLSelectElement> = {
// use mounted & updated because <select> relies on its children <option>s.
mounted(el, { value }, vnode) {
return key in el ? el[key] : checked
}
-/**
- * @internal
- */
export const vModelDynamic: ObjectDirective<
HTMLInputElement | HTMLSelectElement | HTMLTextAreaElement
> = {
}
/**
- * @internal
+ * @private
*/
export const withModifiers = (fn: Function, modifiers: string[]) => {
return (event: Event, ...args: unknown[]) => {
}
/**
- * @internal
+ * @private
*/
export const withKeys = (fn: Function, modifiers: string[]) => {
return (event: KeyboardEvent) => {
_vod: string
}
-/**
- * @internal
- */
export const vShow: ObjectDirective<VShowElement> = {
beforeMount(el, { value }, { transition }) {
el._vod = el.style.display === 'none' ? '' : el.style.display
projects / thirdparty / vuejs / core.git / commitdiff
