@livechart/sharp-vibrant/lib/vibrant.js

Extract prominent colors from an image in a node environment using sharp.

"use strict";
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, privateMap, value) {
    if (!privateMap.has(receiver)) {
        throw new TypeError("attempted to set private field on non-instance");
    }
    privateMap.set(receiver, value);
    return value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, privateMap) {
    if (!privateMap.has(receiver)) {
        throw new TypeError("attempted to get private field on non-instance");
    }
    return privateMap.get(receiver);
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
var _src;
Object.defineProperty(exports, "__esModule", { value: true });
const color_1 = require("./color");
// eslint-disable-next-line import/no-cycle
const builder_1 = __importDefault(require("./builder"));
const Util = __importStar(require("./util"));
const quantizer_1 = __importDefault(require("./quantizer"));
const generator_1 = require("./generator");
// eslint-disable-next-line import/no-cycle
const Filters = __importStar(require("./filter"));
class Vibrant {
    constructor(src, opts) {
        _src.set(this, void 0);
        __classPrivateFieldSet(this, _src, src);
        this.opts = (Object.assign(Object.assign({}, Vibrant.DefaultOpts), opts));
        this.opts.combinedFilter = Filters.combineFilters(this.opts.filters);
    }
    static from(src) {
        return new builder_1.default(src);
    }
    process(image) {
        const { quantizer, generator } = this.opts;
        return image.applyFilter(this.opts.combinedFilter)
            .then((imageData) => quantizer(imageData.data, this.opts))
            .then((colors) => color_1.Swatch.applyFilter(colors, this.opts.combinedFilter))
            .then((colors) => Promise.resolve(generator(colors)));
    }
    getPalette(cb) {
        const image = new this.opts.ImageClass();
        const result = image.load(__classPrivateFieldGet(this, _src), this.opts)
            .then((loadedImage) => this.process(loadedImage))
            .then((palette) => {
            const paletteResult = {
                pixelCount: image.pixelCount,
                imageDimensions: {
                    width: image.width,
                    height: image.height,
                },
                palette,
            };
            image.cleanup();
            return paletteResult;
        }, (err) => {
            image.cleanup();
            throw err;
        });
        if (cb) {
            result.then((palette) => cb(null, palette), (err) => cb(err));
        }
        return result;
    }
}
_src = new WeakMap();
Vibrant.Builder = builder_1.default;
Vibrant.Quantizer = quantizer_1.default;
Vibrant.Generator = generator_1.Default;
Vibrant.Filter = Filters;
Vibrant.Util = Util;
Vibrant.Swatch = color_1.Swatch;
Vibrant.DefaultOpts = {
    colorCount: 64,
    quality: 5,
    generator: generator_1.Default,
    ImageClass: null,
    quantizer: quantizer_1.default,
    filters: [Filters.Default],
};
exports.default = Vibrant;
//# sourceMappingURL=vibrant.js.map