src/model/mixin/palette.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 {Dictionary} from 'zrender/src/core/types';
import {makeInner, normalizeToArray} from '../../util/model';
import Model from '../Model';
import {ZRColor, PaletteOptionMixin, DecalObject, AriaOptionMixin} from '../../util/types';
import GlobalModel from '../Global';

type Inner<T> = (hostObj: PaletteMixin<PaletteOptionMixin>) => {
    paletteIdx: number;
    paletteNameMap: Dictionary<T>;
};

const innerColor: Inner<ZRColor> = makeInner<{
    paletteIdx: number
    paletteNameMap: Dictionary<ZRColor>
}, PaletteMixin>();

const innerDecal: Inner<DecalObject> = makeInner<{
    paletteIdx: number
    paletteNameMap: Dictionary<DecalObject>
}, PaletteMixin>();



interface PaletteMixin<T extends PaletteOptionMixin = PaletteOptionMixin>
    extends Pick<Model<T>, 'get'> {}

class PaletteMixin<T extends PaletteOptionMixin = PaletteOptionMixin> {
    getColorFromPalette(
        this: PaletteMixin<T>,
        name: string,
        scope?: any,
        requestNum?: number
    ): ZRColor {
        const defaultPalette = normalizeToArray(this.get('color', true));
        const layeredPalette = this.get('colorLayer', true);
        return getFromPalette<ZRColor>(this, innerColor, defaultPalette, layeredPalette, name, scope, requestNum);
    }

    clearColorPalette(this: PaletteMixin<T>) {
        clearPalette<ZRColor>(this, innerColor);
    }
}

export function getDecalFromPalette(
    ecModel: GlobalModel,
    name: string,
    scope?: any,
    requestNum?: number
): DecalObject {
    const defaultDecals = normalizeToArray((ecModel as Model<AriaOptionMixin>).get(['aria', 'decal', 'decals']));
    return getFromPalette<DecalObject>(ecModel, innerDecal, defaultDecals, null, name, scope, requestNum);
}


function getNearestPalette<T>(
    palettes: T[][], requestColorNum: number
): T[] {
    const paletteNum = palettes.length;
    // TODO palettes must be in order
    for (let i = 0; i < paletteNum; i++) {
        if (palettes[i].length > requestColorNum) {
            return palettes[i];
        }
    }
    return palettes[paletteNum - 1];
}

/**
 * @param name MUST NOT be null/undefined. Otherwise call this function
 *             twise with the same parameters will get different result.
 * @param scope default this.
 * @return Can be null/undefined
 */
function getFromPalette<T>(
    that: PaletteMixin,
    inner: Inner<T>,
    defaultPalette: T[],
    layeredPalette: T[][],
    name: string,
    scope?: any,
    requestNum?: number
): T {
    scope = scope || that;
    const scopeFields = inner(scope);
    const paletteIdx = scopeFields.paletteIdx || 0;
    const paletteNameMap = scopeFields.paletteNameMap = scopeFields.paletteNameMap || {};
    // Use `hasOwnProperty` to avoid conflict with Object.prototype.
    if (paletteNameMap.hasOwnProperty(name)) {
        return paletteNameMap[name];
    }
    let palette = ((requestNum == null || !layeredPalette)
        ? defaultPalette : getNearestPalette(layeredPalette, requestNum));

    // In case can't find in layered color palette.
    palette = palette || defaultPalette;

    if (!palette || !palette.length) {
        return;
    }

    const pickedPaletteItem = palette[paletteIdx];
    if (name) {
        paletteNameMap[name] = pickedPaletteItem;
    }
    scopeFields.paletteIdx = (paletteIdx + 1) % palette.length;

    return pickedPaletteItem;
}

function clearPalette<T>(that: PaletteMixin, inner: Inner<T>) {
    inner(that).paletteIdx = 0;
    inner(that).paletteNameMap = {};
}

export {PaletteMixin};