PHP Classes

File: public/js/lib/vue/src/util/options.js

Recommend this page to a friend!
  Classes of Sergey Beskorovayniy   Silex MVC Blog   public/js/lib/vue/src/util/options.js   Download  
File: public/js/lib/vue/src/util/options.js
Role: Auxiliary data
Content type: text/plain
Description: Auxiliary data
Class: Silex MVC Blog
MVC based blog using on the Silex micro-framework
Author: By
Last change:
Date: 8 years ago
Size: 9,275 bytes
 

Contents

Class file image Download
import Vue from '../instance/vue' import config from '../config' import { extend, set, isObject, isArray, isPlainObject, hasOwn, camelize, hyphenate } from './lang' import { warn } from './debug' import { commonTagRE, reservedTagRE } from './component' /** * Option overwriting strategies are functions that handle * how to merge a parent option value and a child option * value into the final value. * * All strategy functions follow the same signature: * * @param {*} parentVal * @param {*} childVal * @param {Vue} [vm] */ var strats = config.optionMergeStrategies = Object.create(null) /** * Helper that recursively merges two data objects together. */ function mergeData (to, from) { var key, toVal, fromVal for (key in from) { toVal = to[key] fromVal = from[key] if (!hasOwn(to, key)) { set(to, key, fromVal) } else if (isObject(toVal) && isObject(fromVal)) { mergeData(toVal, fromVal) } } return to } /** * Data */ strats.data = function (parentVal, childVal, vm) { if (!vm) { // in a Vue.extend merge, both should be functions if (!childVal) { return parentVal } if (typeof childVal !== 'function') { process.env.NODE_ENV !== 'production' && warn( 'The "data" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm ) return parentVal } if (!parentVal) { return childVal } // when parentVal & childVal are both present, // we need to return a function that returns the // merged result of both functions... no need to // check if parentVal is a function here because // it has to be a function to pass previous merges. return function mergedDataFn () { return mergeData( childVal.call(this), parentVal.call(this) ) } } else if (parentVal || childVal) { return function mergedInstanceDataFn () { // instance merge var instanceData = typeof childVal === 'function' ? childVal.call(vm) : childVal var defaultData = typeof parentVal === 'function' ? parentVal.call(vm) : undefined if (instanceData) { return mergeData(instanceData, defaultData) } else { return defaultData } } } } /** * El */ strats.el = function (parentVal, childVal, vm) { if (!vm && childVal && typeof childVal !== 'function') { process.env.NODE_ENV !== 'production' && warn( 'The "el" option should be a function ' + 'that returns a per-instance value in component ' + 'definitions.', vm ) return } var ret = childVal || parentVal // invoke the element factory if this is instance merge return vm && typeof ret === 'function' ? ret.call(vm) : ret } /** * Hooks and param attributes are merged as arrays. */ strats.init = strats.created = strats.ready = strats.attached = strats.detached = strats.beforeCompile = strats.compiled = strats.beforeDestroy = strats.destroyed = strats.activate = function (parentVal, childVal) { return childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal } /** * Assets * * When a vm is present (instance creation), we need to do * a three-way merge between constructor options, instance * options and parent options. */ function mergeAssets (parentVal, childVal) { var res = Object.create(parentVal || null) return childVal ? extend(res, guardArrayAssets(childVal)) : res } config._assetTypes.forEach(function (type) { strats[type + 's'] = mergeAssets }) /** * Events & Watchers. * * Events & watchers hashes should not overwrite one * another, so we merge them as arrays. */ strats.watch = strats.events = function (parentVal, childVal) { if (!childVal) return parentVal if (!parentVal) return childVal var ret = {} extend(ret, parentVal) for (var key in childVal) { var parent = ret[key] var child = childVal[key] if (parent && !isArray(parent)) { parent = [parent] } ret[key] = parent ? parent.concat(child) : [child] } return ret } /** * Other object hashes. */ strats.props = strats.methods = strats.computed = function (parentVal, childVal) { if (!childVal) return parentVal if (!parentVal) return childVal var ret = Object.create(null) extend(ret, parentVal) extend(ret, childVal) return ret } /** * Default strategy. */ var defaultStrat = function (parentVal, childVal) { return childVal === undefined ? parentVal : childVal } /** * Make sure component options get converted to actual * constructors. * * @param {Object} options */ function guardComponents (options) { if (options.components) { var components = options.components = guardArrayAssets(options.components) var ids = Object.keys(components) var def if (process.env.NODE_ENV !== 'production') { var map = options._componentNameMap = {} } for (var i = 0, l = ids.length; i < l; i++) { var key = ids[i] if (commonTagRE.test(key) || reservedTagRE.test(key)) { process.env.NODE_ENV !== 'production' && warn( 'Do not use built-in or reserved HTML elements as component ' + 'id: ' + key ) continue } // record a all lowercase <-> kebab-case mapping for // possible custom element case error warning if (process.env.NODE_ENV !== 'production') { map[key.replace(/-/g, '').toLowerCase()] = hyphenate(key) } def = components[key] if (isPlainObject(def)) { components[key] = Vue.extend(def) } } } } /** * Ensure all props option syntax are normalized into the * Object-based format. * * @param {Object} options */ function guardProps (options) { var props = options.props var i, val if (isArray(props)) { options.props = {} i = props.length while (i--) { val = props[i] if (typeof val === 'string') { options.props[val] = null } else if (val.name) { options.props[val.name] = val } } } else if (isPlainObject(props)) { var keys = Object.keys(props) i = keys.length while (i--) { val = props[keys[i]] if (typeof val === 'function') { props[keys[i]] = { type: val } } } } } /** * Guard an Array-format assets option and converted it * into the key-value Object format. * * @param {Object|Array} assets * @return {Object} */ function guardArrayAssets (assets) { if (isArray(assets)) { var res = {} var i = assets.length var asset while (i--) { asset = assets[i] var id = typeof asset === 'function' ? ((asset.options && asset.options.name) || asset.id) : (asset.name || asset.id) if (!id) { process.env.NODE_ENV !== 'production' && warn( 'Array-syntax assets must provide a "name" or "id" field.' ) } else { res[id] = asset } } return res } return assets } /** * Merge two option objects into a new one. * Core utility used in both instantiation and inheritance. * * @param {Object} parent * @param {Object} child * @param {Vue} [vm] - if vm is present, indicates this is * an instantiation merge. */ export function mergeOptions (parent, child, vm) { guardComponents(child) guardProps(child) if (process.env.NODE_ENV !== 'production') { if (child.propsData && !vm) { warn('propsData can only be used as an instantiation option.') } } var options = {} var key if (child.extends) { parent = typeof child.extends === 'function' ? mergeOptions(parent, child.extends.options, vm) : mergeOptions(parent, child.extends, vm) } if (child.mixins) { for (var i = 0, l = child.mixins.length; i < l; i++) { var mixin = child.mixins[i] var mixinOptions = mixin.prototype instanceof Vue ? mixin.options : mixin parent = mergeOptions(parent, mixinOptions, vm) } } for (key in parent) { mergeField(key) } for (key in child) { if (!hasOwn(parent, key)) { mergeField(key) } } function mergeField (key) { var strat = strats[key] || defaultStrat options[key] = strat(parent[key], child[key], vm, key) } return options } /** * Resolve an asset. * This function is used because child instances need access * to assets defined in its ancestor chain. * * @param {Object} options * @param {String} type * @param {String} id * @param {Boolean} warnMissing * @return {Object|Function} */ export function resolveAsset (options, type, id, warnMissing) { /* istanbul ignore if */ if (typeof id !== 'string') { return } var assets = options[type] var camelizedId var res = assets[id] || // camelCase ID assets[camelizedId = camelize(id)] || // Pascal Case ID assets[camelizedId.charAt(0).toUpperCase() + camelizedId.slice(1)] if (process.env.NODE_ENV !== 'production' && warnMissing && !res) { warn( 'Failed to resolve ' + type.slice(0, -1) + ': ' + id, options ) } return res }