index.mjs

function noop() { }
function run(fn) {
    return fn();
}
function blank_object() {
    return Object.create(null);
}
function run_all(fns) {
    fns.forEach(run);
}
function is_function(thing) {
    return typeof thing === 'function';
}
function safe_not_equal(a, b) {
    return a != a ? b == b : a !== b || ((a && typeof a === 'object') || typeof a === 'function');
}
function is_empty(obj) {
    return Object.keys(obj).length === 0;
}
function insert(target, node, anchor) {
    target.insertBefore(node, anchor || null);
}
function detach(node) {
    node.parentNode.removeChild(node);
}
function element(name) {
    return document.createElement(name);
}
function attr(node, attribute, value) {
    if (value == null)
        node.removeAttribute(attribute);
    else if (node.getAttribute(attribute) !== value)
        node.setAttribute(attribute, value);
}
function children(element) {
    return Array.from(element.childNodes);
}
function custom_event(type, detail) {
    const e = document.createEvent('CustomEvent');
    e.initCustomEvent(type, false, false, detail);
    return e;
}

let current_component;
function set_current_component(component) {
    current_component = component;
}
function get_current_component() {
    if (!current_component)
        throw new Error(`Function called outside component initialization`);
    return current_component;
}
function beforeUpdate(fn) {
    get_current_component().$$.before_update.push(fn);
}
function onMount(fn) {
    get_current_component().$$.on_mount.push(fn);
}
function afterUpdate(fn) {
    get_current_component().$$.after_update.push(fn);
}
function onDestroy(fn) {
    get_current_component().$$.on_destroy.push(fn);
}
function createEventDispatcher() {
    const component = get_current_component();
    return (type, detail) => {
        const callbacks = component.$$.callbacks[type];
        if (callbacks) {
            // TODO are there situations where events could be dispatched
            // in a server (non-DOM) environment?
            const event = custom_event(type, detail);
            callbacks.slice().forEach(fn => {
                fn.call(component, event);
            });
        }
    };
}

const dirty_components = [];
const binding_callbacks = [];
const render_callbacks = [];
const flush_callbacks = [];
const resolved_promise = Promise.resolve();
let update_scheduled = false;
function schedule_update() {
    if (!update_scheduled) {
        update_scheduled = true;
        resolved_promise.then(flush);
    }
}
function add_render_callback(fn) {
    render_callbacks.push(fn);
}
let flushing = false;
const seen_callbacks = new Set();
function flush() {
    if (flushing)
        return;
    flushing = true;
    do {
        // first, call beforeUpdate functions
        // and update components
        for (let i = 0; i < dirty_components.length; i += 1) {
            const component = dirty_components[i];
            set_current_component(component);
            update(component.$$);
        }
        dirty_components.length = 0;
        while (binding_callbacks.length)
            binding_callbacks.pop()();
        // then, once components are updated, call
        // afterUpdate functions. This may cause
        // subsequent updates...
        for (let i = 0; i < render_callbacks.length; i += 1) {
            const callback = render_callbacks[i];
            if (!seen_callbacks.has(callback)) {
                // ...so guard against infinite loops
                seen_callbacks.add(callback);
                callback();
            }
        }
        render_callbacks.length = 0;
    } while (dirty_components.length);
    while (flush_callbacks.length) {
        flush_callbacks.pop()();
    }
    update_scheduled = false;
    flushing = false;
    seen_callbacks.clear();
}
function update($$) {
    if ($$.fragment !== null) {
        $$.update();
        run_all($$.before_update);
        const dirty = $$.dirty;
        $$.dirty = [-1];
        $$.fragment && $$.fragment.p($$.ctx, dirty);
        $$.after_update.forEach(add_render_callback);
    }
}
const outroing = new Set();
function transition_in(block, local) {
    if (block && block.i) {
        outroing.delete(block);
        block.i(local);
    }
}
function mount_component(component, target, anchor) {
    const { fragment, on_mount, on_destroy, after_update } = component.$$;
    fragment && fragment.m(target, anchor);
    // onMount happens before the initial afterUpdate
    add_render_callback(() => {
        const new_on_destroy = on_mount.map(run).filter(is_function);
        if (on_destroy) {
            on_destroy.push(...new_on_destroy);
        }
        else {
            // Edge case - component was destroyed immediately,
            // most likely as a result of a binding initialising
            run_all(new_on_destroy);
        }
        component.$$.on_mount = [];
    });
    after_update.forEach(add_render_callback);
}
function destroy_component(component, detaching) {
    const $$ = component.$$;
    if ($$.fragment !== null) {
        run_all($$.on_destroy);
        $$.fragment && $$.fragment.d(detaching);
        // TODO null out other refs, including component.$$ (but need to
        // preserve final state?)
        $$.on_destroy = $$.fragment = null;
        $$.ctx = [];
    }
}
function make_dirty(component, i) {
    if (component.$$.dirty[0] === -1) {
        dirty_components.push(component);
        schedule_update();
        component.$$.dirty.fill(0);
    }
    component.$$.dirty[(i / 31) | 0] |= (1 << (i % 31));
}
function init(component, options, instance, create_fragment, not_equal, props, dirty = [-1]) {
    const parent_component = current_component;
    set_current_component(component);
    const prop_values = options.props || {};
    const $$ = component.$$ = {
        fragment: null,
        ctx: null,
        // state
        props,
        update: noop,
        not_equal,
        bound: blank_object(),
        // lifecycle
        on_mount: [],
        on_destroy: [],
        before_update: [],
        after_update: [],
        context: new Map(parent_component ? parent_component.$$.context : []),
        // everything else
        callbacks: blank_object(),
        dirty,
        skip_bound: false
    };
    let ready = false;
    $$.ctx = instance
        ? instance(component, prop_values, (i, ret, ...rest) => {
            const value = rest.length ? rest[0] : ret;
            if ($$.ctx && not_equal($$.ctx[i], $$.ctx[i] = value)) {
                if (!$$.skip_bound && $$.bound[i])
                    $$.bound[i](value);
                if (ready)
                    make_dirty(component, i);
            }
            return ret;
        })
        : [];
    $$.update();
    ready = true;
    run_all($$.before_update);
    // `false` as a special case of no DOM component
    $$.fragment = create_fragment ? create_fragment($$.ctx) : false;
    if (options.target) {
        if (options.hydrate) {
            const nodes = children(options.target);
            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
            $$.fragment && $$.fragment.l(nodes);
            nodes.forEach(detach);
        }
        else {
            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
            $$.fragment && $$.fragment.c();
        }
        if (options.intro)
            transition_in(component.$$.fragment);
        mount_component(component, options.target, options.anchor);
        flush();
    }
    set_current_component(parent_component);
}
class SvelteComponent {
    $destroy() {
        destroy_component(this, 1);
        this.$destroy = noop;
    }
    $on(type, callback) {
        const callbacks = (this.$$.callbacks[type] || (this.$$.callbacks[type] = []));
        callbacks.push(callback);
        return () => {
            const index = callbacks.indexOf(callback);
            if (index !== -1)
                callbacks.splice(index, 1);
        };
    }
    $set($$props) {
        if (this.$$set && !is_empty($$props)) {
            this.$$.skip_bound = true;
            this.$$set($$props);
            this.$$.skip_bound = false;
        }
    }
}

var Events = [
  "beforeLinkedItemOpen",
  "linkedItemOpened",
  "beforeLinkedItemClose",
  "linkedItemClosed",
  "printReadyStateChange",
  "dataLoadRequestCompleted",
  "dataLoadError",
  "dataLoadCancelled",
  "dataLoadRequestCancelled",
  "dataUpdated",
  "dataUpdateCancelled",
  "dataLoadRequested",
  "beforeDataUpdate",
  "realTimeUpdateComplete",
  "chartCleared",
  "slicingEnd",
  "slicingStart",
  "entityRollOut",
  "entityRollOver",
  "entityClick",
  "connectorRollOver",
  "connectorRollOut",
  "connectorClick",
  "markerRollOver",
  "markerRollOut",
  "markerClick",
  "pageNavigated",
  "rotationEnd",
  "rotationStart",
  "centerLabelRollover",
  "centerLabelRollout",
  "centerLabelClick",
  "centerLabelChanged",
  "chartClick",
  "chartMouseMove",
  "chartRollOver",
  "chartRollOut",
  "backgroundLoaded",
  "backgroundLoadError",
  "legendItemClicked",
  "legendItemRollover",
  "legendItemRollout",
  "logoRollover",
  "logoRollout",
  "logoClick",
  "logoLoaded",
  "logoLoadError",
  "beforeExport",
  "exported",
  "exportCancelled",
  "beforePrint",
  "printComplete",
  "printCancelled",
  "dataLabelClick",
  "dataLabelRollOver",
  "dataLabelRollOut",
  "scrollStart",
  "scrollEnd",
  "onScroll",
  "zoomReset",
  "zoomedOut",
  "zoomedIn",
  "zoomed",
  "zoomModeChanged",
  "pinned",
  "dataRestored",
  "beforeDataSubmit",
  "dataSubmitError",
  "dataSubmitted",
  "dataSubmitCancelled",
  "chartUpdated",
  "nodeAdded",
  "nodeUpdated",
  "nodeDeleted",
  "connectorAdded",
  "connectorUpdated",
  "connectorDeleted",
  "labelAdded",
  "labelDeleted",
  "selectionRemoved",
  "selectionStart",
  "selectionEnd",
  "labelClick",
  "labelRollOver",
  "labelRollOut",
  "labelDragStart",
  "labelDragEnd",
  "dataplotDragStart",
  "dataplotDragEnd",
  "processClick",
  "processRollOver",
  "processRollOut",
  "categoryClick",
  "categoryRollOver",
  "categoryRollOut",
  "milestoneClick",
  "milestoneRollOver",
  "milestoneRollOut",
  "chartTypeChanged",
  "overlayButtonClick",
  "loaded",
  "rendered",
  "drawComplete",
  "renderComplete",
  "dataInvalid",
  "dataXMLInvalid",
  "dataLoaded",
  "noDataToDisplay",
  "legendPointerDragStart",
  "legendPointerDragStop",
  "legendRangeUpdated",
  "alertComplete",
  "realTimeUpdateError",
  "dataplotRollOver",
  "dataplotRollOut",
  "dataplotClick",
  "linkClicked",
  "beforeRender",
  "renderCancelled",
  "beforeResize",
  "resized",
  "resizeCancelled",
  "beforeDispose",
  "disposed",
  "disposeCancelled",
  "linkedChartInvoked",
  "beforeDrillDown",
  "drillDown",
  "beforeDrillUp",
  "drillUp",
  "drillDownCancelled",
  "drillUpCancelled"
];

const ATOMIC_DATA_TYPE = ['string', 'number', 'function', 'boolean', 'undefined'],
    charSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789',
    isResizeRequired = (oldConfig, newConfig) => {
        let { width, height } = oldConfig,
            newWidth = newConfig.width,
            newHeight = newConfig.height;

        if (width !== newWidth || height !== newHeight) {
            return true;
        }
        return false;
    },
    isChartTypeChanged = (oldConfig, newConfig) => {
        return (oldConfig.type !== newConfig.type);
    },
    cloneObject = (arg, purpose = 'clone') => {
        if ((ATOMIC_DATA_TYPE.indexOf(typeof arg) > -1) || arg === null) {
            return arg;
        }

        if (Array.isArray(arg)) {
            let i,
                len,
                arr = [];

            for (i = 0, len = arg.length; i < len; i++) {
                arr.push(cloneObject(arg[i], purpose));
            }

            return arr;
        } else if (typeof arg === 'object') {
            let cloneObj = {},
                key;

            for (key in arg) {
                if (key === 'data') {
                    if (arg[key] && arg[key]._dataStore) {
                        cloneObj[key] = (purpose === 'clone') ? arg[key] : '-'; 
                    } else {
                        cloneObj[key] = cloneObject(arg[key], purpose);
                    }
                } else {
                    cloneObj[key] = cloneObject(arg[key], purpose);
                }
            }

            return cloneObj;
        }
    },
    isDataSourceUpdated = (oldConfig, newConfig) => {
        return JSON.stringify(cloneObject(oldConfig.dataSource, 'diff')) !== JSON.stringify(cloneObject(newConfig.dataSource, 'diff'));
    },
    createUniqueId = (length = 20) => {
        let i,
            result = '',
            charactersLength = charSet.length;

        for (i = 0; i < length; i++) {
           result += charSet.charAt(Math.floor(Math.random() * charactersLength));
        }
        return result;
     };

/* src/index.svelte generated by Svelte v3.24.1 */

function create_fragment(ctx) {
	let div;

	return {
		c() {
			div = element("div");
			attr(div, "class", /*className*/ ctx[0]);
			attr(div, "style", /*inlineStyle*/ ctx[1]);
			attr(div, "id", /*uniqueDivId*/ ctx[2]);
		},
		m(target, anchor) {
			insert(target, div, anchor);
		},
		p(ctx, [dirty]) {
			if (dirty & /*className*/ 1) {
				attr(div, "class", /*className*/ ctx[0]);
			}

			if (dirty & /*inlineStyle*/ 2) {
				attr(div, "style", /*inlineStyle*/ ctx[1]);
			}
		},
		i: noop,
		o: noop,
		d(detaching) {
			if (detaching) detach(div);
		}
	};
}

let FroalaCharts;

function fcRoot(core, ...modules) {
	FroalaCharts = core;

	modules.forEach(m => {
		if (m.getName && m.getType || m.name && m.type) {
			core.addDep(m);
		} else {
			m(core);
		}
	});
}

function instance($$self, $$props, $$invalidate) {
	let { id } = $$props,
		{ className = "" } = $$props,
		{ inlineStyle = "" } = $$props,
		{ type } = $$props,
		{ renderAt } = $$props,
		{ width } = $$props,
		{ height } = $$props,
		{ dataFormat = "json" } = $$props,
		{ dataSource } = $$props,
		{ chart } = $$props;

	let oldChartConfig, chartConfig, eventListerners = [];
	const dispatch = createEventDispatcher(), uniqueDivId = createUniqueId();

	/**
 * Life cycle method sequence
 * beforeUpdate -> onMount -> afterUpdate (during intial render)
 * beforeUpdate -> afterUpdate (during re-render)
 */
	beforeUpdate(() => {
		$$invalidate(3, renderAt = uniqueDivId);

		chartConfig = {
			id,
			type,
			renderAt,
			width,
			height,
			dataFormat,
			dataSource: cloneObject(dataSource)
		};
	});

	onMount(() => {
		if (!FroalaCharts) {
			console.warn("Invalid FroalaCharts constructor");
		} else {
			FroalaCharts.ready(function () {
				$$invalidate(4, chart = new FroalaCharts(chartConfig));
				chart.render();
			});

			Events.forEach((event, index) => {
				eventListerners.push(e => {
					dispatch(event, e);
				});

				FroalaCharts.addEventListener(event, eventListerners[index]);
			});
		}
	});

	afterUpdate(() => {
		// If not the first render
		if (oldChartConfig) {
			if (isResizeRequired(oldChartConfig, chartConfig)) {
				chart.resizeTo(chartConfig.width, chartConfig.height);
			}

			if (isChartTypeChanged(oldChartConfig, chartConfig)) {
				chart.chartType(chartConfig.type, chartConfig);
			} else if (isDataSourceUpdated(oldChartConfig, chartConfig)) {
				chart.setJSONData(chartConfig.dataSource);
			}
		}

		oldChartConfig = cloneObject(chartConfig);
	});

	onDestroy(() => {
		chart.dispose();

		Events.forEach((event, index) => {
			FroalaCharts.removeEventListener(event, eventListerners[index]);
		});
	});

	$$self.$$set = $$props => {
		if ("id" in $$props) $$invalidate(5, id = $$props.id);
		if ("className" in $$props) $$invalidate(0, className = $$props.className);
		if ("inlineStyle" in $$props) $$invalidate(1, inlineStyle = $$props.inlineStyle);
		if ("type" in $$props) $$invalidate(6, type = $$props.type);
		if ("renderAt" in $$props) $$invalidate(3, renderAt = $$props.renderAt);
		if ("width" in $$props) $$invalidate(7, width = $$props.width);
		if ("height" in $$props) $$invalidate(8, height = $$props.height);
		if ("dataFormat" in $$props) $$invalidate(9, dataFormat = $$props.dataFormat);
		if ("dataSource" in $$props) $$invalidate(10, dataSource = $$props.dataSource);
		if ("chart" in $$props) $$invalidate(4, chart = $$props.chart);
	};

	return [
		className,
		inlineStyle,
		uniqueDivId,
		renderAt,
		chart,
		id,
		type,
		width,
		height,
		dataFormat,
		dataSource
	];
}

class Src extends SvelteComponent {
	constructor(options) {
		super();

		init(this, options, instance, create_fragment, safe_not_equal, {
			id: 5,
			className: 0,
			inlineStyle: 1,
			type: 6,
			renderAt: 3,
			width: 7,
			height: 8,
			dataFormat: 9,
			dataSource: 10,
			chart: 4
		});
	}
}

export default Src;
export { fcRoot };