Component,
render,
nodeOps,
- ComponentInstance,
observable,
nextTick
} from '@vue/renderer-test'
}
const root = nodeOps.createElement('div')
- const parent = render(h(Parent), root) as ComponentInstance
+ const parent = render(h(Parent), root) as Component
expect(child.$parent).toBe(parent)
expect(child.$root).toBe(parent)
}
const root = nodeOps.createElement('div')
- const parent = render(h(Parent), root) as ComponentInstance
+ const parent = render(h(Parent), root) as Component
expect(child.$parent).toBe(parent)
expect(child.$root).toBe(parent)
-import { EMPTY_OBJ, NOOP } from './utils'
+import { EMPTY_OBJ, NOOP, isArray } from '@vue/shared'
import { VNode, Slots, RenderNode, MountedVNode } from './vdom'
import {
Data,
$emit(name: string, ...payload: any[]): this
}
-interface APIMethods<P, D> {
- data?(): Partial<D>
+export interface APIMethods<P = {}, D = {}> {
+ data(): Partial<D>
render(props: Readonly<P>, slots: Slots, attrs: Data, parentVNode: VNode): any
}
-interface LifecycleMethods {
- beforeCreate?(): void
- created?(): void
- beforeMount?(): void
- mounted?(): void
- beforeUpdate?(vnode: VNode): void
- updated?(vnode: VNode): void
- beforeUnmount?(): void
- unmounted?(): void
- errorCaptured?(): (
+export interface LifecycleMethods {
+ beforeCreate(): void
+ created(): void
+ beforeMount(): void
+ mounted(): void
+ beforeUpdate(vnode: VNode): void
+ updated(vnode: VNode): void
+ beforeUnmount(): void
+ unmounted(): void
+ errorCaptured(): (
err: Error,
type: ErrorTypes,
instance: ComponentInstance | null,
vnode: VNode
) => boolean | void
- activated?(): void
- deactivated?(): void
- renderTracked?(e: DebuggerEvent): void
- renderTriggered?(e: DebuggerEvent): void
+ activated(): void
+ deactivated(): void
+ renderTracked(e: DebuggerEvent): void
+ renderTriggered(e: DebuggerEvent): void
}
export interface ComponentClass extends ComponentClassOptions {
// It extends InternalComponent with mounted instance properties.
export interface ComponentInstance<P = {}, D = {}>
extends InternalComponent,
- APIMethods<P, D>,
- LifecycleMethods {
+ Partial<APIMethods<P, D>>,
+ Partial<LifecycleMethods> {
constructor: ComponentClass
+ render: APIMethods<P, D>['render']
$vnode: MountedVNode
$data: D
// eventEmitter interface
$on(event: string, fn: Function): this {
- if (Array.isArray(event)) {
+ if (isArray(event)) {
for (let i = 0; i < event.length; i++) {
this.$on(event[i], fn)
}
if (this._events) {
if (!event && !fn) {
this._events = null
- } else if (Array.isArray(event)) {
+ } else if (isArray(event)) {
for (let i = 0; i < event.length; i++) {
this.$off(event[i], fn)
}
function invokeListeners(value: Function | Function[], payload: any[]) {
// TODO handle error
- if (Array.isArray(value)) {
+ if (isArray(value)) {
for (let i = 0; i < value.length; i++) {
value[i](...payload)
}
-import { NOOP } from './utils'
+import { NOOP, isFunction } from '@vue/shared'
import { computed, stop, ComputedGetter } from '@vue/observer'
import { ComponentInstance } from './component'
import { ComponentComputedOptions } from './componentOptions'
const proxy = instance.$proxy
for (const key in computedOptions) {
const option = computedOptions[key]
- const getter = typeof option === 'function' ? option : option.get || NOOP
+ const getter = isFunction(option) ? option : option.get || NOOP
handles[key] = computed(getter, proxy)
}
}
-import { ComponentInstance } from './component'
+import {
+ ComponentInstance,
+ ComponentClass,
+ APIMethods,
+ LifecycleMethods
+} from './component'
import { Slots } from './vdom'
+import { isArray, isObject, isFunction } from '@vue/shared'
+import { normalizePropsOptions } from './componentProps'
export type Data = Record<string, any>
deep?: boolean
immediate?: boolean
}
+
+type ReservedKeys = { [K in keyof (APIMethods & LifecycleMethods)]: 1 }
+
+export const reservedMethods: ReservedKeys = {
+ data: 1,
+ render: 1,
+ beforeCreate: 1,
+ created: 1,
+ beforeMount: 1,
+ mounted: 1,
+ beforeUpdate: 1,
+ updated: 1,
+ beforeUnmount: 1,
+ unmounted: 1,
+ errorCaptured: 1,
+ activated: 1,
+ deactivated: 1,
+ renderTracked: 1,
+ renderTriggered: 1
+}
+
+// This is called in the base component constructor and the return value is
+// set on the instance as $options.
+export function resolveComponentOptionsFromClass(
+ Component: ComponentClass
+): ComponentOptions {
+ if (Component.options) {
+ return Component.options
+ }
+ const staticDescriptors = Object.getOwnPropertyDescriptors(Component)
+ const options = {} as any
+ for (const key in staticDescriptors) {
+ const { enumerable, get, value } = staticDescriptors[key]
+ if (enumerable || get) {
+ options[key] = get ? get() : value
+ }
+ }
+ const instanceDescriptors = Object.getOwnPropertyDescriptors(
+ Component.prototype
+ )
+ for (const key in instanceDescriptors) {
+ const { get, value } = instanceDescriptors[key]
+ if (get) {
+ // computed properties
+ ;(options.computed || (options.computed = {}))[key] = get
+ // there's no need to do anything for the setter
+ // as it's already defined on the prototype
+ } else if (isFunction(value)) {
+ if (key in reservedMethods) {
+ options[key] = value
+ } else {
+ ;(options.methods || (options.methods = {}))[key] = value
+ }
+ }
+ }
+ options.props = normalizePropsOptions(options.props)
+ Component.options = options
+ return options
+}
+
+export function mergeComponentOptions(to: any, from: any): ComponentOptions {
+ const res: any = Object.assign({}, to)
+ if (from.mixins) {
+ from.mixins.forEach((mixin: any) => {
+ from = mergeComponentOptions(from, mixin)
+ })
+ }
+ for (const key in from) {
+ const value = from[key]
+ const existing = res[key]
+ if (isFunction(value) && isFunction(existing)) {
+ if (key === 'data') {
+ // for data we need to merge the returned value
+ res[key] = function() {
+ return Object.assign(existing(), value())
+ }
+ } else if (/^render|^errorCaptured/.test(key)) {
+ // render, renderTracked, renderTriggered & errorCaptured
+ // are never merged
+ res[key] = value
+ } else {
+ // merge lifecycle hooks
+ res[key] = function(...args: any[]) {
+ existing.call(this, ...args)
+ value.call(this, ...args)
+ }
+ }
+ } else if (isArray(value) && isArray(existing)) {
+ res[key] = existing.concat(value)
+ } else if (isObject(value) && isObject(existing)) {
+ res[key] = Object.assign({}, existing, value)
+ } else {
+ res[key] = value
+ }
+ }
+ return res
+}
import { ComponentInstance } from './component'
import {
Data,
- ComponentPropsOptions,
PropOptions,
Prop,
- PropType
+ PropType,
+ ComponentPropsOptions
} from './componentOptions'
-import { EMPTY_OBJ, camelize, hyphenate, capitalize } from './utils'
+import {
+ EMPTY_OBJ,
+ camelize,
+ hyphenate,
+ capitalize,
+ isString,
+ isFunction,
+ isArray,
+ isObject
+} from '@vue/shared'
import { warn } from './warning'
const EMPTY_PROPS = { props: EMPTY_OBJ }
+const enum BooleanFlags {
+ shouldCast = '1',
+ shouldCastTrue = '2'
+}
+
+type NormalizedProp = PropOptions & {
+ [BooleanFlags.shouldCast]?: boolean
+ [BooleanFlags.shouldCastTrue]?: boolean
+}
+
+type NormalizedPropsOptions = Record<string, NormalizedProp>
+
export function initializeProps(
instance: ComponentInstance,
- options: ComponentPropsOptions | undefined,
+ options: NormalizedPropsOptions | undefined,
data: Data | null
) {
const { props, attrs } = resolveProps(data, options)
// - else: everything goes in `props`.
export function resolveProps(
rawData: any,
- rawOptions: ComponentPropsOptions | void
+ _options: NormalizedPropsOptions | void
): { props: Data; attrs?: Data } {
- const hasDeclaredProps = rawOptions !== void 0
+ const hasDeclaredProps = _options !== void 0
+ const options = _options as NormalizedPropsOptions
if (!rawData && !hasDeclaredProps) {
return EMPTY_PROPS
}
- const options = normalizePropsOptions(rawOptions) as NormalizedPropsOptions
const props: any = {}
let attrs: any = void 0
if (rawData != null) {
// default values
if (hasDefault && currentValue === void 0) {
const defaultValue = opt.default
- props[key] =
- typeof defaultValue === 'function' ? defaultValue() : defaultValue
+ props[key] = isFunction(defaultValue) ? defaultValue() : defaultValue
}
// boolean casting
if (opt[BooleanFlags.shouldCast]) {
}
}
-const enum BooleanFlags {
- shouldCast = '1',
- shouldCastTrue = '2'
-}
-
-type NormalizedProp = PropOptions & {
- [BooleanFlags.shouldCast]?: boolean
- [BooleanFlags.shouldCastTrue]?: boolean
-}
-
-type NormalizedPropsOptions = Record<string, NormalizedProp>
-
-const normalizationCache = new WeakMap<
- ComponentPropsOptions,
- NormalizedPropsOptions
->()
-
-function normalizePropsOptions(
+export function normalizePropsOptions(
raw: ComponentPropsOptions | void
-): NormalizedPropsOptions {
+): NormalizedPropsOptions | void {
if (!raw) {
- return EMPTY_OBJ
- }
- const hit = normalizationCache.get(raw)
- if (hit) {
- return hit
+ return
}
const normalized: NormalizedPropsOptions = {}
- if (Array.isArray(raw)) {
+ if (isArray(raw)) {
for (let i = 0; i < raw.length; i++) {
- if (__DEV__ && typeof raw !== 'string') {
- warn(`props must be strings when using array syntax.`)
+ if (__DEV__ && !isString(raw[i])) {
+ warn(`props must be strings when using array syntax.`, raw[i])
}
normalized[camelize(raw[i])] = EMPTY_OBJ
}
} else {
- if (__DEV__ && typeof raw !== 'object') {
+ if (__DEV__ && !isObject(raw)) {
warn(`invalid props options`, raw)
}
for (const key in raw) {
const opt = raw[key]
const prop = (normalized[camelize(key)] =
- Array.isArray(opt) || typeof opt === 'function'
- ? { type: opt }
- : opt) as NormalizedProp
+ isArray(opt) || isFunction(opt) ? { type: opt } : opt) as NormalizedProp
const booleanIndex = getTypeIndex(Boolean, prop.type)
const stringIndex = getTypeIndex(String, prop.type)
prop[BooleanFlags.shouldCast] = booleanIndex > -1
prop[BooleanFlags.shouldCastTrue] = booleanIndex < stringIndex
}
}
- normalizationCache.set(raw, normalized)
return normalized
}
type: Prop<any>,
expectedTypes: PropType<any> | void | null | true
): number {
- if (Array.isArray(expectedTypes)) {
+ if (isArray(expectedTypes)) {
for (let i = 0, len = expectedTypes.length; i < len; i++) {
if (isSameType(expectedTypes[i], type)) {
return i
}
}
- } else if (expectedTypes != null && typeof expectedTypes === 'object') {
+ } else if (isObject(expectedTypes)) {
return isSameType(expectedTypes, type) ? 0 : -1
}
return -1
// type check
if (type != null && type !== true) {
let isValid = false
- const types = Array.isArray(type) ? type : [type]
+ const types = isArray(type) ? type : [type]
const expectedTypes = []
// value is valid as long as one of the specified types match
for (let i = 0; i < types.length && !isValid; i++) {
} else if (expectedType === 'Object') {
valid = toRawType(value) === 'Object'
} else if (expectedType === 'Array') {
- valid = Array.isArray(value)
+ valid = isArray(value)
} else {
valid = value instanceof type
}
import { ComponentInstance } from './component'
+import { isString, isFunction } from '@vue/shared'
const bindCache = new WeakMap()
// TODO warn non-present property
}
const value = Reflect.get(target, key, receiver)
- if (typeof value === 'function') {
+ if (isFunction(value)) {
// auto bind
return getBoundMethod(value, target, receiver)
} else {
receiver: any
): boolean {
if (__DEV__) {
- if (typeof key === 'string' && key[0] === '$') {
+ if (isString(key) && key[0] === '$') {
// TODO warn setting immutable properties
return false
}
-// import { EMPTY_OBJ } from './utils'
import { ComponentInstance } from './component'
import { observable } from '@vue/observer'
import { VNodeFlags } from './flags'
-import { EMPTY_OBJ } from './utils'
+import { EMPTY_OBJ, isArray, isFunction, isObject } from '@vue/shared'
import { h } from './h'
import { VNode, MountedVNode, createFragment } from './vdom'
import {
import { initializeProps, resolveProps } from './componentProps'
import { initializeComputed, teardownComputed } from './componentComputed'
import { initializeWatch, teardownWatch } from './componentWatch'
-import { ComponentOptions } from './componentOptions'
+import {
+ ComponentOptions,
+ resolveComponentOptionsFromClass
+} from './componentOptions'
import { createRenderProxy } from './componentProxy'
import { handleError, ErrorTypes } from './errorHandling'
import { warn } from './warning'
)
}
- instance.$options = resolveComponentOptions(instance.constructor)
+ instance.$options = resolveComponentOptionsFromClass(instance.constructor)
instance.$parentVNode = currentVNode as MountedVNode
// renderProxy
): VNode {
if (vnode == null) {
vnode = createTextVNode('')
- } else if (typeof vnode !== 'object') {
+ } else if (!isObject(vnode)) {
vnode = createTextVNode(vnode + '')
- } else if (Array.isArray(vnode)) {
+ } else if (isArray(vnode)) {
if (vnode.length === 1) {
vnode = normalizeComponentRoot(vnode[0], componentVNode)
} else {
(flags & VNodeFlags.COMPONENT || flags & VNodeFlags.ELEMENT)
) {
if (el) {
- vnode = cloneVNode(vnode)
+ vnode = cloneVNode(vnode as VNode)
}
if (flags & VNodeFlags.COMPONENT) {
vnode.parentVNode = componentVNode
}
} else if (el) {
- vnode = cloneVNode(vnode)
+ vnode = cloneVNode(vnode as VNode)
}
}
return vnode
// name -> displayName
if (key === 'name') {
options.displayName = options.name
- } else if (typeof value === 'function') {
+ } else if (isFunction(value)) {
// lifecycle hook / data / render
if (__COMPAT__) {
if (key === 'render') {
} else if (key === 'computed') {
for (const computedKey in value) {
const computed = value[computedKey]
- const isGet = typeof computed === 'function'
+ const isGet = isFunction(computed)
Object.defineProperty(proto, computedKey, {
configurable: true,
get: isGet ? computed : computed.get,
}
return AnonymousComponent as ComponentClass
}
-
-// This is called in the base component constructor and the return value is
-// set on the instance as $options.
-export function resolveComponentOptions(
- Component: ComponentClass
-): ComponentOptions {
- if (Component.options) {
- return Component.options
- }
- const staticDescriptors = Object.getOwnPropertyDescriptors(Component)
- const options = {} as any
- for (const key in staticDescriptors) {
- const { enumerable, get, value } = staticDescriptors[key]
- if (enumerable || get) {
- options[key] = get ? get() : value
- }
- }
- const instanceDescriptors = Object.getOwnPropertyDescriptors(
- Component.prototype
- )
- for (const key in instanceDescriptors) {
- const { get, value } = instanceDescriptors[key]
- if (get) {
- // computed properties
- ;(options.computed || (options.computed = {}))[key] = get
- // there's no need to do anything for the setter
- // as it's already defined on the prototype
- } else if (typeof value === 'function') {
- ;(options.methods || (options.methods = {}))[key] = value
- }
- }
- Component.options = options
- return options
-}
-import { EMPTY_OBJ, NOOP } from './utils'
+import {
+ EMPTY_OBJ,
+ NOOP,
+ isFunction,
+ isArray,
+ isString,
+ isObject
+} from '@vue/shared'
import { ComponentInstance } from './component'
import { ComponentWatchOptions, WatchOptions } from './componentOptions'
import { autorun, stop } from '@vue/observer'
if (options !== void 0) {
for (const key in options) {
const opt = options[key]
- if (Array.isArray(opt)) {
+ if (isArray(opt)) {
opt.forEach(o => setupWatcher(instance, key, o))
- } else if (typeof opt === 'function') {
+ } else if (isFunction(opt)) {
setupWatcher(instance, key, opt)
- } else if (typeof opt === 'string') {
+ } else if (isString(opt)) {
setupWatcher(instance, key, (instance as any)[opt])
} else if (opt.handler) {
setupWatcher(instance, key, opt.handler, opt)
const handles = instance._watchHandles || (instance._watchHandles = new Set())
const proxy = instance.$proxy
- const rawGetter =
- typeof keyOrFn === 'string'
- ? parseDotPath(keyOrFn, proxy)
- : () => keyOrFn.call(proxy)
+ const rawGetter = isString(keyOrFn)
+ ? parseDotPath(keyOrFn, proxy)
+ : () => keyOrFn.call(proxy)
if (__DEV__ && rawGetter === NOOP) {
warn(
}
function traverse(value: any, seen: Set<any> = new Set()) {
- if (value === null || typeof value !== 'object' || seen.has(value)) {
+ if (!isObject(value) || seen.has(value)) {
return
}
seen.add(value)
- if (Array.isArray(value)) {
+ if (isArray(value)) {
for (let i = 0; i < value.length; i++) {
traverse(value[i], seen)
}
import { autorun, stop } from '@vue/observer'
import { queueJob } from '@vue/scheduler'
import { VNodeFlags, ChildrenFlags } from './flags'
-import { EMPTY_OBJ, reservedPropRE, lis } from './utils'
+import { EMPTY_OBJ, reservedPropRE, isString } from '@vue/shared'
import {
VNode,
MountedVNode,
contextVNode: MountedVNode | null
) {
const { tag, children, childFlags, ref } = vnode
- const target = typeof tag === 'string' ? platformQuerySelector(tag) : tag
+ const target = isString(tag) ? platformQuerySelector(tag) : tag
if (__DEV__ && !target) {
// TODO warn poartal target not found
return { render }
}
+
+// https://en.wikipedia.org/wiki/Longest_increasing_subsequence
+export function lis(arr: number[]): number[] {
+ const p = arr.slice()
+ const result = [0]
+ let i
+ let j
+ let u
+ let v
+ let c
+ const len = arr.length
+ for (i = 0; i < len; i++) {
+ const arrI = arr[i]
+ if (arrI !== 0) {
+ j = result[result.length - 1]
+ if (arr[j] < arrI) {
+ p[i] = j
+ result.push(i)
+ continue
+ }
+ u = 0
+ v = result.length - 1
+ while (u < v) {
+ c = ((u + v) / 2) | 0
+ if (arr[result[c]] < arrI) {
+ u = c + 1
+ } else {
+ v = c
+ }
+ }
+ if (arrI < arr[result[u]]) {
+ if (u > 0) {
+ p[i] = result[u - 1]
+ }
+ result[u] = i
+ }
+ }
+ }
+ u = result.length
+ v = result[u - 1]
+ while (u-- > 0) {
+ result[u] = v
+ v = p[v]
+ }
+ return result
+}
} from './vdom'
import { isObservable } from '@vue/observer'
import { warn } from './warning'
+import { isString, isArray, isFunction, isObject } from '@vue/shared'
export const Fragment = Symbol()
export const Portal = Symbol()
}
export const h = ((tag: ElementType, data?: any, children?: any): VNode => {
- if (
- Array.isArray(data) ||
- (data != null && (typeof data !== 'object' || data._isVNode))
- ) {
+ if (isArray(data) || !isObject(data) || data._isVNode) {
children = data
data = null
}
}
}
- if (typeof tag === 'string') {
+ if (isString(tag)) {
// element
return createElementVNode(
tag,
ref
)
} else {
- if (
- __DEV__ &&
- (!tag || (typeof tag !== 'function' && typeof tag !== 'object'))
- ) {
+ if (__DEV__ && !isFunction(tag) && !isObject(tag)) {
warn('Invalid component passed to h(): ', tag)
}
// component
// Scheduler API
export { nextTick } from '@vue/scheduler'
-// Internal API
-export {
- createComponentInstance,
- createComponentClassFromOptions
-} from './componentUtils'
-
// Optional APIs
// these are imported on-demand and can be tree-shaken
export { applyDirectives } from './optional/directive'
export { Provide, Inject } from './optional/context'
export { createAsyncComponent } from './optional/asyncComponent'
export { KeepAlive } from './optional/keepAlive'
+export { mixins } from './optional/mixin'
// flags & types
export { ComponentType, ComponentClass, FunctionalComponent } from './component'
-export * from './componentOptions'
export { VNodeFlags, ChildrenFlags } from './flags'
export { VNode, Slots } from './vdom'
+
+// Internal API, for libraries or renderers that need to perform low level work
+export {
+ reservedMethods,
+ resolveComponentOptionsFromClass,
+ mergeComponentOptions
+} from './componentOptions'
+export {
+ createComponentInstance,
+ createComponentClassFromOptions
+} from './componentUtils'
import { createComponentVNode, Slots } from '../vdom'
import { Component, ComponentType, ComponentClass } from '../component'
import { unwrap } from '@vue/observer'
+import { isFunction } from '@vue/shared'
interface AsyncComponentFactory {
(): Promise<ComponentType>
export function createAsyncComponent(
options: AsyncComponentOptions
): ComponentClass {
- if (typeof options === 'function') {
+ if (isFunction(options)) {
options = { factory: options }
}
import { VNode, cloneVNode, VNodeData } from '../vdom'
import { ComponentInstance } from '../component'
-import { EMPTY_OBJ } from '../utils'
+import { EMPTY_OBJ } from '@vue/shared'
interface DirectiveBinding {
instance: ComponentInstance
import { VNode, Slots, cloneVNode } from '../vdom'
import { VNodeFlags } from '../flags'
import { warn } from '../warning'
+import { isString, isArray } from '@vue/shared'
type MatchPattern = string | RegExp | string[] | RegExp[]
}
function matches(pattern: MatchPattern, name: string): boolean {
- if (Array.isArray(pattern)) {
+ if (isArray(pattern)) {
return (pattern as any).some((p: string | RegExp) => matches(p, name))
- } else if (typeof pattern === 'string') {
+ } else if (isString(pattern)) {
return pattern.split(',').indexOf(name) > -1
} else if (pattern.test) {
return pattern.test(name)
import { Component } from '../component'
+import { createComponentClassFromOptions } from '../componentUtils'
+import {
+ ComponentOptions,
+ resolveComponentOptionsFromClass,
+ mergeComponentOptions
+} from '../componentOptions'
+import { normalizePropsOptions } from '../componentProps'
+import { isFunction } from '@vue/shared'
interface ComponentConstructor<This = Component> {
new (): This
V = ExtractInstance<T>
>(...args: T): ComponentConstructorWithMixins<V>
export function mixins(...args: any[]): any {
- // TODO
+ let options: ComponentOptions = {}
+ args.forEach(mixin => {
+ if (isFunction(mixin)) {
+ options = mergeComponentOptions(
+ options,
+ resolveComponentOptionsFromClass(mixin)
+ )
+ } else {
+ mixin.props = normalizePropsOptions(mixin.props)
+ options = mergeComponentOptions(options, mixin)
+ }
+ })
+ return createComponentClassFromOptions(options)
}
/* Example usage
+++ /dev/null
-export const EMPTY_OBJ: { readonly [key: string]: any } = Object.freeze({})
-
-export const NOOP = () => {}
-
-export const onRE = /^on/
-export const vnodeHookRE = /^vnode/
-export const handlersRE = /^on|^vnode/
-export const reservedPropRE = /^(?:key|ref|slots)$|^vnode/
-
-export function normalizeStyle(
- value: any
-): Record<string, string | number> | void {
- if (Array.isArray(value)) {
- const res: Record<string, string | number> = {}
- for (let i = 0; i < value.length; i++) {
- const normalized = normalizeStyle(value[i])
- if (normalized) {
- for (const key in normalized) {
- res[key] = normalized[key]
- }
- }
- }
- return res
- } else if (value && typeof value === 'object') {
- return value
- }
-}
-
-export function normalizeClass(value: any): string {
- let res = ''
- if (typeof value === 'string') {
- res = value
- } else if (Array.isArray(value)) {
- for (let i = 0; i < value.length; i++) {
- res += normalizeClass(value[i]) + ' '
- }
- } else if (typeof value === 'object') {
- for (const name in value) {
- if (value[name]) {
- res += name + ' '
- }
- }
- }
- return res.trim()
-}
-
-const camelizeRE = /-(\w)/g
-export const camelize = (str: string): string => {
- return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''))
-}
-
-const hyphenateRE = /\B([A-Z])/g
-export const hyphenate = (str: string): string => {
- return str.replace(hyphenateRE, '-$1').toLowerCase()
-}
-
-export const capitalize = (str: string): string => {
- return str.charAt(0).toUpperCase() + str.slice(1)
-}
-
-// https://en.wikipedia.org/wiki/Longest_increasing_subsequence
-export function lis(arr: number[]): number[] {
- const p = arr.slice()
- const result = [0]
- let i
- let j
- let u
- let v
- let c
- const len = arr.length
- for (i = 0; i < len; i++) {
- const arrI = arr[i]
- if (arrI !== 0) {
- j = result[result.length - 1]
- if (arr[j] < arrI) {
- p[i] = j
- result.push(i)
- continue
- }
- u = 0
- v = result.length - 1
- while (u < v) {
- c = ((u + v) / 2) | 0
- if (arr[result[c]] < arrI) {
- u = c + 1
- } else {
- v = c
- }
- }
- if (arrI < arr[result[u]]) {
- if (u > 0) {
- p[i] = result[u - 1]
- }
- result[u] = i
- }
- }
- }
- u = result.length
- v = result[u - 1]
- while (u-- > 0) {
- result[u] = v
- v = p[v]
- }
- return result
-}
} from './component'
import { VNodeFlags, ChildrenFlags } from './flags'
import { createComponentClassFromOptions } from './componentUtils'
-import { normalizeClass, normalizeStyle, handlersRE, EMPTY_OBJ } from './utils'
+import {
+ handlersRE,
+ EMPTY_OBJ,
+ isObject,
+ isArray,
+ isFunction,
+ isString
+} from '@vue/shared'
import { RawChildrenType, RawSlots } from './h'
// Vue core is platform agnostic, so we are not using Element for "DOM" nodes.
return vnode
}
-function normalizeClassAndStyle(data: VNodeData) {
- if (data.class != null) {
- data.class = normalizeClass(data.class)
- }
- if (data.style != null) {
- data.style = normalizeStyle(data.style)
- }
-}
-
export function createElementVNode(
tag: string,
data: VNodeData | null,
return createVNode(flags, tag, data, children, childFlags, key, ref, null)
}
+function normalizeClassAndStyle(data: VNodeData) {
+ if (data.class != null) {
+ data.class = normalizeClass(data.class)
+ }
+ if (data.style != null) {
+ data.style = normalizeStyle(data.style)
+ }
+}
+
+function normalizeStyle(value: any): Record<string, string | number> | void {
+ if (isArray(value)) {
+ const res: Record<string, string | number> = {}
+ for (let i = 0; i < value.length; i++) {
+ const normalized = normalizeStyle(value[i])
+ if (normalized) {
+ for (const key in normalized) {
+ res[key] = normalized[key]
+ }
+ }
+ }
+ return res
+ } else if (isObject(value)) {
+ return value
+ }
+}
+
+function normalizeClass(value: any): string {
+ let res = ''
+ if (isString(value)) {
+ res = value
+ } else if (isArray(value)) {
+ for (let i = 0; i < value.length; i++) {
+ res += normalizeClass(value[i]) + ' '
+ }
+ } else if (isObject(value)) {
+ for (const name in value) {
+ if (value[name]) {
+ res += name + ' '
+ }
+ }
+ }
+ return res.trim()
+}
+
export function createComponentVNode(
comp: any,
data: VNodeData | null,
let flags: VNodeFlags
// flags
- const compType = typeof comp
- if (compType === 'object') {
+ if (isObject(comp)) {
if (comp.functional) {
// object literal functional
flags = VNodeFlags.COMPONENT_FUNCTIONAL
}
} else {
// assumes comp is function here now
- if (__DEV__ && compType !== 'function') {
+ if (__DEV__ && !isFunction(comp)) {
// TODO warn invalid comp value in dev
}
if (comp.prototype && comp.prototype.render) {
? ChildrenFlags.DYNAMIC_SLOTS
: ChildrenFlags.NO_CHILDREN
if (children != null) {
- const childrenType = typeof children
- if (childrenType === 'function') {
+ if (isFunction(children)) {
// function as children
slots = { default: children }
- } else if (Array.isArray(children) || (children as any)._isVNode) {
+ } else if (isArray(children) || (children as any)._isVNode) {
// direct vnode children
slots = { default: () => children }
- } else if (typeof children === 'object') {
+ } else if (isObject(children)) {
// slot object as children
slots = children
}
function normalizeChildren(vnode: VNode, children: any) {
let childFlags
- if (Array.isArray(children)) {
+ if (isArray(children)) {
const { length } = children
if (length === 0) {
childFlags = ChildrenFlags.NO_CHILDREN
newChild = createTextVNode('')
} else if (child._isVNode) {
newChild = child.el ? cloneVNode(child) : child
- } else if (Array.isArray(child)) {
+ } else if (isArray(child)) {
normalizeVNodes(child, newChildren, currentPrefix + i + '|')
} else {
newChild = createTextVNode(child + '')
function normalizeSlot(value: any): VNode[] {
if (value == null) {
return [createTextVNode('')]
- } else if (Array.isArray(value)) {
+ } else if (isArray(value)) {
return normalizeVNodes(value)
} else if (value._isVNode) {
return [value]
import { ComponentType, ComponentClass, FunctionalComponent } from './component'
-import { EMPTY_OBJ } from './utils'
+import { EMPTY_OBJ, isString } from '@vue/shared'
import { VNode } from './vdom'
import { Data } from './componentOptions'
const res = []
for (const key in props) {
const value = props[key]
- if (typeof value === 'string') {
+ if (isString(value)) {
res.push(`${key}=${JSON.stringify(value)}`)
} else {
res.push(`${key}=`, value)
import { OperationTypes } from './operations'
import { track, trigger } from './autorun'
import { LOCKED } from './lock'
+import { isObject } from '@vue/shared'
const hasOwnProperty = Object.prototype.hasOwnProperty
return res
}
track(target, OperationTypes.GET, key)
- return res !== null && typeof res === 'object'
+ return isObject(res)
? isImmutable
? // need to lazy access immutable and observable here to avoid
// circular dependency
import { track, trigger } from './autorun'
import { OperationTypes } from './operations'
import { LOCKED } from './lock'
+import { isObject } from '@vue/shared'
-const isObject = (value: any) => value !== null && typeof value === 'object'
const toObservable = (value: any) =>
isObject(value) ? observable(value) : value
const toImmutable = (value: any) => (isObject(value) ? immutable(value) : value)
+import { isObject, EMPTY_OBJ } from '@vue/shared'
import { mutableHandlers, immutableHandlers } from './baseHandlers'
import {
export { computed, ComputedGetter } from './computed'
export { lock, unlock } from './lock'
-const EMPTY_OBJ = {}
const collectionTypes: Set<any> = new Set([Set, Map, WeakMap, WeakSet])
const observableValueRE = /^\[object (?:Object|Array|Map|Set|WeakMap|WeakSet)\]$/
baseHandlers: ProxyHandler<any>,
collectionHandlers: ProxyHandler<any>
) {
- if (target === null || typeof target !== 'object') {
+ if (!isObject(target)) {
if (__DEV__) {
console.warn(`value is not observable: ${String(target)}`)
}
-import { createRenderer, VNode, ComponentInstance } from '@vue/core'
+import { createRenderer, VNode, Component } from '@vue/core'
import { nodeOps } from './nodeOps'
import { patchData } from './patchData'
import { teardownVNode } from './teardownVNode'
type publicRender = (
node: VNode | null,
container: HTMLElement
-) => ComponentInstance | null
+) => Component | null
export const render = _render as publicRender
// re-export everything from core
+import { isString } from '@vue/shared'
+
// style properties that should NOT have "px" added when numeric
const nonNumericRE = /acit|ex(?:s|g|n|p|$)|rph|ows|mnc|ntw|ine[ch]|zoo|^ord/i
const { style } = el
if (!next) {
el.removeAttribute('style')
- } else if (typeof next === 'string') {
+ } else if (isString(next)) {
style.cssText = next
} else {
for (const key in next) {
}
style[key] = value
}
- if (prev && typeof prev !== 'string') {
+ if (prev && !isString(prev)) {
for (const key in prev) {
if (!next[key]) {
style[key] = ''
-import { createRenderer, VNode, ComponentInstance } from '@vue/core'
+import { createRenderer, VNode, Component } from '@vue/core'
import { nodeOps, TestElement } from './nodeOps'
import { patchData } from './patchData'
type publicRender = (
node: VNode | null,
container: TestElement
-) => ComponentInstance | null
+) => Component | null
export const render = _render as publicRender
export { serialize } from './serialize'
--- /dev/null
+# @vue/shared
\ No newline at end of file
--- /dev/null
+{
+ "name": "@vue/shared",
+ "private": true
+}
--- /dev/null
+export const EMPTY_OBJ: { readonly [key: string]: any } = Object.freeze({})
+
+export const NOOP = () => {}
+
+export const onRE = /^on/
+export const vnodeHookRE = /^vnode/
+export const handlersRE = /^on|^vnode/
+export const reservedPropRE = /^(?:key|ref|slots)$|^vnode/
+
+export const isArray = Array.isArray
+export const isFunction = (val: any): val is Function =>
+ typeof val === 'function'
+export const isString = (val: any): val is string => typeof val === 'string'
+export const isObject = (val: any): val is Record<any, any> =>
+ val !== null && typeof val === 'object'
+
+const camelizeRE = /-(\w)/g
+export const camelize = (str: string): string => {
+ return str.replace(camelizeRE, (_, c) => (c ? c.toUpperCase() : ''))
+}
+
+const hyphenateRE = /\B([A-Z])/g
+export const hyphenate = (str: string): string => {
+ return str.replace(hyphenateRE, '-$1').toLowerCase()
+}
+
+export const capitalize = (str: string): string => {
+ return str.charAt(0).toUpperCase() + str.slice(1)
+}
// convert it to a class
const Component = createComponentClassFromOptions(options || {})
const vnode = h(Component)
- const instance = createComponentInstance(vnode, Component, null)
+ const instance = createComponentInstance(vnode, Component)
function mount(el: any) {
const dom = typeof el === 'string' ? document.querySelector(el) : el
// during a single build.
hasTSChecked = true
+ const externals = Object.keys(aliasOptions).filter(p => p !== '@vue/shared')
+
return {
input: resolve(`src/index.ts`),
// Global and Browser ESM builds inlines everything so that they can be
// used alone.
- external:
- isGlobalBuild || isBrowserESMBuild ? [] : Object.keys(aliasOptions),
+ external: isGlobalBuild || isBrowserESMBuild ? [] : externals,
plugins: [
tsPlugin,
aliasPlugin,
const fs = require('fs')
-const targets = exports.targets = fs.readdirSync('packages').filter(f => {
- return fs.statSync(`packages/${f}`).isDirectory()
-})
+const targets = (exports.targets = fs.readdirSync('packages').filter(f => {
+ return f !== 'shared' && fs.statSync(`packages/${f}`).isDirectory()
+}))
exports.fuzzyMatchTarget = partialTarget => {
const matched = []
],
"rootDir": ".",
"paths": {
+ "@vue/shared": ["packages/shared/src"],
"@vue/core": ["packages/core/src"],
"@vue/observer": ["packages/observer/src"],
"@vue/scheduler": ["packages/scheduler/src"],
projects / thirdparty / vuejs / core.git / commitdiff
