echarts component 源码

echarts component 代码

文件路径：/src/util/component.ts

/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements.  See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership.  The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License.  You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied.  See the License for the
* specific language governing permissions and limitations
* under the License.
*/

import * as zrUtil from 'zrender/src/core/util';
import {parseClassType, ClassManager} from './clazz';
import { ComponentOption, ComponentMainType, ComponentSubType, ComponentFullType } from './types';
import { Dictionary } from 'zrender/src/core/types';
import { makePrintable } from './log';

// A random offset
let base = Math.round(Math.random() * 10);


/**
 * @public
 * @param {string} type
 * @return {string}
 */
export function getUID(type: string): string {
    // Considering the case of crossing js context,
    // use Math.random to make id as unique as possible.
    return [(type || ''), base++].join('_');
}

export interface SubTypeDefaulter {
    // return subType.
    (option: ComponentOption): ComponentSubType;
}

export interface SubTypeDefaulterManager {
    registerSubTypeDefaulter: (componentType: string, defaulter: SubTypeDefaulter) => void;
    determineSubType: (componentType: string, option: ComponentOption) => string;
}

/**
 * Implements `SubTypeDefaulterManager` for `target`.
 */
export function enableSubTypeDefaulter(target: SubTypeDefaulterManager & ClassManager): void {
    const subTypeDefaulters: Dictionary<SubTypeDefaulter> = {};

    target.registerSubTypeDefaulter = function (
        componentType: ComponentFullType,
        defaulter: SubTypeDefaulter
    ): void {
        const componentTypeInfo = parseClassType(componentType);
        subTypeDefaulters[componentTypeInfo.main] = defaulter;
    };

    target.determineSubType = function (
        componentType: ComponentFullType,
        option: ComponentOption
    ): string {
        let type = option.type;
        if (!type) {
            const componentTypeMain = parseClassType(componentType).main;
            if (target.hasSubTypes(componentType) && subTypeDefaulters[componentTypeMain]) {
                type = subTypeDefaulters[componentTypeMain](option);
            }
        }
        return type;
    };
}

export interface TopologicalTravelable<T> {
    topologicalTravel: (
        targetNameList: ComponentMainType[],
        fullNameList: ComponentMainType[],
        callback: (this: T, mainType: string, dependencies: string[]) => void,
        context?: T
    ) => void;
}


// ComponentMainType can be 'bb' or 'aa.xx'.
type DepGraphItem = {
    predecessor: ComponentMainType[],
    successor: ComponentMainType[],
    originalDeps: ComponentMainType[],
    entryCount: number
};
type DepGraph = {[cmptMainType: string]: DepGraphItem};

/**
 * Implements `TopologicalTravelable<any>` for `entity`.
 *
 * Topological travel on Activity Network (Activity On Vertices).
 * Dependencies is defined in Model.prototype.dependencies, like ['xAxis', 'yAxis'].
 * If 'xAxis' or 'yAxis' is absent in componentTypeList, just ignore it in topology.
 * If there is circular dependencey, Error will be thrown.
 */
export function enableTopologicalTravel<T>(
    entity: TopologicalTravelable<T>,
    dependencyGetter: (name: ComponentMainType) => ComponentMainType[]
): void {

    /**
     * @param targetNameList Target Component type list.
     *                       Can be ['aa', 'bb', 'aa.xx']
     * @param fullNameList By which we can build dependency graph.
     * @param callback Params: componentType, dependencies.
     * @param context Scope of callback.
     */
    entity.topologicalTravel = function<Ctx> (
        targetNameList: ComponentMainType[],
        fullNameList: ComponentMainType[],
        callback: (this: Ctx, mainType: ComponentMainType, dependencies: ComponentMainType[]) => void,
        context?: Ctx
    ) {
        if (!targetNameList.length) {
            return;
        }

        const result = makeDepndencyGraph(fullNameList);
        const graph = result.graph;
        const noEntryList = result.noEntryList;

        const targetNameSet: {[cmtpMainType: string]: boolean} = {};
        zrUtil.each(targetNameList, function (name) {
            targetNameSet[name] = true;
        });

        while (noEntryList.length) {
            const currComponentType = noEntryList.pop();
            const currVertex = graph[currComponentType];
            const isInTargetNameSet = !!targetNameSet[currComponentType];
            if (isInTargetNameSet) {
                callback.call(context, currComponentType, currVertex.originalDeps.slice());
                delete targetNameSet[currComponentType];
            }
            zrUtil.each(
                currVertex.successor,
                isInTargetNameSet ? removeEdgeAndAdd : removeEdge
            );
        }

        zrUtil.each(targetNameSet, function () {
            let errMsg = '';
            if (__DEV__) {
                errMsg = makePrintable('Circular dependency may exists: ', targetNameSet, targetNameList, fullNameList);
            }
            throw new Error(errMsg);
        });

        function removeEdge(succComponentType: ComponentMainType): void {
            graph[succComponentType].entryCount--;
            if (graph[succComponentType].entryCount === 0) {
                noEntryList.push(succComponentType);
            }
        }

        // Consider this case: legend depends on series, and we call
        // chart.setOption({series: [...]}), where only series is in option.
        // If we do not have 'removeEdgeAndAdd', legendModel.mergeOption will
        // not be called, but only sereis.mergeOption is called. Thus legend
        // have no chance to update its local record about series (like which
        // name of series is available in legend).
        function removeEdgeAndAdd(succComponentType: ComponentMainType): void {
            targetNameSet[succComponentType] = true;
            removeEdge(succComponentType);
        }
    };

    function makeDepndencyGraph(fullNameList: ComponentMainType[]) {
        const graph: DepGraph = {};
        const noEntryList: ComponentMainType[] = [];

        zrUtil.each(fullNameList, function (name: ComponentMainType) {

            const thisItem = createDependencyGraphItem(graph, name);
            const originalDeps = thisItem.originalDeps = dependencyGetter(name);

            const availableDeps = getAvailableDependencies(originalDeps, fullNameList);
            thisItem.entryCount = availableDeps.length;
            if (thisItem.entryCount === 0) {
                noEntryList.push(name);
            }

            zrUtil.each(availableDeps, function (dependentName) {
                if (zrUtil.indexOf(thisItem.predecessor, dependentName) < 0) {
                    thisItem.predecessor.push(dependentName);
                }
                const thatItem = createDependencyGraphItem(graph, dependentName);
                if (zrUtil.indexOf(thatItem.successor, dependentName) < 0) {
                    thatItem.successor.push(name);
                }
            });
        });

        return {graph: graph, noEntryList: noEntryList};
    }

    function createDependencyGraphItem(graph: DepGraph, name: ComponentMainType) {
        if (!graph[name]) {
            graph[name] = {predecessor: [], successor: []} as DepGraphItem;
        }
        return graph[name];
    }

    function getAvailableDependencies(
        originalDeps: ComponentMainType[], fullNameList: ComponentMainType[]
    ): ComponentMainType[] {
        const availableDeps = [] as ComponentMainType[];
        zrUtil.each(originalDeps, function (dep) {
            zrUtil.indexOf(fullNameList, dep) >= 0 && availableDeps.push(dep);
        });
        return availableDeps;
    }

}

export function inheritDefaultOption<T, K>(superOption: T, subOption: K): K {
    // See also `model/Component.ts#getDefaultOption`
    return zrUtil.merge(zrUtil.merge({}, superOption, true), subOption, true);
}

相关信息

echarts 源码目录

相关文章

echarts ECEventProcessor 源码

echarts KDTree 源码

echarts animation 源码

echarts clazz 源码

echarts conditionalExpression 源码

echarts decal 源码

echarts event 源码

echarts format 源码

echarts graphic 源码

echarts innerStore 源码