33891 lines
1.2 MiB
33891 lines
1.2 MiB
|
|
(function(l, i, v, e) { v = l.createElement(i); v.async = 1; v.src = '//' + (location.host || 'localhost').split(':')[0] + ':35729/livereload.js?snipver=1'; e = l.getElementsByTagName(i)[0]; e.parentNode.insertBefore(v, e)})(document, 'script');
|
|
(function (fp, shortid, _, compilerUtil, lunr, safeBuffer) {
|
|
'use strict';
|
|
|
|
var ___default = 'default' in _ ? _['default'] : _;
|
|
lunr = lunr && lunr.hasOwnProperty('default') ? lunr['default'] : lunr;
|
|
|
|
function noop() { }
|
|
function assign(tar, src) {
|
|
// @ts-ignore
|
|
for (const k in src)
|
|
tar[k] = src[k];
|
|
return tar;
|
|
}
|
|
function is_promise(value) {
|
|
return value && typeof value === 'object' && typeof value.then === 'function';
|
|
}
|
|
function add_location(element, file, line, column, char) {
|
|
element.__svelte_meta = {
|
|
loc: { file, line, column, char }
|
|
};
|
|
}
|
|
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 validate_store(store, name) {
|
|
if (!store || typeof store.subscribe !== 'function') {
|
|
throw new Error(`'${name}' is not a store with a 'subscribe' method`);
|
|
}
|
|
}
|
|
function subscribe(component, store, callback) {
|
|
const unsub = store.subscribe(callback);
|
|
component.$$.on_destroy.push(unsub.unsubscribe
|
|
? () => unsub.unsubscribe()
|
|
: unsub);
|
|
}
|
|
function create_slot(definition, ctx, fn) {
|
|
if (definition) {
|
|
const slot_ctx = get_slot_context(definition, ctx, fn);
|
|
return definition[0](slot_ctx);
|
|
}
|
|
}
|
|
function get_slot_context(definition, ctx, fn) {
|
|
return definition[1]
|
|
? assign({}, assign(ctx.$$scope.ctx, definition[1](fn ? fn(ctx) : {})))
|
|
: ctx.$$scope.ctx;
|
|
}
|
|
function get_slot_changes(definition, ctx, changed, fn) {
|
|
return definition[1]
|
|
? assign({}, assign(ctx.$$scope.changed || {}, definition[1](fn ? fn(changed) : {})))
|
|
: ctx.$$scope.changed || {};
|
|
}
|
|
|
|
function append(target, node) {
|
|
target.appendChild(node);
|
|
}
|
|
function insert(target, node, anchor) {
|
|
target.insertBefore(node, anchor || null);
|
|
}
|
|
function detach(node) {
|
|
node.parentNode.removeChild(node);
|
|
}
|
|
function detach_before(after) {
|
|
while (after.previousSibling) {
|
|
after.parentNode.removeChild(after.previousSibling);
|
|
}
|
|
}
|
|
function destroy_each(iterations, detaching) {
|
|
for (let i = 0; i < iterations.length; i += 1) {
|
|
if (iterations[i])
|
|
iterations[i].d(detaching);
|
|
}
|
|
}
|
|
function element(name) {
|
|
return document.createElement(name);
|
|
}
|
|
function text(data) {
|
|
return document.createTextNode(data);
|
|
}
|
|
function space() {
|
|
return text(' ');
|
|
}
|
|
function empty() {
|
|
return text('');
|
|
}
|
|
function listen(node, event, handler, options) {
|
|
node.addEventListener(event, handler, options);
|
|
return () => node.removeEventListener(event, handler, options);
|
|
}
|
|
function stop_propagation(fn) {
|
|
return function (event) {
|
|
event.stopPropagation();
|
|
// @ts-ignore
|
|
return fn.call(this, event);
|
|
};
|
|
}
|
|
function attr(node, attribute, value) {
|
|
if (value == null)
|
|
node.removeAttribute(attribute);
|
|
else
|
|
node.setAttribute(attribute, value);
|
|
}
|
|
function children(element) {
|
|
return Array.from(element.childNodes);
|
|
}
|
|
function set_data(text, data) {
|
|
data = '' + data;
|
|
if (text.data !== data)
|
|
text.data = data;
|
|
}
|
|
function set_style(node, key, value) {
|
|
node.style.setProperty(key, value);
|
|
}
|
|
function select_option(select, value) {
|
|
for (let i = 0; i < select.options.length; i += 1) {
|
|
const option = select.options[i];
|
|
if (option.__value === value) {
|
|
option.selected = true;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
function select_options(select, value) {
|
|
for (let i = 0; i < select.options.length; i += 1) {
|
|
const option = select.options[i];
|
|
option.selected = ~value.indexOf(option.__value);
|
|
}
|
|
}
|
|
function select_value(select) {
|
|
const selected_option = select.querySelector(':checked') || select.options[0];
|
|
return selected_option && selected_option.__value;
|
|
}
|
|
function select_multiple_value(select) {
|
|
return [].map.call(select.querySelectorAll(':checked'), option => option.__value);
|
|
}
|
|
|
|
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 onMount(fn) {
|
|
get_current_component().$$.on_mount.push(fn);
|
|
}
|
|
// TODO figure out if we still want to support
|
|
// shorthand events, or if we want to implement
|
|
// a real bubbling mechanism
|
|
function bubble(component, event) {
|
|
const callbacks = component.$$.callbacks[event.type];
|
|
if (callbacks) {
|
|
callbacks.slice().forEach(fn => fn(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);
|
|
}
|
|
function add_flush_callback(fn) {
|
|
flush_callbacks.push(fn);
|
|
}
|
|
function flush() {
|
|
const seen_callbacks = new Set();
|
|
do {
|
|
// first, call beforeUpdate functions
|
|
// and update components
|
|
while (dirty_components.length) {
|
|
const component = dirty_components.shift();
|
|
set_current_component(component);
|
|
update(component.$$);
|
|
}
|
|
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)) {
|
|
callback();
|
|
// ...so guard against infinite loops
|
|
seen_callbacks.add(callback);
|
|
}
|
|
}
|
|
render_callbacks.length = 0;
|
|
} while (dirty_components.length);
|
|
while (flush_callbacks.length) {
|
|
flush_callbacks.pop()();
|
|
}
|
|
update_scheduled = false;
|
|
}
|
|
function update($$) {
|
|
if ($$.fragment) {
|
|
$$.update($$.dirty);
|
|
run_all($$.before_update);
|
|
$$.fragment.p($$.dirty, $$.ctx);
|
|
$$.dirty = null;
|
|
$$.after_update.forEach(add_render_callback);
|
|
}
|
|
}
|
|
const outroing = new Set();
|
|
let outros;
|
|
function group_outros() {
|
|
outros = {
|
|
r: 0,
|
|
c: [],
|
|
p: outros // parent group
|
|
};
|
|
}
|
|
function check_outros() {
|
|
if (!outros.r) {
|
|
run_all(outros.c);
|
|
}
|
|
outros = outros.p;
|
|
}
|
|
function transition_in(block, local) {
|
|
if (block && block.i) {
|
|
outroing.delete(block);
|
|
block.i(local);
|
|
}
|
|
}
|
|
function transition_out(block, local, detach, callback) {
|
|
if (block && block.o) {
|
|
if (outroing.has(block))
|
|
return;
|
|
outroing.add(block);
|
|
outros.c.push(() => {
|
|
outroing.delete(block);
|
|
if (callback) {
|
|
if (detach)
|
|
block.d(1);
|
|
callback();
|
|
}
|
|
});
|
|
block.o(local);
|
|
}
|
|
}
|
|
|
|
function handle_promise(promise, info) {
|
|
const token = info.token = {};
|
|
function update(type, index, key, value) {
|
|
if (info.token !== token)
|
|
return;
|
|
info.resolved = key && { [key]: value };
|
|
const child_ctx = assign(assign({}, info.ctx), info.resolved);
|
|
const block = type && (info.current = type)(child_ctx);
|
|
if (info.block) {
|
|
if (info.blocks) {
|
|
info.blocks.forEach((block, i) => {
|
|
if (i !== index && block) {
|
|
group_outros();
|
|
transition_out(block, 1, 1, () => {
|
|
info.blocks[i] = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
});
|
|
}
|
|
else {
|
|
info.block.d(1);
|
|
}
|
|
block.c();
|
|
transition_in(block, 1);
|
|
block.m(info.mount(), info.anchor);
|
|
flush();
|
|
}
|
|
info.block = block;
|
|
if (info.blocks)
|
|
info.blocks[index] = block;
|
|
}
|
|
if (is_promise(promise)) {
|
|
promise.then(value => {
|
|
update(info.then, 1, info.value, value);
|
|
}, error => {
|
|
update(info.catch, 2, info.error, error);
|
|
});
|
|
// if we previously had a then/catch block, destroy it
|
|
if (info.current !== info.pending) {
|
|
update(info.pending, 0);
|
|
return true;
|
|
}
|
|
}
|
|
else {
|
|
if (info.current !== info.then) {
|
|
update(info.then, 1, info.value, promise);
|
|
return true;
|
|
}
|
|
info.resolved = { [info.value]: promise };
|
|
}
|
|
}
|
|
|
|
function bind(component, name, callback) {
|
|
if (component.$$.props.indexOf(name) === -1)
|
|
return;
|
|
component.$$.bound[name] = callback;
|
|
callback(component.$$.ctx[name]);
|
|
}
|
|
function mount_component(component, target, anchor) {
|
|
const { fragment, on_mount, on_destroy, after_update } = component.$$;
|
|
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) {
|
|
if (component.$$.fragment) {
|
|
run_all(component.$$.on_destroy);
|
|
component.$$.fragment.d(detaching);
|
|
// TODO null out other refs, including component.$$ (but need to
|
|
// preserve final state?)
|
|
component.$$.on_destroy = component.$$.fragment = null;
|
|
component.$$.ctx = {};
|
|
}
|
|
}
|
|
function make_dirty(component, key) {
|
|
if (!component.$$.dirty) {
|
|
dirty_components.push(component);
|
|
schedule_update();
|
|
component.$$.dirty = blank_object();
|
|
}
|
|
component.$$.dirty[key] = true;
|
|
}
|
|
function init(component, options, instance, create_fragment, not_equal, prop_names) {
|
|
const parent_component = current_component;
|
|
set_current_component(component);
|
|
const props = options.props || {};
|
|
const $$ = component.$$ = {
|
|
fragment: null,
|
|
ctx: null,
|
|
// state
|
|
props: prop_names,
|
|
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: null
|
|
};
|
|
let ready = false;
|
|
$$.ctx = instance
|
|
? instance(component, props, (key, value) => {
|
|
if ($$.ctx && not_equal($$.ctx[key], $$.ctx[key] = value)) {
|
|
if ($$.bound[key])
|
|
$$.bound[key](value);
|
|
if (ready)
|
|
make_dirty(component, key);
|
|
}
|
|
})
|
|
: props;
|
|
$$.update();
|
|
ready = true;
|
|
run_all($$.before_update);
|
|
$$.fragment = create_fragment($$.ctx);
|
|
if (options.target) {
|
|
if (options.hydrate) {
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
$$.fragment.l(children(options.target));
|
|
}
|
|
else {
|
|
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
|
|
$$.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() {
|
|
// overridden by instance, if it has props
|
|
}
|
|
}
|
|
class SvelteComponentDev extends SvelteComponent {
|
|
constructor(options) {
|
|
if (!options || (!options.target && !options.$$inline)) {
|
|
throw new Error(`'target' is a required option`);
|
|
}
|
|
super();
|
|
}
|
|
$destroy() {
|
|
super.$destroy();
|
|
this.$destroy = () => {
|
|
console.warn(`Component was already destroyed`); // eslint-disable-line no-console
|
|
};
|
|
}
|
|
}
|
|
|
|
/* src\common\Button.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file = "src\\common\\Button.svelte";
|
|
|
|
function create_fragment(ctx) {
|
|
var button, button_class_value, current, dispose;
|
|
|
|
const default_slot_1 = ctx.$$slots.default;
|
|
const default_slot = create_slot(default_slot_1, ctx, null);
|
|
|
|
return {
|
|
c: function create() {
|
|
button = element("button");
|
|
|
|
if (default_slot) default_slot.c();
|
|
|
|
attr(button, "class", button_class_value = "" + ctx.color + " " + ctx.className + " " + ctx.borderClass + " " + (ctx.grouped ? "grouped" : "") + " svelte-7rfkdx");
|
|
attr(button, "style", ctx.style);
|
|
add_location(button, file, 14, 0, 260);
|
|
dispose = listen(button, "click", ctx.click_handler);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
if (default_slot) default_slot.l(button_nodes);
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, button, anchor);
|
|
|
|
if (default_slot) {
|
|
default_slot.m(button, null);
|
|
}
|
|
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (default_slot && default_slot.p && changed.$$scope) {
|
|
default_slot.p(get_slot_changes(default_slot_1, ctx, changed, null), get_slot_context(default_slot_1, ctx, null));
|
|
}
|
|
|
|
if ((!current || changed.color || changed.className || changed.borderClass || changed.grouped) && button_class_value !== (button_class_value = "" + ctx.color + " " + ctx.className + " " + ctx.borderClass + " " + (ctx.grouped ? "grouped" : "") + " svelte-7rfkdx")) {
|
|
attr(button, "class", button_class_value);
|
|
}
|
|
|
|
if (!current || changed.style) {
|
|
attr(button, "style", ctx.style);
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(button);
|
|
}
|
|
|
|
if (default_slot) default_slot.d(detaching);
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance($$self, $$props, $$invalidate) {
|
|
let { color = "primary", className = "", style = "", groupPosition = "", grouped = false } = $$props;
|
|
|
|
const writable_props = ['color', 'className', 'style', 'groupPosition', 'grouped'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Button> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
let { $$slots = {}, $$scope } = $$props;
|
|
|
|
function click_handler(event) {
|
|
bubble($$self, event);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('color' in $$props) $$invalidate('color', color = $$props.color);
|
|
if ('className' in $$props) $$invalidate('className', className = $$props.className);
|
|
if ('style' in $$props) $$invalidate('style', style = $$props.style);
|
|
if ('groupPosition' in $$props) $$invalidate('groupPosition', groupPosition = $$props.groupPosition);
|
|
if ('grouped' in $$props) $$invalidate('grouped', grouped = $$props.grouped);
|
|
if ('$$scope' in $$props) $$invalidate('$$scope', $$scope = $$props.$$scope);
|
|
};
|
|
|
|
let borderClass;
|
|
|
|
$$self.$$.update = ($$dirty = { grouped: 1 }) => {
|
|
if ($$dirty.grouped) { $$invalidate('borderClass', borderClass = grouped
|
|
? ""
|
|
: "border-normal"); }
|
|
};
|
|
|
|
return {
|
|
color,
|
|
className,
|
|
style,
|
|
groupPosition,
|
|
grouped,
|
|
borderClass,
|
|
click_handler,
|
|
$$slots,
|
|
$$scope
|
|
};
|
|
}
|
|
|
|
class Button extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance, create_fragment, safe_not_equal, ["color", "className", "style", "groupPosition", "grouped"]);
|
|
}
|
|
|
|
get color() {
|
|
throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set color(value) {
|
|
throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get className() {
|
|
throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set className(value) {
|
|
throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get style() {
|
|
throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set style(value) {
|
|
throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get groupPosition() {
|
|
throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set groupPosition(value) {
|
|
throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get grouped() {
|
|
throw new Error("<Button>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set grouped(value) {
|
|
throw new Error("<Button>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
const commonPlus = extra => fp.union(['onBegin', 'onComplete', 'onError'])(extra);
|
|
|
|
const common = () => commonPlus([]);
|
|
|
|
const _events = {
|
|
recordApi: {
|
|
save: commonPlus([
|
|
'onInvalid',
|
|
'onRecordUpdated',
|
|
'onRecordCreated']),
|
|
delete: common(),
|
|
getContext: common(),
|
|
getNew: common(),
|
|
load: common(),
|
|
validate: common(),
|
|
uploadFile: common(),
|
|
downloadFile: common(),
|
|
},
|
|
indexApi: {
|
|
buildIndex: common(),
|
|
listItems: common(),
|
|
delete: common(),
|
|
aggregates: common(),
|
|
},
|
|
collectionApi: {
|
|
getAllowedRecordTypes: common(),
|
|
initialise: common(),
|
|
delete: common(),
|
|
},
|
|
authApi: {
|
|
authenticate: common(),
|
|
authenticateTemporaryAccess: common(),
|
|
createTemporaryAccess: common(),
|
|
createUser: common(),
|
|
enableUser: common(),
|
|
disableUser: common(),
|
|
loadAccessLevels: common(),
|
|
getNewAccessLevel: common(),
|
|
getNewUser: common(),
|
|
getNewUserAuth: common(),
|
|
getUsers: common(),
|
|
saveAccessLevels: common(),
|
|
isAuthorized: common(),
|
|
changeMyPassword: common(),
|
|
setPasswordFromTemporaryCode: common(),
|
|
scorePassword: common(),
|
|
isValidPassword: common(),
|
|
validateUser: common(),
|
|
validateAccessLevels: common(),
|
|
setUserAccessLevels: common(),
|
|
},
|
|
templateApi: {
|
|
saveApplicationHierarchy: common(),
|
|
saveActionsAndTriggers: common(),
|
|
},
|
|
actionsApi: {
|
|
execute: common(),
|
|
},
|
|
};
|
|
|
|
const _eventsList = [];
|
|
|
|
const makeEvent = (area, method, name) => `${area}:${method}:${name}`;
|
|
|
|
for (const areaKey in _events) {
|
|
for (const methodKey in _events[areaKey]) {
|
|
_events[areaKey][methodKey] = fp.reduce((obj, s) => {
|
|
obj[s] = makeEvent(areaKey, methodKey, s);
|
|
return obj;
|
|
},
|
|
{})(_events[areaKey][methodKey]);
|
|
}
|
|
}
|
|
|
|
|
|
for (const areaKey in _events) {
|
|
for (const methodKey in _events[areaKey]) {
|
|
for (const name in _events[areaKey][methodKey]) {
|
|
_eventsList.push(
|
|
_events[areaKey][methodKey][name],
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
const events = _events;
|
|
|
|
const eventsList = _eventsList;
|
|
|
|
class BadRequestError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.httpStatusCode = 400;
|
|
}
|
|
}
|
|
|
|
class UnauthorisedError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.httpStatusCode = 401;
|
|
}
|
|
}
|
|
|
|
class NotFoundError extends Error {
|
|
constructor(message) {
|
|
super(message);
|
|
this.httpStatusCode = 404;
|
|
}
|
|
}
|
|
|
|
const apiWrapper = async (app, eventNamespace, isAuthorized, eventContext, func, ...params) => {
|
|
pushCallStack(app, eventNamespace);
|
|
|
|
if (!isAuthorized(app)) {
|
|
handleNotAuthorized(app, eventContext, eventNamespace);
|
|
return;
|
|
}
|
|
|
|
const startDate = Date.now();
|
|
const elapsed = () => (Date.now() - startDate);
|
|
|
|
try {
|
|
await app.publish(
|
|
eventNamespace.onBegin,
|
|
eventContext,
|
|
);
|
|
|
|
const result = await func(...params);
|
|
|
|
await publishComplete(app, eventContext, eventNamespace, elapsed, result);
|
|
return result;
|
|
} catch (error) {
|
|
await publishError(app, eventContext, eventNamespace, elapsed, error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
const apiWrapperSync = (app, eventNamespace, isAuthorized, eventContext, func, ...params) => {
|
|
pushCallStack(app, eventNamespace);
|
|
|
|
if (!isAuthorized(app)) {
|
|
handleNotAuthorized(app, eventContext, eventNamespace);
|
|
return;
|
|
}
|
|
|
|
const startDate = Date.now();
|
|
const elapsed = () => (Date.now() - startDate);
|
|
|
|
try {
|
|
app.publish(
|
|
eventNamespace.onBegin,
|
|
eventContext,
|
|
);
|
|
|
|
const result = func(...params);
|
|
|
|
publishComplete(app, eventContext, eventNamespace, elapsed, result);
|
|
return result;
|
|
} catch (error) {
|
|
publishError(app, eventContext, eventNamespace, elapsed, error);
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
const handleNotAuthorized = (app, eventContext, eventNamespace) => {
|
|
const err = new UnauthorisedError(`Unauthorized: ${eventNamespace}`);
|
|
publishError(app, eventContext, eventNamespace, () => 0, err);
|
|
throw err;
|
|
};
|
|
|
|
const pushCallStack = (app, eventNamespace, seedCallId) => {
|
|
const callId = shortid.generate();
|
|
|
|
const createCallStack = () => ({
|
|
seedCallId: !fp.isUndefined(seedCallId)
|
|
? seedCallId
|
|
: callId,
|
|
threadCallId: callId,
|
|
stack: [],
|
|
});
|
|
|
|
if (fp.isUndefined(app.calls)) {
|
|
app.calls = createCallStack();
|
|
}
|
|
|
|
app.calls.stack.push({
|
|
namespace: eventNamespace,
|
|
callId,
|
|
});
|
|
};
|
|
|
|
const popCallStack = (app) => {
|
|
app.calls.stack.pop();
|
|
if (app.calls.stack.length === 0) {
|
|
delete app.calls;
|
|
}
|
|
};
|
|
|
|
const publishError = async (app, eventContext, eventNamespace, elapsed, err) => {
|
|
const ctx = fp.cloneDeep(eventContext);
|
|
ctx.error = err;
|
|
ctx.elapsed = elapsed();
|
|
await app.publish(
|
|
eventNamespace.onError,
|
|
ctx,
|
|
);
|
|
popCallStack(app);
|
|
};
|
|
|
|
const publishComplete = async (app, eventContext, eventNamespace, elapsed, result) => {
|
|
const endcontext = fp.cloneDeep(eventContext);
|
|
endcontext.result = result;
|
|
endcontext.elapsed = elapsed();
|
|
await app.publish(
|
|
eventNamespace.onComplete,
|
|
endcontext,
|
|
);
|
|
popCallStack(app);
|
|
return result;
|
|
};
|
|
|
|
const lockOverlapMilliseconds = 10;
|
|
|
|
const getLock = async (app, lockFile, timeoutMilliseconds, maxLockRetries, retryCount = 0) => {
|
|
try {
|
|
const timeout = (await app.getEpochTime())
|
|
+ timeoutMilliseconds;
|
|
|
|
const lock = {
|
|
timeout,
|
|
key: lockFile,
|
|
totalTimeout: timeoutMilliseconds,
|
|
};
|
|
|
|
await app.datastore.createFile(
|
|
lockFile,
|
|
getLockFileContent(
|
|
lock.totalTimeout,
|
|
lock.timeout,
|
|
),
|
|
);
|
|
|
|
return lock;
|
|
} catch (e) {
|
|
if (retryCount == maxLockRetries) { return NO_LOCK; }
|
|
|
|
const lock = parseLockFileContent(
|
|
lockFile,
|
|
await app.datastore.loadFile(lockFile),
|
|
);
|
|
|
|
const currentEpochTime = await app.getEpochTime();
|
|
|
|
if (currentEpochTime < lock.timeout) {
|
|
return NO_LOCK;
|
|
}
|
|
|
|
try {
|
|
await app.datastore.deleteFile(lockFile);
|
|
} catch (_) {
|
|
//empty
|
|
}
|
|
|
|
await sleepForRetry();
|
|
|
|
return await getLock(
|
|
app, lockFile, timeoutMilliseconds,
|
|
maxLockRetries, retryCount + 1,
|
|
);
|
|
}
|
|
};
|
|
|
|
const getLockFileContent = (totalTimeout, epochTime) => `${totalTimeout}:${epochTime.toString()}`;
|
|
|
|
const parseLockFileContent = (key, content) => $(content, [
|
|
fp.split(':'),
|
|
parts => ({
|
|
totalTimeout: new Number(parts[0]),
|
|
timeout: new Number(parts[1]),
|
|
key,
|
|
}),
|
|
]);
|
|
|
|
const releaseLock = async (app, lock) => {
|
|
const currentEpochTime = await app.getEpochTime();
|
|
// only release if not timedout
|
|
if (currentEpochTime < (lock.timeout - lockOverlapMilliseconds)) {
|
|
try {
|
|
await app.datastore.deleteFile(lock.key);
|
|
} catch (_) {
|
|
//empty
|
|
}
|
|
}
|
|
};
|
|
|
|
const NO_LOCK = 'no lock';
|
|
const isNolock = id => id === NO_LOCK;
|
|
|
|
const sleepForRetry = () => new Promise(resolve => setTimeout(resolve, lockOverlapMilliseconds));
|
|
|
|
// this is the combinator function
|
|
const $$ = (...funcs) => arg => _.flow(funcs)(arg);
|
|
|
|
// this is the pipe function
|
|
const $ = (arg, funcs) => $$(...funcs)(arg);
|
|
|
|
const keySep = '/';
|
|
const trimKeySep = str => _.trim(str, keySep);
|
|
const splitByKeySep = str => _.split(str, keySep);
|
|
const safeKey = key => _.replace(`${keySep}${trimKeySep(key)}`, `${keySep}${keySep}`, keySep);
|
|
const joinKey = (...strs) => {
|
|
const paramsOrArray = strs.length === 1 & _.isArray(strs[0])
|
|
? strs[0] : strs;
|
|
return safeKey(_.join(paramsOrArray, keySep));
|
|
};
|
|
const splitKey = $$(trimKeySep, splitByKeySep);
|
|
const getDirFomKey = $$(splitKey, _.dropRight, p => joinKey(...p));
|
|
const getFileFromKey = $$(splitKey, _.takeRight, _.head);
|
|
|
|
const configFolder = `${keySep}.config`;
|
|
const fieldDefinitions = joinKey(configFolder, 'fields.json');
|
|
const templateDefinitions = joinKey(configFolder, 'templates.json');
|
|
const appDefinitionFile = joinKey(configFolder, 'appDefinition.json');
|
|
const dirIndex = folderPath => joinKey(configFolder, 'dir', ...splitKey(folderPath), 'dir.idx');
|
|
const getIndexKeyFromFileKey = $$(getDirFomKey, dirIndex);
|
|
|
|
const ifExists = (val, exists, notExists) => (_.isUndefined(val)
|
|
? _.isUndefined(notExists) ? (() => { })() : notExists()
|
|
: exists());
|
|
|
|
const getOrDefault = (val, defaultVal) => ifExists(val, () => val, () => defaultVal);
|
|
|
|
const not = func => val => !func(val);
|
|
const isDefined = not(_.isUndefined);
|
|
const isNonNull = not(_.isNull);
|
|
const isNotNaN = not(_.isNaN);
|
|
|
|
const allTrue = (...funcArgs) => val => _.reduce(funcArgs,
|
|
(result, conditionFunc) => (_.isNull(result) || result == true) && conditionFunc(val),
|
|
null);
|
|
|
|
const anyTrue = (...funcArgs) => val => _.reduce(funcArgs,
|
|
(result, conditionFunc) => result == true || conditionFunc(val),
|
|
null);
|
|
|
|
const insensitiveEquals = (str1, str2) => str1.trim().toLowerCase() === str2.trim().toLowerCase();
|
|
|
|
const isSomething = allTrue(isDefined, isNonNull, isNotNaN);
|
|
const isNothing = not(isSomething);
|
|
const isNothingOrEmpty = v => isNothing(v) || _.isEmpty(v);
|
|
const somethingOrGetDefault = getDefaultFunc => val => (isSomething(val) ? val : getDefaultFunc());
|
|
const somethingOrDefault = (val, defaultVal) => somethingOrGetDefault(_.constant(defaultVal))(val);
|
|
|
|
const mapIfSomethingOrDefault = (mapFunc, defaultVal) => val => (isSomething(val) ? mapFunc(val) : defaultVal);
|
|
|
|
const mapIfSomethingOrBlank = mapFunc => mapIfSomethingOrDefault(mapFunc, '');
|
|
|
|
const none = predicate => collection => !fp.some(predicate)(collection);
|
|
|
|
const all = predicate => collection => none(v => !predicate(v))(collection);
|
|
|
|
const isNotEmpty = ob => !_.isEmpty(ob);
|
|
const isNonEmptyArray = allTrue(_.isArray, isNotEmpty);
|
|
const isNonEmptyString = allTrue(_.isString, isNotEmpty);
|
|
const tryOr = failFunc => (func, ...args) => {
|
|
try {
|
|
return func.apply(null, ...args);
|
|
} catch (_) {
|
|
return failFunc();
|
|
}
|
|
};
|
|
|
|
const tryAwaitOr = failFunc => async (func, ...args) => {
|
|
try {
|
|
return await func.apply(null, ...args);
|
|
} catch (_) {
|
|
return await failFunc();
|
|
}
|
|
};
|
|
|
|
const defineError = (func, errorPrefix) => {
|
|
try {
|
|
return func();
|
|
} catch (err) {
|
|
err.message = `${errorPrefix} : ${err.message}`;
|
|
throw err;
|
|
}
|
|
};
|
|
|
|
const tryOrIgnore = tryOr(() => { });
|
|
const tryAwaitOrIgnore = tryAwaitOr(async () => { });
|
|
const causesException = (func) => {
|
|
try {
|
|
func();
|
|
return false;
|
|
} catch (e) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
const executesWithoutException = func => !causesException(func);
|
|
|
|
const handleErrorWith = returnValInError => tryOr(_.constant(returnValInError));
|
|
|
|
const handleErrorWithUndefined = handleErrorWith(undefined);
|
|
|
|
const switchCase = (...cases) => (value) => {
|
|
const nextCase = () => _.head(cases)[0](value);
|
|
const nextResult = () => _.head(cases)[1](value);
|
|
|
|
if (_.isEmpty(cases)) return; // undefined
|
|
if (nextCase() === true) return nextResult();
|
|
return switchCase(..._.tail(cases))(value);
|
|
};
|
|
|
|
const isValue = val1 => val2 => (val1 === val2);
|
|
const isOneOf = (...vals) => val => _.includes(vals, val);
|
|
const defaultCase = _.constant(true);
|
|
const memberMatches = (member, match) => obj => match(obj[member]);
|
|
|
|
|
|
const StartsWith = searchFor => searchIn => _.startsWith(searchIn, searchFor);
|
|
|
|
const contains = val => array => (_.findIndex(array, v => v === val) > -1);
|
|
|
|
const getHashCode = (s) => {
|
|
let hash = 0; let i; let char; let
|
|
l;
|
|
if (s.length == 0) return hash;
|
|
for (i = 0, l = s.length; i < l; i++) {
|
|
char = s.charCodeAt(i);
|
|
hash = ((hash << 5) - hash) + char;
|
|
hash |= 0; // Convert to 32bit integer
|
|
}
|
|
|
|
// converting to string, but dont want a "-" prefixed
|
|
if (hash < 0) { return `n${(hash * -1).toString()}`; }
|
|
return hash.toString();
|
|
};
|
|
|
|
// thanks to https://blog.grossman.io/how-to-write-async-await-without-try-catch-blocks-in-javascript/
|
|
const awEx = async (promise) => {
|
|
try {
|
|
const result = await promise;
|
|
return [undefined, result];
|
|
} catch (error) {
|
|
return [error, undefined];
|
|
}
|
|
};
|
|
|
|
const isSafeInteger = n => _.isInteger(n)
|
|
&& n <= Number.MAX_SAFE_INTEGER
|
|
&& n >= 0 - Number.MAX_SAFE_INTEGER;
|
|
|
|
const toDateOrNull = s => (_.isNull(s) ? null
|
|
: _.isDate(s) ? s : new Date(s));
|
|
const toBoolOrNull = s => (_.isNull(s) ? null
|
|
: s === 'true' || s === true);
|
|
const toNumberOrNull = s => (_.isNull(s) ? null
|
|
: _.toNumber(s));
|
|
|
|
const isArrayOfString = opts => _.isArray(opts) && all(_.isString)(opts);
|
|
|
|
const pause = async duration => new Promise(res => setTimeout(res, duration));
|
|
|
|
const retry = async (fn, retries, delay, ...args) => {
|
|
try {
|
|
return await fn(...args);
|
|
} catch (err) {
|
|
if (retries > 1) {
|
|
return await pause(delay).then(async () => await retry(fn, (retries - 1), delay, ...args));
|
|
}
|
|
throw err;
|
|
}
|
|
};
|
|
|
|
var index = {
|
|
ifExists,
|
|
getOrDefault,
|
|
isDefined,
|
|
isNonNull,
|
|
isNotNaN,
|
|
allTrue,
|
|
isSomething,
|
|
mapIfSomethingOrDefault,
|
|
mapIfSomethingOrBlank,
|
|
configFolder,
|
|
fieldDefinitions,
|
|
isNothing,
|
|
not,
|
|
switchCase,
|
|
defaultCase,
|
|
StartsWith,
|
|
contains,
|
|
templateDefinitions,
|
|
handleErrorWith,
|
|
handleErrorWithUndefined,
|
|
tryOr,
|
|
tryOrIgnore,
|
|
tryAwaitOr,
|
|
tryAwaitOrIgnore,
|
|
dirIndex,
|
|
keySep,
|
|
$,
|
|
$$,
|
|
getDirFomKey,
|
|
getFileFromKey,
|
|
splitKey,
|
|
somethingOrDefault,
|
|
getIndexKeyFromFileKey,
|
|
joinKey,
|
|
somethingOrGetDefault,
|
|
appDefinitionFile,
|
|
isValue,
|
|
all,
|
|
isOneOf,
|
|
memberMatches,
|
|
defineError,
|
|
anyTrue,
|
|
isNonEmptyArray,
|
|
causesException,
|
|
executesWithoutException,
|
|
none,
|
|
getHashCode,
|
|
awEx,
|
|
apiWrapper,
|
|
events,
|
|
eventsList,
|
|
isNothingOrEmpty,
|
|
isSafeInteger,
|
|
toNumber: _.toNumber,
|
|
toDate: toDateOrNull,
|
|
toBool: toBoolOrNull,
|
|
isArrayOfString,
|
|
getLock,
|
|
NO_LOCK,
|
|
isNolock,
|
|
insensitiveEquals,
|
|
pause,
|
|
retry,
|
|
};
|
|
|
|
const stringNotEmpty = s => isSomething(s) && s.trim().length > 0;
|
|
|
|
const makerule = (field, error, isValid) => ({ field, error, isValid });
|
|
|
|
const validationError = (rule, item) => ({ ...rule, item });
|
|
|
|
const applyRuleSet = ruleSet => itemToValidate => $(ruleSet, [
|
|
fp.map(applyRule(itemToValidate)),
|
|
fp.filter(isSomething),
|
|
]);
|
|
|
|
const applyRule = itemTovalidate => rule => (rule.isValid(itemTovalidate)
|
|
? null
|
|
: validationError(rule, itemTovalidate));
|
|
|
|
const compileFilter = index => compilerUtil.compileExpression(index.filter);
|
|
|
|
const compileMap = index => compilerUtil.compileCode(index.map);
|
|
|
|
const indexTypes = { reference: 'reference', ancestor: 'ancestor' };
|
|
|
|
const indexRuleSet = [
|
|
makerule('map', 'index has no map function',
|
|
index => isNonEmptyString(index.map)),
|
|
makerule('map', "index's map function does not compile",
|
|
index => !isNonEmptyString(index.map)
|
|
|| executesWithoutException(() => compileMap(index))),
|
|
makerule('filter', "index's filter function does not compile",
|
|
index => !isNonEmptyString(index.filter)
|
|
|| executesWithoutException(() => compileFilter(index))),
|
|
makerule('name', 'must declare a name for index',
|
|
index => isNonEmptyString(index.name)),
|
|
makerule('name', 'there is a duplicate named index on this node',
|
|
index => fp.isEmpty(index.name)
|
|
|| fp.countBy('name')(index.parent().indexes)[index.name] === 1),
|
|
makerule('indexType', 'reference index may only exist on a record node',
|
|
index => isRecord(index.parent())
|
|
|| index.indexType !== indexTypes.reference),
|
|
makerule('indexType', `index type must be one of: ${_.join(', ', _.keys(indexTypes))}`,
|
|
index => fp.includes(index.indexType)(_.keys(indexTypes))),
|
|
];
|
|
|
|
const getFlattenedHierarchy = (appHierarchy, useCached = true) => {
|
|
if (isSomething(appHierarchy.getFlattenedHierarchy) && useCached) { return appHierarchy.getFlattenedHierarchy(); }
|
|
|
|
const flattenHierarchy = (currentNode, flattened) => {
|
|
flattened.push(currentNode);
|
|
if ((!currentNode.children
|
|
|| currentNode.children.length === 0)
|
|
&& (!currentNode.indexes
|
|
|| currentNode.indexes.length === 0)
|
|
&& (!currentNode.aggregateGroups
|
|
|| currentNode.aggregateGroups.length === 0)) {
|
|
return flattened;
|
|
}
|
|
|
|
const unionIfAny = l2 => l1 => fp.union(l1)(!l2 ? [] : l2);
|
|
|
|
const children = $([], [
|
|
unionIfAny(currentNode.children),
|
|
unionIfAny(currentNode.indexes),
|
|
unionIfAny(currentNode.aggregateGroups),
|
|
]);
|
|
|
|
for (const child of children) {
|
|
flattenHierarchy(child, flattened);
|
|
}
|
|
return flattened;
|
|
};
|
|
|
|
appHierarchy.getFlattenedHierarchy = () => flattenHierarchy(appHierarchy, []);
|
|
return appHierarchy.getFlattenedHierarchy();
|
|
};
|
|
|
|
const getLastPartInKey = key => fp.last(splitKey(key));
|
|
|
|
const getNodesInPath = appHierarchy => key => $(appHierarchy, [
|
|
getFlattenedHierarchy,
|
|
fp.filter(n => new RegExp(`${n.pathRegx()}`).test(key)),
|
|
]);
|
|
|
|
const getExactNodeForPath = appHierarchy => key => $(appHierarchy, [
|
|
getFlattenedHierarchy,
|
|
fp.find(n => new RegExp(`${n.pathRegx()}$`).test(key)),
|
|
]);
|
|
|
|
const hasMatchingAncestor = ancestorPredicate => decendantNode => switchCase(
|
|
|
|
[node => isNothing(node.parent()),
|
|
fp.constant(false)],
|
|
|
|
[node => ancestorPredicate(node.parent()),
|
|
fp.constant(true)],
|
|
|
|
[defaultCase,
|
|
node => hasMatchingAncestor(ancestorPredicate)(node.parent())],
|
|
|
|
)(decendantNode);
|
|
|
|
const getNode = (appHierarchy, nodeKey) => $(appHierarchy, [
|
|
getFlattenedHierarchy,
|
|
fp.find(n => n.nodeKey() === nodeKey
|
|
|| (isCollectionRecord(n)
|
|
&& n.collectionNodeKey() === nodeKey)),
|
|
]);
|
|
|
|
const getNodeByKeyOrNodeKey = (appHierarchy, keyOrNodeKey) => {
|
|
const nodeByKey = getExactNodeForPath(appHierarchy)(keyOrNodeKey);
|
|
return isNothing(nodeByKey)
|
|
? getNode(appHierarchy, keyOrNodeKey)
|
|
: nodeByKey;
|
|
};
|
|
|
|
const isNode = (appHierarchy, key) => isSomething(getExactNodeForPath(appHierarchy)(key));
|
|
|
|
const getActualKeyOfParent = (parentNodeKey, actualChildKey) => $(actualChildKey, [
|
|
splitKey,
|
|
fp.take(splitKey(parentNodeKey).length),
|
|
ks => joinKey(...ks),
|
|
]);
|
|
|
|
const getParentKey = (key) => {
|
|
return $(key, [
|
|
splitKey,
|
|
fp.take(splitKey(key).length - 1),
|
|
joinKey,
|
|
]);
|
|
};
|
|
|
|
const isKeyAncestorOf = ancestorKey => decendantNode => hasMatchingAncestor(p => p.nodeKey() === ancestorKey)(decendantNode);
|
|
|
|
const hasNoMatchingAncestors = parentPredicate => node => !hasMatchingAncestor(parentPredicate)(node);
|
|
|
|
const findField = (recordNode, fieldName) => fp.find(f => f.name == fieldName)(recordNode.fields);
|
|
|
|
const isAncestor = decendant => ancestor => isKeyAncestorOf(ancestor.nodeKey())(decendant);
|
|
|
|
const isDecendant = ancestor => decendant => isAncestor(decendant)(ancestor);
|
|
|
|
const getRecordNodeId = recordKey => $(recordKey, [
|
|
splitKey,
|
|
fp.last,
|
|
getRecordNodeIdFromId,
|
|
]);
|
|
|
|
const getRecordNodeIdFromId = recordId => $(recordId, [fp.split('-'), fp.first, parseInt]);
|
|
|
|
const getRecordNodeById = (hierarchy, recordId) => $(hierarchy, [
|
|
getFlattenedHierarchy,
|
|
fp.find(n => isRecord(n)
|
|
&& n.nodeId === getRecordNodeIdFromId(recordId)),
|
|
]);
|
|
|
|
const recordNodeIdIsAllowed = indexNode => nodeId => indexNode.allowedRecordNodeIds.length === 0
|
|
|| fp.includes(nodeId)(indexNode.allowedRecordNodeIds);
|
|
|
|
const recordNodeIsAllowed = indexNode => recordNode => recordNodeIdIsAllowed(indexNode)(recordNode.nodeId);
|
|
|
|
const getAllowedRecordNodesForIndex = (appHierarchy, indexNode) => {
|
|
const recordNodes = $(appHierarchy, [
|
|
getFlattenedHierarchy,
|
|
fp.filter(isRecord),
|
|
]);
|
|
|
|
if (isGlobalIndex(indexNode)) {
|
|
return $(recordNodes, [
|
|
fp.filter(recordNodeIsAllowed(indexNode)),
|
|
]);
|
|
}
|
|
|
|
if (isAncestorIndex(indexNode)) {
|
|
return $(recordNodes, [
|
|
fp.filter(isDecendant(indexNode.parent())),
|
|
fp.filter(recordNodeIsAllowed(indexNode)),
|
|
]);
|
|
}
|
|
|
|
if (isReferenceIndex(indexNode)) {
|
|
return $(recordNodes, [
|
|
fp.filter(n => fp.some(fieldReversesReferenceToIndex(indexNode))(n.fields)),
|
|
]);
|
|
}
|
|
};
|
|
|
|
const getNodeFromNodeKeyHash = hierarchy => hash => $(hierarchy, [
|
|
getFlattenedHierarchy,
|
|
fp.find(n => getHashCode(n.nodeKey()) === hash),
|
|
]);
|
|
|
|
const isRecord = node => isSomething(node) && node.type === 'record';
|
|
const isSingleRecord = node => isRecord(node) && node.isSingle;
|
|
const isCollectionRecord = node => isRecord(node) && !node.isSingle;
|
|
const isIndex = node => isSomething(node) && node.type === 'index';
|
|
const isaggregateGroup = node => isSomething(node) && node.type === 'aggregateGroup';
|
|
const isShardedIndex = node => isIndex(node) && isNonEmptyString(node.getShardName);
|
|
const isRoot = node => isSomething(node) && node.isRoot();
|
|
const isDecendantOfARecord = hasMatchingAncestor(isRecord);
|
|
const isGlobalIndex = node => isIndex(node) && isRoot(node.parent());
|
|
const isReferenceIndex = node => isIndex(node) && node.indexType === indexTypes.reference;
|
|
const isAncestorIndex = node => isIndex(node) && node.indexType === indexTypes.ancestor;
|
|
|
|
const fieldReversesReferenceToNode = node => field => field.type === 'reference'
|
|
&& fp.intersection(field.typeOptions.reverseIndexNodeKeys)(fp.map(i => i.nodeKey())(node.indexes))
|
|
.length > 0;
|
|
|
|
const fieldReversesReferenceToIndex = indexNode => field => field.type === 'reference'
|
|
&& fp.intersection(field.typeOptions.reverseIndexNodeKeys)([indexNode.nodeKey()])
|
|
.length > 0;
|
|
|
|
var hierarchy = {
|
|
getLastPartInKey,
|
|
getNodesInPath,
|
|
getExactNodeForPath,
|
|
hasMatchingAncestor,
|
|
getNode,
|
|
getNodeByKeyOrNodeKey,
|
|
isNode,
|
|
getActualKeyOfParent,
|
|
getParentKey,
|
|
isKeyAncestorOf,
|
|
hasNoMatchingAncestors,
|
|
findField,
|
|
isAncestor,
|
|
isDecendant,
|
|
getRecordNodeId,
|
|
getRecordNodeIdFromId,
|
|
getRecordNodeById,
|
|
recordNodeIdIsAllowed,
|
|
recordNodeIsAllowed,
|
|
getAllowedRecordNodesForIndex,
|
|
getNodeFromNodeKeyHash,
|
|
isRecord,
|
|
isCollectionRecord,
|
|
isIndex,
|
|
isaggregateGroup,
|
|
isShardedIndex,
|
|
isRoot,
|
|
isDecendantOfARecord,
|
|
isGlobalIndex,
|
|
isReferenceIndex,
|
|
isAncestorIndex,
|
|
fieldReversesReferenceToNode,
|
|
fieldReversesReferenceToIndex,
|
|
getFlattenedHierarchy,
|
|
};
|
|
|
|
const getSafeFieldParser = (tryParse, defaultValueFunctions) => (field, record) => {
|
|
if (_.has(record, field.name)) {
|
|
return getSafeValueParser(tryParse, defaultValueFunctions)(record[field.name]);
|
|
}
|
|
return defaultValueFunctions[field.getUndefinedValue]();
|
|
};
|
|
|
|
const getSafeValueParser = (tryParse, defaultValueFunctions) => (value) => {
|
|
const parsed = tryParse(value);
|
|
if (parsed.success) {
|
|
return parsed.value;
|
|
}
|
|
return defaultValueFunctions.default();
|
|
};
|
|
|
|
const getNewValue = (tryParse, defaultValueFunctions) => (field) => {
|
|
const getInitialValue = fp.isUndefined(field) || fp.isUndefined(field.getInitialValue)
|
|
? 'default'
|
|
: field.getInitialValue;
|
|
|
|
return _.has(defaultValueFunctions, getInitialValue)
|
|
? defaultValueFunctions[getInitialValue]()
|
|
: getSafeValueParser(tryParse, defaultValueFunctions)(getInitialValue);
|
|
};
|
|
|
|
const typeFunctions = specificFunctions => _.merge({
|
|
value: fp.constant,
|
|
null: fp.constant(null),
|
|
}, specificFunctions);
|
|
|
|
const validateTypeConstraints = validationRules => async (field, record, context) => {
|
|
const fieldValue = record[field.name];
|
|
const validateRule = async r => (!await r.isValid(fieldValue, field.typeOptions, context)
|
|
? r.getMessage(fieldValue, field.typeOptions)
|
|
: '');
|
|
|
|
const errors = [];
|
|
for (const r of validationRules) {
|
|
const err = await validateRule(r);
|
|
if (isNotEmpty(err)) errors.push(err);
|
|
}
|
|
|
|
return errors;
|
|
};
|
|
|
|
const getDefaultOptions = fp.mapValues(v => v.defaultValue);
|
|
|
|
const makerule$1 = (isValid, getMessage) => ({ isValid, getMessage });
|
|
const parsedFailed = val => ({ success: false, value: val });
|
|
const parsedSuccess = val => ({ success: true, value: val });
|
|
const getDefaultExport = (name, tryParse, functions, options, validationRules, sampleValue, stringify) => ({
|
|
getNew: getNewValue(tryParse, functions),
|
|
safeParseField: getSafeFieldParser(tryParse, functions),
|
|
safeParseValue: getSafeValueParser(tryParse, functions),
|
|
tryParse,
|
|
name,
|
|
getDefaultOptions: () => getDefaultOptions(fp.cloneDeep(options)),
|
|
optionDefinitions: options,
|
|
validateTypeConstraints: validateTypeConstraints(validationRules),
|
|
sampleValue,
|
|
stringify: val => (val === null || val === undefined
|
|
? '' : stringify(val)),
|
|
getDefaultValue: functions.default,
|
|
});
|
|
|
|
const stringFunctions = typeFunctions({
|
|
default: _.constant(null),
|
|
});
|
|
|
|
const stringTryParse = switchCase(
|
|
[_.isString, parsedSuccess],
|
|
[_.isNull, parsedSuccess],
|
|
[defaultCase, v => parsedSuccess(v.toString())],
|
|
);
|
|
|
|
const options = {
|
|
maxLength: {
|
|
defaultValue: null,
|
|
isValid: n => n === null || isSafeInteger(n) && n > 0,
|
|
requirementDescription: 'max length must be null (no limit) or a greater than zero integer',
|
|
parse: toNumberOrNull,
|
|
},
|
|
values: {
|
|
defaultValue: null,
|
|
isValid: v => v === null || (isArrayOfString(v) && v.length > 0 && v.length < 10000),
|
|
requirementDescription: "'values' must be null (no values) or an arry of at least one string",
|
|
parse: s => s,
|
|
},
|
|
allowDeclaredValuesOnly: {
|
|
defaultValue: false,
|
|
isValid: _.isBoolean,
|
|
requirementDescription: 'allowDeclaredValuesOnly must be true or false',
|
|
parse: toBoolOrNull,
|
|
},
|
|
};
|
|
|
|
const typeConstraints = [
|
|
makerule$1(async (val, opts) => val === null || opts.maxLength === null || val.length <= opts.maxLength,
|
|
(val, opts) => `value exceeds maximum length of ${opts.maxLength}`),
|
|
makerule$1(async (val, opts) => val === null
|
|
|| opts.allowDeclaredValuesOnly === false
|
|
|| _.includes(opts.values, val),
|
|
(val) => `"${val}" does not exist in the list of allowed values`),
|
|
];
|
|
|
|
var string = getDefaultExport(
|
|
'string',
|
|
stringTryParse,
|
|
stringFunctions,
|
|
options,
|
|
typeConstraints,
|
|
'abcde',
|
|
str => str,
|
|
);
|
|
|
|
const boolFunctions = typeFunctions({
|
|
default: _.constant(null),
|
|
});
|
|
|
|
const boolTryParse = switchCase(
|
|
[_.isBoolean, parsedSuccess],
|
|
[_.isNull, parsedSuccess],
|
|
[isOneOf('true', '1', 'yes', 'on'), () => parsedSuccess(true)],
|
|
[isOneOf('false', '0', 'no', 'off'), () => parsedSuccess(false)],
|
|
[defaultCase, parsedFailed],
|
|
);
|
|
|
|
const options$1 = {
|
|
allowNulls: {
|
|
defaultValue: true,
|
|
isValid: _.isBoolean,
|
|
requirementDescription: 'must be a true or false',
|
|
parse: toBoolOrNull,
|
|
},
|
|
};
|
|
|
|
const typeConstraints$1 = [
|
|
makerule$1(async (val, opts) => opts.allowNulls === true || val !== null,
|
|
() => 'field cannot be null'),
|
|
];
|
|
|
|
var bool = getDefaultExport(
|
|
'bool', boolTryParse, boolFunctions,
|
|
options$1, typeConstraints$1, true, JSON.stringify,
|
|
);
|
|
|
|
const numberFunctions = typeFunctions({
|
|
default: _.constant(null),
|
|
});
|
|
|
|
const parseStringtoNumberOrNull = (s) => {
|
|
const num = Number(s);
|
|
return isNaN(num) ? parsedFailed(s) : parsedSuccess(num);
|
|
};
|
|
|
|
const numberTryParse = switchCase(
|
|
[_.isNumber, parsedSuccess],
|
|
[_.isString, parseStringtoNumberOrNull],
|
|
[_.isNull, parsedSuccess],
|
|
[defaultCase, parsedFailed],
|
|
);
|
|
|
|
const options$2 = {
|
|
maxValue: {
|
|
defaultValue: Number.MAX_SAFE_INTEGER,
|
|
isValid: isSafeInteger,
|
|
requirementDescription: 'must be a valid integer',
|
|
parse: toNumberOrNull,
|
|
},
|
|
minValue: {
|
|
defaultValue: 0 - Number.MAX_SAFE_INTEGER,
|
|
isValid: isSafeInteger,
|
|
requirementDescription: 'must be a valid integer',
|
|
parse: toNumberOrNull,
|
|
},
|
|
decimalPlaces: {
|
|
defaultValue: 0,
|
|
isValid: n => isSafeInteger(n) && n >= 0,
|
|
requirementDescription: 'must be a positive integer',
|
|
parse: toNumberOrNull,
|
|
},
|
|
};
|
|
|
|
const getDecimalPlaces = (val) => {
|
|
const splitDecimal = val.toString().split('.');
|
|
if (splitDecimal.length === 1) return 0;
|
|
return splitDecimal[1].length;
|
|
};
|
|
|
|
const typeConstraints$2 = [
|
|
makerule$1(async (val, opts) => val === null || opts.minValue === null || val >= opts.minValue,
|
|
(val, opts) => `value (${val.toString()}) must be greater than or equal to ${opts.minValue}`),
|
|
makerule$1(async (val, opts) => val === null || opts.maxValue === null || val <= opts.maxValue,
|
|
(val, opts) => `value (${val.toString()}) must be less than or equal to ${opts.minValue} options`),
|
|
makerule$1(async (val, opts) => val === null || opts.decimalPlaces >= getDecimalPlaces(val),
|
|
(val, opts) => `value (${val.toString()}) must have ${opts.decimalPlaces} decimal places or less`),
|
|
];
|
|
|
|
var number = getDefaultExport(
|
|
'number',
|
|
numberTryParse,
|
|
numberFunctions,
|
|
options$2,
|
|
typeConstraints$2,
|
|
1,
|
|
num => num.toString(),
|
|
);
|
|
|
|
const dateFunctions = typeFunctions({
|
|
default: _.constant(null),
|
|
now: () => new Date(),
|
|
});
|
|
|
|
const isValidDate = d => d instanceof Date && !isNaN(d);
|
|
|
|
const parseStringToDate = s => switchCase(
|
|
[isValidDate, parsedSuccess],
|
|
[defaultCase, parsedFailed],
|
|
)(new Date(s));
|
|
|
|
|
|
const dateTryParse = switchCase(
|
|
[_.isDate, parsedSuccess],
|
|
[_.isString, parseStringToDate],
|
|
[_.isNull, parsedSuccess],
|
|
[defaultCase, parsedFailed],
|
|
);
|
|
|
|
const options$3 = {
|
|
maxValue: {
|
|
defaultValue: new Date(32503680000000),
|
|
isValid: _.isDate,
|
|
requirementDescription: 'must be a valid date',
|
|
parse: toDateOrNull,
|
|
},
|
|
minValue: {
|
|
defaultValue: new Date(-8520336000000),
|
|
isValid: _.isDate,
|
|
requirementDescription: 'must be a valid date',
|
|
parse: toDateOrNull,
|
|
},
|
|
};
|
|
|
|
const typeConstraints$3 = [
|
|
makerule$1(async (val, opts) => val === null || opts.minValue === null || val >= opts.minValue,
|
|
(val, opts) => `value (${val.toString()}) must be greater than or equal to ${opts.minValue}`),
|
|
makerule$1(async (val, opts) => val === null || opts.maxValue === null || val <= opts.maxValue,
|
|
(val, opts) => `value (${val.toString()}) must be less than or equal to ${opts.minValue} options`),
|
|
];
|
|
|
|
var datetime = getDefaultExport(
|
|
'datetime',
|
|
dateTryParse,
|
|
dateFunctions,
|
|
options$3,
|
|
typeConstraints$3,
|
|
new Date(1984, 4, 1),
|
|
date => JSON.stringify(date).replace(new RegExp('"', 'g'), ''),
|
|
);
|
|
|
|
const arrayFunctions = () => typeFunctions({
|
|
default: _.constant([]),
|
|
});
|
|
|
|
const mapToParsedArrary = type => $$(
|
|
fp.map(i => type.safeParseValue(i)),
|
|
parsedSuccess,
|
|
);
|
|
|
|
const arrayTryParse = type => switchCase(
|
|
[_.isArray, mapToParsedArrary(type)],
|
|
[defaultCase, parsedFailed],
|
|
);
|
|
|
|
const typeName = type => `array<${type}>`;
|
|
|
|
|
|
const options$4 = {
|
|
maxLength: {
|
|
defaultValue: 10000,
|
|
isValid: isSafeInteger,
|
|
requirementDescription: 'must be a positive integer',
|
|
parse: toNumberOrNull,
|
|
},
|
|
minLength: {
|
|
defaultValue: 0,
|
|
isValid: n => isSafeInteger(n) && n >= 0,
|
|
requirementDescription: 'must be a positive integer',
|
|
parse: toNumberOrNull,
|
|
},
|
|
};
|
|
|
|
const typeConstraints$4 = [
|
|
makerule$1(async (val, opts) => val === null || val.length >= opts.minLength,
|
|
(val, opts) => `must choose ${opts.minLength} or more options`),
|
|
makerule$1(async (val, opts) => val === null || val.length <= opts.maxLength,
|
|
(val, opts) => `cannot choose more than ${opts.maxLength} options`),
|
|
];
|
|
|
|
var array = type => getDefaultExport(
|
|
typeName(type.name),
|
|
arrayTryParse(type),
|
|
arrayFunctions(),
|
|
options$4,
|
|
typeConstraints$4,
|
|
[type.sampleValue],
|
|
JSON.stringify,
|
|
);
|
|
|
|
const referenceNothing = () => ({ key: '' });
|
|
|
|
const referenceFunctions = typeFunctions({
|
|
default: referenceNothing,
|
|
});
|
|
|
|
const hasStringValue = (ob, path) => _.has(ob, path)
|
|
&& _.isString(ob[path]);
|
|
|
|
const isObjectWithKey = v => _.isObjectLike(v)
|
|
&& hasStringValue(v, 'key');
|
|
|
|
const tryParseFromString = s => {
|
|
|
|
try {
|
|
const asObj = JSON.parse(s);
|
|
if(isObjectWithKey) {
|
|
return parsedSuccess(asObj);
|
|
}
|
|
}
|
|
catch(_) {
|
|
// EMPTY
|
|
}
|
|
|
|
return parsedFailed(s);
|
|
};
|
|
|
|
const referenceTryParse = v => switchCase(
|
|
[isObjectWithKey, parsedSuccess],
|
|
[_.isString, tryParseFromString],
|
|
[_.isNull, () => parsedSuccess(referenceNothing())],
|
|
[defaultCase, parsedFailed],
|
|
)(v);
|
|
|
|
const options$5 = {
|
|
indexNodeKey: {
|
|
defaultValue: null,
|
|
isValid: isNonEmptyString,
|
|
requirementDescription: 'must be a non-empty string',
|
|
parse: s => s,
|
|
},
|
|
displayValue: {
|
|
defaultValue: '',
|
|
isValid: isNonEmptyString,
|
|
requirementDescription: 'must be a non-empty string',
|
|
parse: s => s,
|
|
},
|
|
reverseIndexNodeKeys: {
|
|
defaultValue: null,
|
|
isValid: v => isArrayOfString(v) && v.length > 0,
|
|
requirementDescription: 'must be a non-empty array of strings',
|
|
parse: s => s,
|
|
},
|
|
};
|
|
|
|
const isEmptyString = s => _.isString(s) && _.isEmpty(s);
|
|
|
|
const ensureReferenceExists = async (val, opts, context) => isEmptyString(val.key)
|
|
|| await context.referenceExists(opts, val.key);
|
|
|
|
const typeConstraints$5 = [
|
|
makerule$1(
|
|
ensureReferenceExists,
|
|
(val, opts) => `"${val[opts.displayValue]}" does not exist in options list (key: ${val.key})`,
|
|
),
|
|
];
|
|
|
|
var reference = getDefaultExport(
|
|
'reference',
|
|
referenceTryParse,
|
|
referenceFunctions,
|
|
options$5,
|
|
typeConstraints$5,
|
|
{ key: 'key', value: 'value' },
|
|
JSON.stringify,
|
|
);
|
|
|
|
const illegalCharacters = '*?\\/:<>|\0\b\f\v';
|
|
|
|
const isLegalFilename = (filePath) => {
|
|
const fn = fileName(filePath);
|
|
return fn.length <= 255
|
|
&& fp.intersection(fn.split(''))(illegalCharacters.split('')).length === 0
|
|
&& none(f => f === '..')(splitKey(filePath));
|
|
};
|
|
|
|
const fileNothing = () => ({ relativePath: '', size: 0 });
|
|
|
|
const fileFunctions = typeFunctions({
|
|
default: fileNothing,
|
|
});
|
|
|
|
const fileTryParse = v => switchCase(
|
|
[isValidFile, parsedSuccess],
|
|
[fp.isNull, () => parsedSuccess(fileNothing())],
|
|
[defaultCase, parsedFailed],
|
|
)(v);
|
|
|
|
const fileName = filePath => $(filePath, [
|
|
splitKey,
|
|
fp.last,
|
|
]);
|
|
|
|
const isValidFile = f => !fp.isNull(f)
|
|
&& fp.has('relativePath')(f) && fp.has('size')(f)
|
|
&& fp.isNumber(f.size)
|
|
&& fp.isString(f.relativePath)
|
|
&& isLegalFilename(f.relativePath);
|
|
|
|
const options$6 = {};
|
|
|
|
const typeConstraints$6 = [];
|
|
|
|
var file$1 = getDefaultExport(
|
|
'file',
|
|
fileTryParse,
|
|
fileFunctions,
|
|
options$6,
|
|
typeConstraints$6,
|
|
{ relativePath: 'some_file.jpg', size: 1000 },
|
|
JSON.stringify,
|
|
);
|
|
|
|
const allTypes = () => {
|
|
const basicTypes = {
|
|
string, number, datetime, bool, reference, file: file$1,
|
|
};
|
|
|
|
const arrays = $(basicTypes, [
|
|
_.keys,
|
|
fp.map((k) => {
|
|
const kvType = {};
|
|
const concreteArray = array(basicTypes[k]);
|
|
kvType[concreteArray.name] = concreteArray;
|
|
return kvType;
|
|
}),
|
|
types => _.assign({}, ...types),
|
|
]);
|
|
|
|
return _.merge({}, basicTypes, arrays);
|
|
};
|
|
|
|
|
|
const all$1 = allTypes();
|
|
|
|
const getType = (typeName) => {
|
|
if (!_.has(all$1, typeName)) throw new BadRequestError(`Do not recognise type ${typeName}`);
|
|
return all$1[typeName];
|
|
};
|
|
|
|
const getDefaultOptions$1 = type => getType(type).getDefaultOptions();
|
|
|
|
// 5 minutes
|
|
const tempCodeExpiryLength = 5 * 60 * 1000;
|
|
|
|
const AUTH_FOLDER = '/.auth';
|
|
const USERS_LIST_FILE = joinKey(AUTH_FOLDER, 'users.json');
|
|
const userAuthFile = username => joinKey(AUTH_FOLDER, `auth_${username}.json`);
|
|
const USERS_LOCK_FILE = joinKey(AUTH_FOLDER, 'users_lock');
|
|
const ACCESS_LEVELS_FILE = joinKey(AUTH_FOLDER, 'access_levels.json');
|
|
const ACCESS_LEVELS_LOCK_FILE = joinKey(AUTH_FOLDER, 'access_levels_lock');
|
|
|
|
const permissionTypes = {
|
|
CREATE_RECORD: 'create record',
|
|
UPDATE_RECORD: 'update record',
|
|
READ_RECORD: 'read record',
|
|
DELETE_RECORD: 'delete record',
|
|
READ_INDEX: 'read index',
|
|
MANAGE_INDEX: 'manage index',
|
|
MANAGE_COLLECTION: 'manage collection',
|
|
WRITE_TEMPLATES: 'write templates',
|
|
CREATE_USER: 'create user',
|
|
SET_PASSWORD: 'set password',
|
|
CREATE_TEMPORARY_ACCESS: 'create temporary access',
|
|
ENABLE_DISABLE_USER: 'enable or disable user',
|
|
WRITE_ACCESS_LEVELS: 'write access levels',
|
|
LIST_USERS: 'list users',
|
|
LIST_ACCESS_LEVELS: 'list access levels',
|
|
EXECUTE_ACTION: 'execute action',
|
|
SET_USER_ACCESS_LEVELS: 'set user access levels',
|
|
};
|
|
|
|
const getUserByName = (users, name) => $(users, [
|
|
fp.find(u => u.name.toLowerCase() === name.toLowerCase()),
|
|
]);
|
|
|
|
const stripUserOfSensitiveStuff = (user) => {
|
|
const stripped = fp.clone(user);
|
|
delete stripped.tempCode;
|
|
return stripped;
|
|
};
|
|
|
|
const parseTemporaryCode = fullCode => $(fullCode, [
|
|
fp.split(':'),
|
|
parts => ({
|
|
id: parts[1],
|
|
code: parts[2],
|
|
}),
|
|
]);
|
|
|
|
const isAuthorized = app => (permissionType, resourceKey) => apiWrapperSync(
|
|
app,
|
|
events.authApi.isAuthorized,
|
|
alwaysAuthorized,
|
|
{ resourceKey, permissionType },
|
|
_isAuthorized, app, permissionType, resourceKey,
|
|
);
|
|
|
|
const _isAuthorized = (app, permissionType, resourceKey) => {
|
|
if (!app.user) {
|
|
return false;
|
|
}
|
|
|
|
const validType = $(permissionTypes, [
|
|
fp.values,
|
|
fp.includes(permissionType),
|
|
]);
|
|
|
|
if (!validType) {
|
|
return false;
|
|
}
|
|
|
|
const permMatchesResource = (userperm) => {
|
|
const nodeKey = isNothing(resourceKey)
|
|
? null
|
|
: isNode(app.hierarchy, resourceKey)
|
|
? getNodeByKeyOrNodeKey(
|
|
app.hierarchy, resourceKey,
|
|
).nodeKey()
|
|
: resourceKey;
|
|
|
|
return (userperm.type === permissionType)
|
|
&& (
|
|
isNothing(resourceKey)
|
|
|| nodeKey === userperm.nodeKey
|
|
);
|
|
};
|
|
|
|
return $(app.user.permissions, [
|
|
fp.some(permMatchesResource),
|
|
]);
|
|
};
|
|
|
|
const nodePermission = type => ({
|
|
add: (nodeKey, accessLevel) => accessLevel.permissions.push({ type, nodeKey }),
|
|
isAuthorized: resourceKey => app => isAuthorized(app)(type, resourceKey),
|
|
isNode: true,
|
|
get: nodeKey => ({ type, nodeKey }),
|
|
});
|
|
|
|
const staticPermission = type => ({
|
|
add: accessLevel => accessLevel.permissions.push({ type }),
|
|
isAuthorized: app => isAuthorized(app)(type),
|
|
isNode: false,
|
|
get: () => ({ type }),
|
|
});
|
|
|
|
const createRecord = nodePermission(permissionTypes.CREATE_RECORD);
|
|
|
|
const updateRecord = nodePermission(permissionTypes.UPDATE_RECORD);
|
|
|
|
const deleteRecord = nodePermission(permissionTypes.DELETE_RECORD);
|
|
|
|
const readRecord = nodePermission(permissionTypes.READ_RECORD);
|
|
|
|
const writeTemplates = staticPermission(permissionTypes.WRITE_TEMPLATES);
|
|
|
|
const createUser = staticPermission(permissionTypes.CREATE_USER);
|
|
|
|
const setPassword = staticPermission(permissionTypes.SET_PASSWORD);
|
|
|
|
const readIndex = nodePermission(permissionTypes.READ_INDEX);
|
|
|
|
const manageIndex = staticPermission(permissionTypes.MANAGE_INDEX);
|
|
|
|
const manageCollection = staticPermission(permissionTypes.MANAGE_COLLECTION);
|
|
|
|
const createTemporaryAccess = staticPermission(permissionTypes.CREATE_TEMPORARY_ACCESS);
|
|
|
|
const enableDisableUser = staticPermission(permissionTypes.ENABLE_DISABLE_USER);
|
|
|
|
const writeAccessLevels = staticPermission(permissionTypes.WRITE_ACCESS_LEVELS);
|
|
|
|
const listUsers = staticPermission(permissionTypes.LIST_USERS);
|
|
|
|
const listAccessLevels = staticPermission(permissionTypes.LIST_ACCESS_LEVELS);
|
|
|
|
const setUserAccessLevels = staticPermission(permissionTypes.SET_USER_ACCESS_LEVELS);
|
|
|
|
const executeAction = nodePermission(permissionTypes.EXECUTE_ACTION);
|
|
|
|
const alwaysAuthorized = () => true;
|
|
|
|
const permission = {
|
|
createRecord,
|
|
updateRecord,
|
|
deleteRecord,
|
|
readRecord,
|
|
writeTemplates,
|
|
createUser,
|
|
setPassword,
|
|
readIndex,
|
|
createTemporaryAccess,
|
|
enableDisableUser,
|
|
writeAccessLevels,
|
|
listUsers,
|
|
listAccessLevels,
|
|
manageIndex,
|
|
manageCollection,
|
|
executeAction,
|
|
setUserAccessLevels,
|
|
};
|
|
|
|
var global$1 = (typeof global !== "undefined" ? global :
|
|
typeof self !== "undefined" ? self :
|
|
typeof window !== "undefined" ? window : {});
|
|
|
|
var lookup = [];
|
|
var revLookup = [];
|
|
var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
|
|
var inited = false;
|
|
function init$1 () {
|
|
inited = true;
|
|
var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
|
|
for (var i = 0, len = code.length; i < len; ++i) {
|
|
lookup[i] = code[i];
|
|
revLookup[code.charCodeAt(i)] = i;
|
|
}
|
|
|
|
revLookup['-'.charCodeAt(0)] = 62;
|
|
revLookup['_'.charCodeAt(0)] = 63;
|
|
}
|
|
|
|
function toByteArray (b64) {
|
|
if (!inited) {
|
|
init$1();
|
|
}
|
|
var i, j, l, tmp, placeHolders, arr;
|
|
var len = b64.length;
|
|
|
|
if (len % 4 > 0) {
|
|
throw new Error('Invalid string. Length must be a multiple of 4')
|
|
}
|
|
|
|
// the number of equal signs (place holders)
|
|
// if there are two placeholders, than the two characters before it
|
|
// represent one byte
|
|
// if there is only one, then the three characters before it represent 2 bytes
|
|
// this is just a cheap hack to not do indexOf twice
|
|
placeHolders = b64[len - 2] === '=' ? 2 : b64[len - 1] === '=' ? 1 : 0;
|
|
|
|
// base64 is 4/3 + up to two characters of the original data
|
|
arr = new Arr(len * 3 / 4 - placeHolders);
|
|
|
|
// if there are placeholders, only get up to the last complete 4 chars
|
|
l = placeHolders > 0 ? len - 4 : len;
|
|
|
|
var L = 0;
|
|
|
|
for (i = 0, j = 0; i < l; i += 4, j += 3) {
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 18) | (revLookup[b64.charCodeAt(i + 1)] << 12) | (revLookup[b64.charCodeAt(i + 2)] << 6) | revLookup[b64.charCodeAt(i + 3)];
|
|
arr[L++] = (tmp >> 16) & 0xFF;
|
|
arr[L++] = (tmp >> 8) & 0xFF;
|
|
arr[L++] = tmp & 0xFF;
|
|
}
|
|
|
|
if (placeHolders === 2) {
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 2) | (revLookup[b64.charCodeAt(i + 1)] >> 4);
|
|
arr[L++] = tmp & 0xFF;
|
|
} else if (placeHolders === 1) {
|
|
tmp = (revLookup[b64.charCodeAt(i)] << 10) | (revLookup[b64.charCodeAt(i + 1)] << 4) | (revLookup[b64.charCodeAt(i + 2)] >> 2);
|
|
arr[L++] = (tmp >> 8) & 0xFF;
|
|
arr[L++] = tmp & 0xFF;
|
|
}
|
|
|
|
return arr
|
|
}
|
|
|
|
function tripletToBase64 (num) {
|
|
return lookup[num >> 18 & 0x3F] + lookup[num >> 12 & 0x3F] + lookup[num >> 6 & 0x3F] + lookup[num & 0x3F]
|
|
}
|
|
|
|
function encodeChunk (uint8, start, end) {
|
|
var tmp;
|
|
var output = [];
|
|
for (var i = start; i < end; i += 3) {
|
|
tmp = (uint8[i] << 16) + (uint8[i + 1] << 8) + (uint8[i + 2]);
|
|
output.push(tripletToBase64(tmp));
|
|
}
|
|
return output.join('')
|
|
}
|
|
|
|
function fromByteArray (uint8) {
|
|
if (!inited) {
|
|
init$1();
|
|
}
|
|
var tmp;
|
|
var len = uint8.length;
|
|
var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
|
|
var output = '';
|
|
var parts = [];
|
|
var maxChunkLength = 16383; // must be multiple of 3
|
|
|
|
// go through the array every three bytes, we'll deal with trailing stuff later
|
|
for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
|
|
parts.push(encodeChunk(uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)));
|
|
}
|
|
|
|
// pad the end with zeros, but make sure to not forget the extra bytes
|
|
if (extraBytes === 1) {
|
|
tmp = uint8[len - 1];
|
|
output += lookup[tmp >> 2];
|
|
output += lookup[(tmp << 4) & 0x3F];
|
|
output += '==';
|
|
} else if (extraBytes === 2) {
|
|
tmp = (uint8[len - 2] << 8) + (uint8[len - 1]);
|
|
output += lookup[tmp >> 10];
|
|
output += lookup[(tmp >> 4) & 0x3F];
|
|
output += lookup[(tmp << 2) & 0x3F];
|
|
output += '=';
|
|
}
|
|
|
|
parts.push(output);
|
|
|
|
return parts.join('')
|
|
}
|
|
|
|
function read (buffer, offset, isLE, mLen, nBytes) {
|
|
var e, m;
|
|
var eLen = nBytes * 8 - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var nBits = -7;
|
|
var i = isLE ? (nBytes - 1) : 0;
|
|
var d = isLE ? -1 : 1;
|
|
var s = buffer[offset + i];
|
|
|
|
i += d;
|
|
|
|
e = s & ((1 << (-nBits)) - 1);
|
|
s >>= (-nBits);
|
|
nBits += eLen;
|
|
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
m = e & ((1 << (-nBits)) - 1);
|
|
e >>= (-nBits);
|
|
nBits += mLen;
|
|
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {}
|
|
|
|
if (e === 0) {
|
|
e = 1 - eBias;
|
|
} else if (e === eMax) {
|
|
return m ? NaN : ((s ? -1 : 1) * Infinity)
|
|
} else {
|
|
m = m + Math.pow(2, mLen);
|
|
e = e - eBias;
|
|
}
|
|
return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
|
|
}
|
|
|
|
function write (buffer, value, offset, isLE, mLen, nBytes) {
|
|
var e, m, c;
|
|
var eLen = nBytes * 8 - mLen - 1;
|
|
var eMax = (1 << eLen) - 1;
|
|
var eBias = eMax >> 1;
|
|
var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0);
|
|
var i = isLE ? 0 : (nBytes - 1);
|
|
var d = isLE ? 1 : -1;
|
|
var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
|
|
|
|
value = Math.abs(value);
|
|
|
|
if (isNaN(value) || value === Infinity) {
|
|
m = isNaN(value) ? 1 : 0;
|
|
e = eMax;
|
|
} else {
|
|
e = Math.floor(Math.log(value) / Math.LN2);
|
|
if (value * (c = Math.pow(2, -e)) < 1) {
|
|
e--;
|
|
c *= 2;
|
|
}
|
|
if (e + eBias >= 1) {
|
|
value += rt / c;
|
|
} else {
|
|
value += rt * Math.pow(2, 1 - eBias);
|
|
}
|
|
if (value * c >= 2) {
|
|
e++;
|
|
c /= 2;
|
|
}
|
|
|
|
if (e + eBias >= eMax) {
|
|
m = 0;
|
|
e = eMax;
|
|
} else if (e + eBias >= 1) {
|
|
m = (value * c - 1) * Math.pow(2, mLen);
|
|
e = e + eBias;
|
|
} else {
|
|
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
|
e = 0;
|
|
}
|
|
}
|
|
|
|
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
|
|
|
|
e = (e << mLen) | m;
|
|
eLen += mLen;
|
|
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
|
|
|
|
buffer[offset + i - d] |= s * 128;
|
|
}
|
|
|
|
var toString = {}.toString;
|
|
|
|
var isArray = Array.isArray || function (arr) {
|
|
return toString.call(arr) == '[object Array]';
|
|
};
|
|
|
|
var INSPECT_MAX_BYTES = 50;
|
|
|
|
/**
|
|
* If `Buffer.TYPED_ARRAY_SUPPORT`:
|
|
* === true Use Uint8Array implementation (fastest)
|
|
* === false Use Object implementation (most compatible, even IE6)
|
|
*
|
|
* Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
|
|
* Opera 11.6+, iOS 4.2+.
|
|
*
|
|
* Due to various browser bugs, sometimes the Object implementation will be used even
|
|
* when the browser supports typed arrays.
|
|
*
|
|
* Note:
|
|
*
|
|
* - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,
|
|
* See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.
|
|
*
|
|
* - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.
|
|
*
|
|
* - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of
|
|
* incorrect length in some situations.
|
|
|
|
* We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they
|
|
* get the Object implementation, which is slower but behaves correctly.
|
|
*/
|
|
Buffer.TYPED_ARRAY_SUPPORT = global$1.TYPED_ARRAY_SUPPORT !== undefined
|
|
? global$1.TYPED_ARRAY_SUPPORT
|
|
: true;
|
|
|
|
function kMaxLength () {
|
|
return Buffer.TYPED_ARRAY_SUPPORT
|
|
? 0x7fffffff
|
|
: 0x3fffffff
|
|
}
|
|
|
|
function createBuffer (that, length) {
|
|
if (kMaxLength() < length) {
|
|
throw new RangeError('Invalid typed array length')
|
|
}
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// Return an augmented `Uint8Array` instance, for best performance
|
|
that = new Uint8Array(length);
|
|
that.__proto__ = Buffer.prototype;
|
|
} else {
|
|
// Fallback: Return an object instance of the Buffer class
|
|
if (that === null) {
|
|
that = new Buffer(length);
|
|
}
|
|
that.length = length;
|
|
}
|
|
|
|
return that
|
|
}
|
|
|
|
/**
|
|
* The Buffer constructor returns instances of `Uint8Array` that have their
|
|
* prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
|
|
* `Uint8Array`, so the returned instances will have all the node `Buffer` methods
|
|
* and the `Uint8Array` methods. Square bracket notation works as expected -- it
|
|
* returns a single octet.
|
|
*
|
|
* The `Uint8Array` prototype remains unmodified.
|
|
*/
|
|
|
|
function Buffer (arg, encodingOrOffset, length) {
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {
|
|
return new Buffer(arg, encodingOrOffset, length)
|
|
}
|
|
|
|
// Common case.
|
|
if (typeof arg === 'number') {
|
|
if (typeof encodingOrOffset === 'string') {
|
|
throw new Error(
|
|
'If encoding is specified then the first argument must be a string'
|
|
)
|
|
}
|
|
return allocUnsafe(this, arg)
|
|
}
|
|
return from(this, arg, encodingOrOffset, length)
|
|
}
|
|
|
|
Buffer.poolSize = 8192; // not used by this implementation
|
|
|
|
// TODO: Legacy, not needed anymore. Remove in next major version.
|
|
Buffer._augment = function (arr) {
|
|
arr.__proto__ = Buffer.prototype;
|
|
return arr
|
|
};
|
|
|
|
function from (that, value, encodingOrOffset, length) {
|
|
if (typeof value === 'number') {
|
|
throw new TypeError('"value" argument must not be a number')
|
|
}
|
|
|
|
if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {
|
|
return fromArrayBuffer(that, value, encodingOrOffset, length)
|
|
}
|
|
|
|
if (typeof value === 'string') {
|
|
return fromString(that, value, encodingOrOffset)
|
|
}
|
|
|
|
return fromObject(that, value)
|
|
}
|
|
|
|
/**
|
|
* Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
|
|
* if value is a number.
|
|
* Buffer.from(str[, encoding])
|
|
* Buffer.from(array)
|
|
* Buffer.from(buffer)
|
|
* Buffer.from(arrayBuffer[, byteOffset[, length]])
|
|
**/
|
|
Buffer.from = function (value, encodingOrOffset, length) {
|
|
return from(null, value, encodingOrOffset, length)
|
|
};
|
|
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
Buffer.prototype.__proto__ = Uint8Array.prototype;
|
|
Buffer.__proto__ = Uint8Array;
|
|
}
|
|
|
|
function assertSize (size) {
|
|
if (typeof size !== 'number') {
|
|
throw new TypeError('"size" argument must be a number')
|
|
} else if (size < 0) {
|
|
throw new RangeError('"size" argument must not be negative')
|
|
}
|
|
}
|
|
|
|
function alloc (that, size, fill, encoding) {
|
|
assertSize(size);
|
|
if (size <= 0) {
|
|
return createBuffer(that, size)
|
|
}
|
|
if (fill !== undefined) {
|
|
// Only pay attention to encoding if it's a string. This
|
|
// prevents accidentally sending in a number that would
|
|
// be interpretted as a start offset.
|
|
return typeof encoding === 'string'
|
|
? createBuffer(that, size).fill(fill, encoding)
|
|
: createBuffer(that, size).fill(fill)
|
|
}
|
|
return createBuffer(that, size)
|
|
}
|
|
|
|
/**
|
|
* Creates a new filled Buffer instance.
|
|
* alloc(size[, fill[, encoding]])
|
|
**/
|
|
Buffer.alloc = function (size, fill, encoding) {
|
|
return alloc(null, size, fill, encoding)
|
|
};
|
|
|
|
function allocUnsafe (that, size) {
|
|
assertSize(size);
|
|
that = createBuffer(that, size < 0 ? 0 : checked(size) | 0);
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) {
|
|
for (var i = 0; i < size; ++i) {
|
|
that[i] = 0;
|
|
}
|
|
}
|
|
return that
|
|
}
|
|
|
|
/**
|
|
* Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
|
|
* */
|
|
Buffer.allocUnsafe = function (size) {
|
|
return allocUnsafe(null, size)
|
|
};
|
|
/**
|
|
* Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
|
|
*/
|
|
Buffer.allocUnsafeSlow = function (size) {
|
|
return allocUnsafe(null, size)
|
|
};
|
|
|
|
function fromString (that, string, encoding) {
|
|
if (typeof encoding !== 'string' || encoding === '') {
|
|
encoding = 'utf8';
|
|
}
|
|
|
|
if (!Buffer.isEncoding(encoding)) {
|
|
throw new TypeError('"encoding" must be a valid string encoding')
|
|
}
|
|
|
|
var length = byteLength(string, encoding) | 0;
|
|
that = createBuffer(that, length);
|
|
|
|
var actual = that.write(string, encoding);
|
|
|
|
if (actual !== length) {
|
|
// Writing a hex string, for example, that contains invalid characters will
|
|
// cause everything after the first invalid character to be ignored. (e.g.
|
|
// 'abxxcd' will be treated as 'ab')
|
|
that = that.slice(0, actual);
|
|
}
|
|
|
|
return that
|
|
}
|
|
|
|
function fromArrayLike (that, array) {
|
|
var length = array.length < 0 ? 0 : checked(array.length) | 0;
|
|
that = createBuffer(that, length);
|
|
for (var i = 0; i < length; i += 1) {
|
|
that[i] = array[i] & 255;
|
|
}
|
|
return that
|
|
}
|
|
|
|
function fromArrayBuffer (that, array, byteOffset, length) {
|
|
array.byteLength; // this throws if `array` is not a valid ArrayBuffer
|
|
|
|
if (byteOffset < 0 || array.byteLength < byteOffset) {
|
|
throw new RangeError('\'offset\' is out of bounds')
|
|
}
|
|
|
|
if (array.byteLength < byteOffset + (length || 0)) {
|
|
throw new RangeError('\'length\' is out of bounds')
|
|
}
|
|
|
|
if (byteOffset === undefined && length === undefined) {
|
|
array = new Uint8Array(array);
|
|
} else if (length === undefined) {
|
|
array = new Uint8Array(array, byteOffset);
|
|
} else {
|
|
array = new Uint8Array(array, byteOffset, length);
|
|
}
|
|
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// Return an augmented `Uint8Array` instance, for best performance
|
|
that = array;
|
|
that.__proto__ = Buffer.prototype;
|
|
} else {
|
|
// Fallback: Return an object instance of the Buffer class
|
|
that = fromArrayLike(that, array);
|
|
}
|
|
return that
|
|
}
|
|
|
|
function fromObject (that, obj) {
|
|
if (internalIsBuffer(obj)) {
|
|
var len = checked(obj.length) | 0;
|
|
that = createBuffer(that, len);
|
|
|
|
if (that.length === 0) {
|
|
return that
|
|
}
|
|
|
|
obj.copy(that, 0, 0, len);
|
|
return that
|
|
}
|
|
|
|
if (obj) {
|
|
if ((typeof ArrayBuffer !== 'undefined' &&
|
|
obj.buffer instanceof ArrayBuffer) || 'length' in obj) {
|
|
if (typeof obj.length !== 'number' || isnan(obj.length)) {
|
|
return createBuffer(that, 0)
|
|
}
|
|
return fromArrayLike(that, obj)
|
|
}
|
|
|
|
if (obj.type === 'Buffer' && isArray(obj.data)) {
|
|
return fromArrayLike(that, obj.data)
|
|
}
|
|
}
|
|
|
|
throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
|
|
}
|
|
|
|
function checked (length) {
|
|
// Note: cannot use `length < kMaxLength()` here because that fails when
|
|
// length is NaN (which is otherwise coerced to zero.)
|
|
if (length >= kMaxLength()) {
|
|
throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
|
|
'size: 0x' + kMaxLength().toString(16) + ' bytes')
|
|
}
|
|
return length | 0
|
|
}
|
|
Buffer.isBuffer = isBuffer;
|
|
function internalIsBuffer (b) {
|
|
return !!(b != null && b._isBuffer)
|
|
}
|
|
|
|
Buffer.compare = function compare (a, b) {
|
|
if (!internalIsBuffer(a) || !internalIsBuffer(b)) {
|
|
throw new TypeError('Arguments must be Buffers')
|
|
}
|
|
|
|
if (a === b) return 0
|
|
|
|
var x = a.length;
|
|
var y = b.length;
|
|
|
|
for (var i = 0, len = Math.min(x, y); i < len; ++i) {
|
|
if (a[i] !== b[i]) {
|
|
x = a[i];
|
|
y = b[i];
|
|
break
|
|
}
|
|
}
|
|
|
|
if (x < y) return -1
|
|
if (y < x) return 1
|
|
return 0
|
|
};
|
|
|
|
Buffer.isEncoding = function isEncoding (encoding) {
|
|
switch (String(encoding).toLowerCase()) {
|
|
case 'hex':
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case 'ascii':
|
|
case 'latin1':
|
|
case 'binary':
|
|
case 'base64':
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
};
|
|
|
|
Buffer.concat = function concat (list, length) {
|
|
if (!isArray(list)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
|
}
|
|
|
|
if (list.length === 0) {
|
|
return Buffer.alloc(0)
|
|
}
|
|
|
|
var i;
|
|
if (length === undefined) {
|
|
length = 0;
|
|
for (i = 0; i < list.length; ++i) {
|
|
length += list[i].length;
|
|
}
|
|
}
|
|
|
|
var buffer = Buffer.allocUnsafe(length);
|
|
var pos = 0;
|
|
for (i = 0; i < list.length; ++i) {
|
|
var buf = list[i];
|
|
if (!internalIsBuffer(buf)) {
|
|
throw new TypeError('"list" argument must be an Array of Buffers')
|
|
}
|
|
buf.copy(buffer, pos);
|
|
pos += buf.length;
|
|
}
|
|
return buffer
|
|
};
|
|
|
|
function byteLength (string, encoding) {
|
|
if (internalIsBuffer(string)) {
|
|
return string.length
|
|
}
|
|
if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&
|
|
(ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {
|
|
return string.byteLength
|
|
}
|
|
if (typeof string !== 'string') {
|
|
string = '' + string;
|
|
}
|
|
|
|
var len = string.length;
|
|
if (len === 0) return 0
|
|
|
|
// Use a for loop to avoid recursion
|
|
var loweredCase = false;
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'ascii':
|
|
case 'latin1':
|
|
case 'binary':
|
|
return len
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
case undefined:
|
|
return utf8ToBytes(string).length
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return len * 2
|
|
case 'hex':
|
|
return len >>> 1
|
|
case 'base64':
|
|
return base64ToBytes(string).length
|
|
default:
|
|
if (loweredCase) return utf8ToBytes(string).length // assume utf8
|
|
encoding = ('' + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
}
|
|
Buffer.byteLength = byteLength;
|
|
|
|
function slowToString (encoding, start, end) {
|
|
var loweredCase = false;
|
|
|
|
// No need to verify that "this.length <= MAX_UINT32" since it's a read-only
|
|
// property of a typed array.
|
|
|
|
// This behaves neither like String nor Uint8Array in that we set start/end
|
|
// to their upper/lower bounds if the value passed is out of range.
|
|
// undefined is handled specially as per ECMA-262 6th Edition,
|
|
// Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
|
|
if (start === undefined || start < 0) {
|
|
start = 0;
|
|
}
|
|
// Return early if start > this.length. Done here to prevent potential uint32
|
|
// coercion fail below.
|
|
if (start > this.length) {
|
|
return ''
|
|
}
|
|
|
|
if (end === undefined || end > this.length) {
|
|
end = this.length;
|
|
}
|
|
|
|
if (end <= 0) {
|
|
return ''
|
|
}
|
|
|
|
// Force coersion to uint32. This will also coerce falsey/NaN values to 0.
|
|
end >>>= 0;
|
|
start >>>= 0;
|
|
|
|
if (end <= start) {
|
|
return ''
|
|
}
|
|
|
|
if (!encoding) encoding = 'utf8';
|
|
|
|
while (true) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return hexSlice(this, start, end)
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8Slice(this, start, end)
|
|
|
|
case 'ascii':
|
|
return asciiSlice(this, start, end)
|
|
|
|
case 'latin1':
|
|
case 'binary':
|
|
return latin1Slice(this, start, end)
|
|
|
|
case 'base64':
|
|
return base64Slice(this, start, end)
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return utf16leSlice(this, start, end)
|
|
|
|
default:
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
encoding = (encoding + '').toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect
|
|
// Buffer instances.
|
|
Buffer.prototype._isBuffer = true;
|
|
|
|
function swap (b, n, m) {
|
|
var i = b[n];
|
|
b[n] = b[m];
|
|
b[m] = i;
|
|
}
|
|
|
|
Buffer.prototype.swap16 = function swap16 () {
|
|
var len = this.length;
|
|
if (len % 2 !== 0) {
|
|
throw new RangeError('Buffer size must be a multiple of 16-bits')
|
|
}
|
|
for (var i = 0; i < len; i += 2) {
|
|
swap(this, i, i + 1);
|
|
}
|
|
return this
|
|
};
|
|
|
|
Buffer.prototype.swap32 = function swap32 () {
|
|
var len = this.length;
|
|
if (len % 4 !== 0) {
|
|
throw new RangeError('Buffer size must be a multiple of 32-bits')
|
|
}
|
|
for (var i = 0; i < len; i += 4) {
|
|
swap(this, i, i + 3);
|
|
swap(this, i + 1, i + 2);
|
|
}
|
|
return this
|
|
};
|
|
|
|
Buffer.prototype.swap64 = function swap64 () {
|
|
var len = this.length;
|
|
if (len % 8 !== 0) {
|
|
throw new RangeError('Buffer size must be a multiple of 64-bits')
|
|
}
|
|
for (var i = 0; i < len; i += 8) {
|
|
swap(this, i, i + 7);
|
|
swap(this, i + 1, i + 6);
|
|
swap(this, i + 2, i + 5);
|
|
swap(this, i + 3, i + 4);
|
|
}
|
|
return this
|
|
};
|
|
|
|
Buffer.prototype.toString = function toString () {
|
|
var length = this.length | 0;
|
|
if (length === 0) return ''
|
|
if (arguments.length === 0) return utf8Slice(this, 0, length)
|
|
return slowToString.apply(this, arguments)
|
|
};
|
|
|
|
Buffer.prototype.equals = function equals (b) {
|
|
if (!internalIsBuffer(b)) throw new TypeError('Argument must be a Buffer')
|
|
if (this === b) return true
|
|
return Buffer.compare(this, b) === 0
|
|
};
|
|
|
|
Buffer.prototype.inspect = function inspect () {
|
|
var str = '';
|
|
var max = INSPECT_MAX_BYTES;
|
|
if (this.length > 0) {
|
|
str = this.toString('hex', 0, max).match(/.{2}/g).join(' ');
|
|
if (this.length > max) str += ' ... ';
|
|
}
|
|
return '<Buffer ' + str + '>'
|
|
};
|
|
|
|
Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
|
|
if (!internalIsBuffer(target)) {
|
|
throw new TypeError('Argument must be a Buffer')
|
|
}
|
|
|
|
if (start === undefined) {
|
|
start = 0;
|
|
}
|
|
if (end === undefined) {
|
|
end = target ? target.length : 0;
|
|
}
|
|
if (thisStart === undefined) {
|
|
thisStart = 0;
|
|
}
|
|
if (thisEnd === undefined) {
|
|
thisEnd = this.length;
|
|
}
|
|
|
|
if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
|
|
throw new RangeError('out of range index')
|
|
}
|
|
|
|
if (thisStart >= thisEnd && start >= end) {
|
|
return 0
|
|
}
|
|
if (thisStart >= thisEnd) {
|
|
return -1
|
|
}
|
|
if (start >= end) {
|
|
return 1
|
|
}
|
|
|
|
start >>>= 0;
|
|
end >>>= 0;
|
|
thisStart >>>= 0;
|
|
thisEnd >>>= 0;
|
|
|
|
if (this === target) return 0
|
|
|
|
var x = thisEnd - thisStart;
|
|
var y = end - start;
|
|
var len = Math.min(x, y);
|
|
|
|
var thisCopy = this.slice(thisStart, thisEnd);
|
|
var targetCopy = target.slice(start, end);
|
|
|
|
for (var i = 0; i < len; ++i) {
|
|
if (thisCopy[i] !== targetCopy[i]) {
|
|
x = thisCopy[i];
|
|
y = targetCopy[i];
|
|
break
|
|
}
|
|
}
|
|
|
|
if (x < y) return -1
|
|
if (y < x) return 1
|
|
return 0
|
|
};
|
|
|
|
// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
|
|
// OR the last index of `val` in `buffer` at offset <= `byteOffset`.
|
|
//
|
|
// Arguments:
|
|
// - buffer - a Buffer to search
|
|
// - val - a string, Buffer, or number
|
|
// - byteOffset - an index into `buffer`; will be clamped to an int32
|
|
// - encoding - an optional encoding, relevant is val is a string
|
|
// - dir - true for indexOf, false for lastIndexOf
|
|
function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
|
|
// Empty buffer means no match
|
|
if (buffer.length === 0) return -1
|
|
|
|
// Normalize byteOffset
|
|
if (typeof byteOffset === 'string') {
|
|
encoding = byteOffset;
|
|
byteOffset = 0;
|
|
} else if (byteOffset > 0x7fffffff) {
|
|
byteOffset = 0x7fffffff;
|
|
} else if (byteOffset < -0x80000000) {
|
|
byteOffset = -0x80000000;
|
|
}
|
|
byteOffset = +byteOffset; // Coerce to Number.
|
|
if (isNaN(byteOffset)) {
|
|
// byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
|
|
byteOffset = dir ? 0 : (buffer.length - 1);
|
|
}
|
|
|
|
// Normalize byteOffset: negative offsets start from the end of the buffer
|
|
if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
|
|
if (byteOffset >= buffer.length) {
|
|
if (dir) return -1
|
|
else byteOffset = buffer.length - 1;
|
|
} else if (byteOffset < 0) {
|
|
if (dir) byteOffset = 0;
|
|
else return -1
|
|
}
|
|
|
|
// Normalize val
|
|
if (typeof val === 'string') {
|
|
val = Buffer.from(val, encoding);
|
|
}
|
|
|
|
// Finally, search either indexOf (if dir is true) or lastIndexOf
|
|
if (internalIsBuffer(val)) {
|
|
// Special case: looking for empty string/buffer always fails
|
|
if (val.length === 0) {
|
|
return -1
|
|
}
|
|
return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
|
|
} else if (typeof val === 'number') {
|
|
val = val & 0xFF; // Search for a byte value [0-255]
|
|
if (Buffer.TYPED_ARRAY_SUPPORT &&
|
|
typeof Uint8Array.prototype.indexOf === 'function') {
|
|
if (dir) {
|
|
return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
|
|
} else {
|
|
return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
|
|
}
|
|
}
|
|
return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
|
|
}
|
|
|
|
throw new TypeError('val must be string, number or Buffer')
|
|
}
|
|
|
|
function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
|
|
var indexSize = 1;
|
|
var arrLength = arr.length;
|
|
var valLength = val.length;
|
|
|
|
if (encoding !== undefined) {
|
|
encoding = String(encoding).toLowerCase();
|
|
if (encoding === 'ucs2' || encoding === 'ucs-2' ||
|
|
encoding === 'utf16le' || encoding === 'utf-16le') {
|
|
if (arr.length < 2 || val.length < 2) {
|
|
return -1
|
|
}
|
|
indexSize = 2;
|
|
arrLength /= 2;
|
|
valLength /= 2;
|
|
byteOffset /= 2;
|
|
}
|
|
}
|
|
|
|
function read (buf, i) {
|
|
if (indexSize === 1) {
|
|
return buf[i]
|
|
} else {
|
|
return buf.readUInt16BE(i * indexSize)
|
|
}
|
|
}
|
|
|
|
var i;
|
|
if (dir) {
|
|
var foundIndex = -1;
|
|
for (i = byteOffset; i < arrLength; i++) {
|
|
if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
|
|
if (foundIndex === -1) foundIndex = i;
|
|
if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
|
|
} else {
|
|
if (foundIndex !== -1) i -= i - foundIndex;
|
|
foundIndex = -1;
|
|
}
|
|
}
|
|
} else {
|
|
if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
|
|
for (i = byteOffset; i >= 0; i--) {
|
|
var found = true;
|
|
for (var j = 0; j < valLength; j++) {
|
|
if (read(arr, i + j) !== read(val, j)) {
|
|
found = false;
|
|
break
|
|
}
|
|
}
|
|
if (found) return i
|
|
}
|
|
}
|
|
|
|
return -1
|
|
}
|
|
|
|
Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
|
|
return this.indexOf(val, byteOffset, encoding) !== -1
|
|
};
|
|
|
|
Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
|
|
};
|
|
|
|
Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
|
|
return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
|
|
};
|
|
|
|
function hexWrite (buf, string, offset, length) {
|
|
offset = Number(offset) || 0;
|
|
var remaining = buf.length - offset;
|
|
if (!length) {
|
|
length = remaining;
|
|
} else {
|
|
length = Number(length);
|
|
if (length > remaining) {
|
|
length = remaining;
|
|
}
|
|
}
|
|
|
|
// must be an even number of digits
|
|
var strLen = string.length;
|
|
if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')
|
|
|
|
if (length > strLen / 2) {
|
|
length = strLen / 2;
|
|
}
|
|
for (var i = 0; i < length; ++i) {
|
|
var parsed = parseInt(string.substr(i * 2, 2), 16);
|
|
if (isNaN(parsed)) return i
|
|
buf[offset + i] = parsed;
|
|
}
|
|
return i
|
|
}
|
|
|
|
function utf8Write (buf, string, offset, length) {
|
|
return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
|
|
}
|
|
|
|
function asciiWrite (buf, string, offset, length) {
|
|
return blitBuffer(asciiToBytes(string), buf, offset, length)
|
|
}
|
|
|
|
function latin1Write (buf, string, offset, length) {
|
|
return asciiWrite(buf, string, offset, length)
|
|
}
|
|
|
|
function base64Write (buf, string, offset, length) {
|
|
return blitBuffer(base64ToBytes(string), buf, offset, length)
|
|
}
|
|
|
|
function ucs2Write (buf, string, offset, length) {
|
|
return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
|
|
}
|
|
|
|
Buffer.prototype.write = function write (string, offset, length, encoding) {
|
|
// Buffer#write(string)
|
|
if (offset === undefined) {
|
|
encoding = 'utf8';
|
|
length = this.length;
|
|
offset = 0;
|
|
// Buffer#write(string, encoding)
|
|
} else if (length === undefined && typeof offset === 'string') {
|
|
encoding = offset;
|
|
length = this.length;
|
|
offset = 0;
|
|
// Buffer#write(string, offset[, length][, encoding])
|
|
} else if (isFinite(offset)) {
|
|
offset = offset | 0;
|
|
if (isFinite(length)) {
|
|
length = length | 0;
|
|
if (encoding === undefined) encoding = 'utf8';
|
|
} else {
|
|
encoding = length;
|
|
length = undefined;
|
|
}
|
|
// legacy write(string, encoding, offset, length) - remove in v0.13
|
|
} else {
|
|
throw new Error(
|
|
'Buffer.write(string, encoding, offset[, length]) is no longer supported'
|
|
)
|
|
}
|
|
|
|
var remaining = this.length - offset;
|
|
if (length === undefined || length > remaining) length = remaining;
|
|
|
|
if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
|
|
throw new RangeError('Attempt to write outside buffer bounds')
|
|
}
|
|
|
|
if (!encoding) encoding = 'utf8';
|
|
|
|
var loweredCase = false;
|
|
for (;;) {
|
|
switch (encoding) {
|
|
case 'hex':
|
|
return hexWrite(this, string, offset, length)
|
|
|
|
case 'utf8':
|
|
case 'utf-8':
|
|
return utf8Write(this, string, offset, length)
|
|
|
|
case 'ascii':
|
|
return asciiWrite(this, string, offset, length)
|
|
|
|
case 'latin1':
|
|
case 'binary':
|
|
return latin1Write(this, string, offset, length)
|
|
|
|
case 'base64':
|
|
// Warning: maxLength not taken into account in base64Write
|
|
return base64Write(this, string, offset, length)
|
|
|
|
case 'ucs2':
|
|
case 'ucs-2':
|
|
case 'utf16le':
|
|
case 'utf-16le':
|
|
return ucs2Write(this, string, offset, length)
|
|
|
|
default:
|
|
if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
|
|
encoding = ('' + encoding).toLowerCase();
|
|
loweredCase = true;
|
|
}
|
|
}
|
|
};
|
|
|
|
Buffer.prototype.toJSON = function toJSON () {
|
|
return {
|
|
type: 'Buffer',
|
|
data: Array.prototype.slice.call(this._arr || this, 0)
|
|
}
|
|
};
|
|
|
|
function base64Slice (buf, start, end) {
|
|
if (start === 0 && end === buf.length) {
|
|
return fromByteArray(buf)
|
|
} else {
|
|
return fromByteArray(buf.slice(start, end))
|
|
}
|
|
}
|
|
|
|
function utf8Slice (buf, start, end) {
|
|
end = Math.min(buf.length, end);
|
|
var res = [];
|
|
|
|
var i = start;
|
|
while (i < end) {
|
|
var firstByte = buf[i];
|
|
var codePoint = null;
|
|
var bytesPerSequence = (firstByte > 0xEF) ? 4
|
|
: (firstByte > 0xDF) ? 3
|
|
: (firstByte > 0xBF) ? 2
|
|
: 1;
|
|
|
|
if (i + bytesPerSequence <= end) {
|
|
var secondByte, thirdByte, fourthByte, tempCodePoint;
|
|
|
|
switch (bytesPerSequence) {
|
|
case 1:
|
|
if (firstByte < 0x80) {
|
|
codePoint = firstByte;
|
|
}
|
|
break
|
|
case 2:
|
|
secondByte = buf[i + 1];
|
|
if ((secondByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F);
|
|
if (tempCodePoint > 0x7F) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
break
|
|
case 3:
|
|
secondByte = buf[i + 1];
|
|
thirdByte = buf[i + 2];
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F);
|
|
if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
break
|
|
case 4:
|
|
secondByte = buf[i + 1];
|
|
thirdByte = buf[i + 2];
|
|
fourthByte = buf[i + 3];
|
|
if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
|
|
tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F);
|
|
if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
|
|
codePoint = tempCodePoint;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (codePoint === null) {
|
|
// we did not generate a valid codePoint so insert a
|
|
// replacement char (U+FFFD) and advance only 1 byte
|
|
codePoint = 0xFFFD;
|
|
bytesPerSequence = 1;
|
|
} else if (codePoint > 0xFFFF) {
|
|
// encode to utf16 (surrogate pair dance)
|
|
codePoint -= 0x10000;
|
|
res.push(codePoint >>> 10 & 0x3FF | 0xD800);
|
|
codePoint = 0xDC00 | codePoint & 0x3FF;
|
|
}
|
|
|
|
res.push(codePoint);
|
|
i += bytesPerSequence;
|
|
}
|
|
|
|
return decodeCodePointsArray(res)
|
|
}
|
|
|
|
// Based on http://stackoverflow.com/a/22747272/680742, the browser with
|
|
// the lowest limit is Chrome, with 0x10000 args.
|
|
// We go 1 magnitude less, for safety
|
|
var MAX_ARGUMENTS_LENGTH = 0x1000;
|
|
|
|
function decodeCodePointsArray (codePoints) {
|
|
var len = codePoints.length;
|
|
if (len <= MAX_ARGUMENTS_LENGTH) {
|
|
return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
|
|
}
|
|
|
|
// Decode in chunks to avoid "call stack size exceeded".
|
|
var res = '';
|
|
var i = 0;
|
|
while (i < len) {
|
|
res += String.fromCharCode.apply(
|
|
String,
|
|
codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
|
|
);
|
|
}
|
|
return res
|
|
}
|
|
|
|
function asciiSlice (buf, start, end) {
|
|
var ret = '';
|
|
end = Math.min(buf.length, end);
|
|
|
|
for (var i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf[i] & 0x7F);
|
|
}
|
|
return ret
|
|
}
|
|
|
|
function latin1Slice (buf, start, end) {
|
|
var ret = '';
|
|
end = Math.min(buf.length, end);
|
|
|
|
for (var i = start; i < end; ++i) {
|
|
ret += String.fromCharCode(buf[i]);
|
|
}
|
|
return ret
|
|
}
|
|
|
|
function hexSlice (buf, start, end) {
|
|
var len = buf.length;
|
|
|
|
if (!start || start < 0) start = 0;
|
|
if (!end || end < 0 || end > len) end = len;
|
|
|
|
var out = '';
|
|
for (var i = start; i < end; ++i) {
|
|
out += toHex(buf[i]);
|
|
}
|
|
return out
|
|
}
|
|
|
|
function utf16leSlice (buf, start, end) {
|
|
var bytes = buf.slice(start, end);
|
|
var res = '';
|
|
for (var i = 0; i < bytes.length; i += 2) {
|
|
res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
|
|
}
|
|
return res
|
|
}
|
|
|
|
Buffer.prototype.slice = function slice (start, end) {
|
|
var len = this.length;
|
|
start = ~~start;
|
|
end = end === undefined ? len : ~~end;
|
|
|
|
if (start < 0) {
|
|
start += len;
|
|
if (start < 0) start = 0;
|
|
} else if (start > len) {
|
|
start = len;
|
|
}
|
|
|
|
if (end < 0) {
|
|
end += len;
|
|
if (end < 0) end = 0;
|
|
} else if (end > len) {
|
|
end = len;
|
|
}
|
|
|
|
if (end < start) end = start;
|
|
|
|
var newBuf;
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
newBuf = this.subarray(start, end);
|
|
newBuf.__proto__ = Buffer.prototype;
|
|
} else {
|
|
var sliceLen = end - start;
|
|
newBuf = new Buffer(sliceLen, undefined);
|
|
for (var i = 0; i < sliceLen; ++i) {
|
|
newBuf[i] = this[i + start];
|
|
}
|
|
}
|
|
|
|
return newBuf
|
|
};
|
|
|
|
/*
|
|
* Need to make sure that buffer isn't trying to write out of bounds.
|
|
*/
|
|
function checkOffset (offset, ext, length) {
|
|
if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
|
|
if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
|
|
}
|
|
|
|
Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
|
|
offset = offset | 0;
|
|
byteLength = byteLength | 0;
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
|
|
|
var val = this[offset];
|
|
var mul = 1;
|
|
var i = 0;
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
val += this[offset + i] * mul;
|
|
}
|
|
|
|
return val
|
|
};
|
|
|
|
Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
|
|
offset = offset | 0;
|
|
byteLength = byteLength | 0;
|
|
if (!noAssert) {
|
|
checkOffset(offset, byteLength, this.length);
|
|
}
|
|
|
|
var val = this[offset + --byteLength];
|
|
var mul = 1;
|
|
while (byteLength > 0 && (mul *= 0x100)) {
|
|
val += this[offset + --byteLength] * mul;
|
|
}
|
|
|
|
return val
|
|
};
|
|
|
|
Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 1, this.length);
|
|
return this[offset]
|
|
};
|
|
|
|
Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
|
return this[offset] | (this[offset + 1] << 8)
|
|
};
|
|
|
|
Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
|
return (this[offset] << 8) | this[offset + 1]
|
|
};
|
|
|
|
Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
|
|
return ((this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16)) +
|
|
(this[offset + 3] * 0x1000000)
|
|
};
|
|
|
|
Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
|
|
return (this[offset] * 0x1000000) +
|
|
((this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
this[offset + 3])
|
|
};
|
|
|
|
Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
|
|
offset = offset | 0;
|
|
byteLength = byteLength | 0;
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
|
|
|
var val = this[offset];
|
|
var mul = 1;
|
|
var i = 0;
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
val += this[offset + i] * mul;
|
|
}
|
|
mul *= 0x80;
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
|
|
|
|
return val
|
|
};
|
|
|
|
Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
|
|
offset = offset | 0;
|
|
byteLength = byteLength | 0;
|
|
if (!noAssert) checkOffset(offset, byteLength, this.length);
|
|
|
|
var i = byteLength;
|
|
var mul = 1;
|
|
var val = this[offset + --i];
|
|
while (i > 0 && (mul *= 0x100)) {
|
|
val += this[offset + --i] * mul;
|
|
}
|
|
mul *= 0x80;
|
|
|
|
if (val >= mul) val -= Math.pow(2, 8 * byteLength);
|
|
|
|
return val
|
|
};
|
|
|
|
Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 1, this.length);
|
|
if (!(this[offset] & 0x80)) return (this[offset])
|
|
return ((0xff - this[offset] + 1) * -1)
|
|
};
|
|
|
|
Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
|
var val = this[offset] | (this[offset + 1] << 8);
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
};
|
|
|
|
Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 2, this.length);
|
|
var val = this[offset + 1] | (this[offset] << 8);
|
|
return (val & 0x8000) ? val | 0xFFFF0000 : val
|
|
};
|
|
|
|
Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
|
|
return (this[offset]) |
|
|
(this[offset + 1] << 8) |
|
|
(this[offset + 2] << 16) |
|
|
(this[offset + 3] << 24)
|
|
};
|
|
|
|
Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
|
|
return (this[offset] << 24) |
|
|
(this[offset + 1] << 16) |
|
|
(this[offset + 2] << 8) |
|
|
(this[offset + 3])
|
|
};
|
|
|
|
Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
return read(this, offset, true, 23, 4)
|
|
};
|
|
|
|
Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 4, this.length);
|
|
return read(this, offset, false, 23, 4)
|
|
};
|
|
|
|
Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 8, this.length);
|
|
return read(this, offset, true, 52, 8)
|
|
};
|
|
|
|
Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
|
|
if (!noAssert) checkOffset(offset, 8, this.length);
|
|
return read(this, offset, false, 52, 8)
|
|
};
|
|
|
|
function checkInt (buf, value, offset, ext, max, min) {
|
|
if (!internalIsBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
|
|
if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
|
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
|
}
|
|
|
|
Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
byteLength = byteLength | 0;
|
|
if (!noAssert) {
|
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
|
|
checkInt(this, value, offset, byteLength, maxBytes, 0);
|
|
}
|
|
|
|
var mul = 1;
|
|
var i = 0;
|
|
this[offset] = value & 0xFF;
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
this[offset + i] = (value / mul) & 0xFF;
|
|
}
|
|
|
|
return offset + byteLength
|
|
};
|
|
|
|
Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
byteLength = byteLength | 0;
|
|
if (!noAssert) {
|
|
var maxBytes = Math.pow(2, 8 * byteLength) - 1;
|
|
checkInt(this, value, offset, byteLength, maxBytes, 0);
|
|
}
|
|
|
|
var i = byteLength - 1;
|
|
var mul = 1;
|
|
this[offset + i] = value & 0xFF;
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
this[offset + i] = (value / mul) & 0xFF;
|
|
}
|
|
|
|
return offset + byteLength
|
|
};
|
|
|
|
Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0);
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
|
|
this[offset] = (value & 0xff);
|
|
return offset + 1
|
|
};
|
|
|
|
function objectWriteUInt16 (buf, value, offset, littleEndian) {
|
|
if (value < 0) value = 0xffff + value + 1;
|
|
for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {
|
|
buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>
|
|
(littleEndian ? i : 1 - i) * 8;
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff);
|
|
this[offset + 1] = (value >>> 8);
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, true);
|
|
}
|
|
return offset + 2
|
|
};
|
|
|
|
Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0);
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 8);
|
|
this[offset + 1] = (value & 0xff);
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, false);
|
|
}
|
|
return offset + 2
|
|
};
|
|
|
|
function objectWriteUInt32 (buf, value, offset, littleEndian) {
|
|
if (value < 0) value = 0xffffffff + value + 1;
|
|
for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {
|
|
buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff;
|
|
}
|
|
}
|
|
|
|
Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset + 3] = (value >>> 24);
|
|
this[offset + 2] = (value >>> 16);
|
|
this[offset + 1] = (value >>> 8);
|
|
this[offset] = (value & 0xff);
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, true);
|
|
}
|
|
return offset + 4
|
|
};
|
|
|
|
Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0);
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 24);
|
|
this[offset + 1] = (value >>> 16);
|
|
this[offset + 2] = (value >>> 8);
|
|
this[offset + 3] = (value & 0xff);
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, false);
|
|
}
|
|
return offset + 4
|
|
};
|
|
|
|
Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) {
|
|
var limit = Math.pow(2, 8 * byteLength - 1);
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit);
|
|
}
|
|
|
|
var i = 0;
|
|
var mul = 1;
|
|
var sub = 0;
|
|
this[offset] = value & 0xFF;
|
|
while (++i < byteLength && (mul *= 0x100)) {
|
|
if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
|
|
sub = 1;
|
|
}
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
|
|
}
|
|
|
|
return offset + byteLength
|
|
};
|
|
|
|
Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) {
|
|
var limit = Math.pow(2, 8 * byteLength - 1);
|
|
|
|
checkInt(this, value, offset, byteLength, limit - 1, -limit);
|
|
}
|
|
|
|
var i = byteLength - 1;
|
|
var mul = 1;
|
|
var sub = 0;
|
|
this[offset + i] = value & 0xFF;
|
|
while (--i >= 0 && (mul *= 0x100)) {
|
|
if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
|
|
sub = 1;
|
|
}
|
|
this[offset + i] = ((value / mul) >> 0) - sub & 0xFF;
|
|
}
|
|
|
|
return offset + byteLength
|
|
};
|
|
|
|
Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80);
|
|
if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value);
|
|
if (value < 0) value = 0xff + value + 1;
|
|
this[offset] = (value & 0xff);
|
|
return offset + 1
|
|
};
|
|
|
|
Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff);
|
|
this[offset + 1] = (value >>> 8);
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, true);
|
|
}
|
|
return offset + 2
|
|
};
|
|
|
|
Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000);
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 8);
|
|
this[offset + 1] = (value & 0xff);
|
|
} else {
|
|
objectWriteUInt16(this, value, offset, false);
|
|
}
|
|
return offset + 2
|
|
};
|
|
|
|
Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value & 0xff);
|
|
this[offset + 1] = (value >>> 8);
|
|
this[offset + 2] = (value >>> 16);
|
|
this[offset + 3] = (value >>> 24);
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, true);
|
|
}
|
|
return offset + 4
|
|
};
|
|
|
|
Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
|
|
value = +value;
|
|
offset = offset | 0;
|
|
if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000);
|
|
if (value < 0) value = 0xffffffff + value + 1;
|
|
if (Buffer.TYPED_ARRAY_SUPPORT) {
|
|
this[offset] = (value >>> 24);
|
|
this[offset + 1] = (value >>> 16);
|
|
this[offset + 2] = (value >>> 8);
|
|
this[offset + 3] = (value & 0xff);
|
|
} else {
|
|
objectWriteUInt32(this, value, offset, false);
|
|
}
|
|
return offset + 4
|
|
};
|
|
|
|
function checkIEEE754 (buf, value, offset, ext, max, min) {
|
|
if (offset + ext > buf.length) throw new RangeError('Index out of range')
|
|
if (offset < 0) throw new RangeError('Index out of range')
|
|
}
|
|
|
|
function writeFloat (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 4);
|
|
}
|
|
write(buf, value, offset, littleEndian, 23, 4);
|
|
return offset + 4
|
|
}
|
|
|
|
Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, true, noAssert)
|
|
};
|
|
|
|
Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
|
|
return writeFloat(this, value, offset, false, noAssert)
|
|
};
|
|
|
|
function writeDouble (buf, value, offset, littleEndian, noAssert) {
|
|
if (!noAssert) {
|
|
checkIEEE754(buf, value, offset, 8);
|
|
}
|
|
write(buf, value, offset, littleEndian, 52, 8);
|
|
return offset + 8
|
|
}
|
|
|
|
Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, true, noAssert)
|
|
};
|
|
|
|
Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
|
|
return writeDouble(this, value, offset, false, noAssert)
|
|
};
|
|
|
|
// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
|
|
Buffer.prototype.copy = function copy (target, targetStart, start, end) {
|
|
if (!start) start = 0;
|
|
if (!end && end !== 0) end = this.length;
|
|
if (targetStart >= target.length) targetStart = target.length;
|
|
if (!targetStart) targetStart = 0;
|
|
if (end > 0 && end < start) end = start;
|
|
|
|
// Copy 0 bytes; we're done
|
|
if (end === start) return 0
|
|
if (target.length === 0 || this.length === 0) return 0
|
|
|
|
// Fatal error conditions
|
|
if (targetStart < 0) {
|
|
throw new RangeError('targetStart out of bounds')
|
|
}
|
|
if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')
|
|
if (end < 0) throw new RangeError('sourceEnd out of bounds')
|
|
|
|
// Are we oob?
|
|
if (end > this.length) end = this.length;
|
|
if (target.length - targetStart < end - start) {
|
|
end = target.length - targetStart + start;
|
|
}
|
|
|
|
var len = end - start;
|
|
var i;
|
|
|
|
if (this === target && start < targetStart && targetStart < end) {
|
|
// descending copy from end
|
|
for (i = len - 1; i >= 0; --i) {
|
|
target[i + targetStart] = this[i + start];
|
|
}
|
|
} else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {
|
|
// ascending copy from start
|
|
for (i = 0; i < len; ++i) {
|
|
target[i + targetStart] = this[i + start];
|
|
}
|
|
} else {
|
|
Uint8Array.prototype.set.call(
|
|
target,
|
|
this.subarray(start, start + len),
|
|
targetStart
|
|
);
|
|
}
|
|
|
|
return len
|
|
};
|
|
|
|
// Usage:
|
|
// buffer.fill(number[, offset[, end]])
|
|
// buffer.fill(buffer[, offset[, end]])
|
|
// buffer.fill(string[, offset[, end]][, encoding])
|
|
Buffer.prototype.fill = function fill (val, start, end, encoding) {
|
|
// Handle string cases:
|
|
if (typeof val === 'string') {
|
|
if (typeof start === 'string') {
|
|
encoding = start;
|
|
start = 0;
|
|
end = this.length;
|
|
} else if (typeof end === 'string') {
|
|
encoding = end;
|
|
end = this.length;
|
|
}
|
|
if (val.length === 1) {
|
|
var code = val.charCodeAt(0);
|
|
if (code < 256) {
|
|
val = code;
|
|
}
|
|
}
|
|
if (encoding !== undefined && typeof encoding !== 'string') {
|
|
throw new TypeError('encoding must be a string')
|
|
}
|
|
if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
|
|
throw new TypeError('Unknown encoding: ' + encoding)
|
|
}
|
|
} else if (typeof val === 'number') {
|
|
val = val & 255;
|
|
}
|
|
|
|
// Invalid ranges are not set to a default, so can range check early.
|
|
if (start < 0 || this.length < start || this.length < end) {
|
|
throw new RangeError('Out of range index')
|
|
}
|
|
|
|
if (end <= start) {
|
|
return this
|
|
}
|
|
|
|
start = start >>> 0;
|
|
end = end === undefined ? this.length : end >>> 0;
|
|
|
|
if (!val) val = 0;
|
|
|
|
var i;
|
|
if (typeof val === 'number') {
|
|
for (i = start; i < end; ++i) {
|
|
this[i] = val;
|
|
}
|
|
} else {
|
|
var bytes = internalIsBuffer(val)
|
|
? val
|
|
: utf8ToBytes(new Buffer(val, encoding).toString());
|
|
var len = bytes.length;
|
|
for (i = 0; i < end - start; ++i) {
|
|
this[i + start] = bytes[i % len];
|
|
}
|
|
}
|
|
|
|
return this
|
|
};
|
|
|
|
// HELPER FUNCTIONS
|
|
// ================
|
|
|
|
var INVALID_BASE64_RE = /[^+\/0-9A-Za-z-_]/g;
|
|
|
|
function base64clean (str) {
|
|
// Node strips out invalid characters like \n and \t from the string, base64-js does not
|
|
str = stringtrim(str).replace(INVALID_BASE64_RE, '');
|
|
// Node converts strings with length < 2 to ''
|
|
if (str.length < 2) return ''
|
|
// Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
|
|
while (str.length % 4 !== 0) {
|
|
str = str + '=';
|
|
}
|
|
return str
|
|
}
|
|
|
|
function stringtrim (str) {
|
|
if (str.trim) return str.trim()
|
|
return str.replace(/^\s+|\s+$/g, '')
|
|
}
|
|
|
|
function toHex (n) {
|
|
if (n < 16) return '0' + n.toString(16)
|
|
return n.toString(16)
|
|
}
|
|
|
|
function utf8ToBytes (string, units) {
|
|
units = units || Infinity;
|
|
var codePoint;
|
|
var length = string.length;
|
|
var leadSurrogate = null;
|
|
var bytes = [];
|
|
|
|
for (var i = 0; i < length; ++i) {
|
|
codePoint = string.charCodeAt(i);
|
|
|
|
// is surrogate component
|
|
if (codePoint > 0xD7FF && codePoint < 0xE000) {
|
|
// last char was a lead
|
|
if (!leadSurrogate) {
|
|
// no lead yet
|
|
if (codePoint > 0xDBFF) {
|
|
// unexpected trail
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
|
continue
|
|
} else if (i + 1 === length) {
|
|
// unpaired lead
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
|
continue
|
|
}
|
|
|
|
// valid lead
|
|
leadSurrogate = codePoint;
|
|
|
|
continue
|
|
}
|
|
|
|
// 2 leads in a row
|
|
if (codePoint < 0xDC00) {
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
|
leadSurrogate = codePoint;
|
|
continue
|
|
}
|
|
|
|
// valid surrogate pair
|
|
codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000;
|
|
} else if (leadSurrogate) {
|
|
// valid bmp char, but last char was a lead
|
|
if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD);
|
|
}
|
|
|
|
leadSurrogate = null;
|
|
|
|
// encode utf8
|
|
if (codePoint < 0x80) {
|
|
if ((units -= 1) < 0) break
|
|
bytes.push(codePoint);
|
|
} else if (codePoint < 0x800) {
|
|
if ((units -= 2) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0x6 | 0xC0,
|
|
codePoint & 0x3F | 0x80
|
|
);
|
|
} else if (codePoint < 0x10000) {
|
|
if ((units -= 3) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0xC | 0xE0,
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
codePoint & 0x3F | 0x80
|
|
);
|
|
} else if (codePoint < 0x110000) {
|
|
if ((units -= 4) < 0) break
|
|
bytes.push(
|
|
codePoint >> 0x12 | 0xF0,
|
|
codePoint >> 0xC & 0x3F | 0x80,
|
|
codePoint >> 0x6 & 0x3F | 0x80,
|
|
codePoint & 0x3F | 0x80
|
|
);
|
|
} else {
|
|
throw new Error('Invalid code point')
|
|
}
|
|
}
|
|
|
|
return bytes
|
|
}
|
|
|
|
function asciiToBytes (str) {
|
|
var byteArray = [];
|
|
for (var i = 0; i < str.length; ++i) {
|
|
// Node's code seems to be doing this and not & 0x7F..
|
|
byteArray.push(str.charCodeAt(i) & 0xFF);
|
|
}
|
|
return byteArray
|
|
}
|
|
|
|
function utf16leToBytes (str, units) {
|
|
var c, hi, lo;
|
|
var byteArray = [];
|
|
for (var i = 0; i < str.length; ++i) {
|
|
if ((units -= 2) < 0) break
|
|
|
|
c = str.charCodeAt(i);
|
|
hi = c >> 8;
|
|
lo = c % 256;
|
|
byteArray.push(lo);
|
|
byteArray.push(hi);
|
|
}
|
|
|
|
return byteArray
|
|
}
|
|
|
|
|
|
function base64ToBytes (str) {
|
|
return toByteArray(base64clean(str))
|
|
}
|
|
|
|
function blitBuffer (src, dst, offset, length) {
|
|
for (var i = 0; i < length; ++i) {
|
|
if ((i + offset >= dst.length) || (i >= src.length)) break
|
|
dst[i + offset] = src[i];
|
|
}
|
|
return i
|
|
}
|
|
|
|
function isnan (val) {
|
|
return val !== val // eslint-disable-line no-self-compare
|
|
}
|
|
|
|
|
|
// the following is from is-buffer, also by Feross Aboukhadijeh and with same lisence
|
|
// The _isBuffer check is for Safari 5-7 support, because it's missing
|
|
// Object.prototype.constructor. Remove this eventually
|
|
function isBuffer(obj) {
|
|
return obj != null && (!!obj._isBuffer || isFastBuffer(obj) || isSlowBuffer(obj))
|
|
}
|
|
|
|
function isFastBuffer (obj) {
|
|
return !!obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)
|
|
}
|
|
|
|
// For Node v0.10 support. Remove this eventually.
|
|
function isSlowBuffer (obj) {
|
|
return typeof obj.readFloatLE === 'function' && typeof obj.slice === 'function' && isFastBuffer(obj.slice(0, 0))
|
|
}
|
|
|
|
const TRANSACTIONS_FOLDER = `${keySep}.transactions`;
|
|
const LOCK_FILENAME = 'lock';
|
|
const LOCK_FILE_KEY = joinKey(
|
|
TRANSACTIONS_FOLDER, LOCK_FILENAME,
|
|
);
|
|
|
|
const createNodeErrors = {
|
|
indexCannotBeParent: 'Index template cannot be a parent',
|
|
allNonRootNodesMustHaveParent: 'Only the root node may have no parent',
|
|
indexParentMustBeRecordOrRoot: 'An index may only have a record or root as a parent',
|
|
aggregateParentMustBeAnIndex: 'aggregateGroup parent must be an index',
|
|
};
|
|
|
|
const pathRegxMaker = node => () => node.nodeKey().replace(/{id}/g, '[a-zA-Z0-9_-]+');
|
|
|
|
const nodeKeyMaker = node => () => switchCase(
|
|
|
|
[n => isRecord(n) && !isSingleRecord(n),
|
|
n => joinKey(
|
|
node.parent().nodeKey(),
|
|
node.collectionName,
|
|
`${n.nodeId}-{id}`,
|
|
)],
|
|
|
|
[isRoot,
|
|
_.constant('/')],
|
|
|
|
[defaultCase,
|
|
n => joinKey(node.parent().nodeKey(), n.name)],
|
|
|
|
)(node);
|
|
|
|
|
|
const validate$1 = parent => (node) => {
|
|
if (isIndex(node)
|
|
&& isSomething(parent)
|
|
&& !isRoot(parent)
|
|
&& !isRecord(parent)) {
|
|
throw new BadRequestError(createNodeErrors.indexParentMustBeRecordOrRoot);
|
|
}
|
|
|
|
if (isaggregateGroup(node)
|
|
&& isSomething(parent)
|
|
&& !isIndex(parent)) {
|
|
throw new BadRequestError(createNodeErrors.aggregateParentMustBeAnIndex);
|
|
}
|
|
|
|
if (isNothing(parent) && !isRoot(node)) { throw new BadRequestError(createNodeErrors.allNonRootNodesMustHaveParent); }
|
|
|
|
return node;
|
|
};
|
|
|
|
const construct = parent => (node) => {
|
|
node.nodeKey = nodeKeyMaker(node);
|
|
node.pathRegx = pathRegxMaker(node);
|
|
node.parent = _.constant(parent);
|
|
node.isRoot = () => isNothing(parent)
|
|
&& node.name === 'root'
|
|
&& node.type === 'root';
|
|
if (isCollectionRecord(node)) {
|
|
node.collectionNodeKey = () => joinKey(
|
|
parent.nodeKey(), node.collectionName,
|
|
);
|
|
node.collectionPathRegx = () => joinKey(
|
|
parent.pathRegx(), node.collectionName,
|
|
);
|
|
}
|
|
return node;
|
|
};
|
|
|
|
const addToParent = (obj) => {
|
|
const parent = obj.parent();
|
|
if (isSomething(parent)) {
|
|
if (isIndex(obj))
|
|
// Q: why are indexes not children ?
|
|
// A: because they cannot have children of their own.
|
|
{ parent.indexes.push(obj); } else if (isaggregateGroup(obj)) { parent.aggregateGroups.push(obj); } else { parent.children.push(obj); }
|
|
|
|
if (isRecord(obj)) {
|
|
const defaultIndex = _.find(
|
|
parent.indexes,
|
|
i => i.name === `${parent.name}_index`,
|
|
);
|
|
if (defaultIndex) {
|
|
defaultIndex.allowedRecordNodeIds.push(obj.nodeId);
|
|
}
|
|
}
|
|
}
|
|
return obj;
|
|
};
|
|
|
|
const constructNode = (parent, obj) => $(obj, [
|
|
construct(parent),
|
|
validate$1(parent),
|
|
addToParent,
|
|
]);
|
|
|
|
const getNodeId = (parentNode) => {
|
|
// this case is handled better elsewhere
|
|
if (!parentNode) return null;
|
|
const findRoot = n => (isRoot(n) ? n : findRoot(n.parent()));
|
|
const root = findRoot(parentNode);
|
|
|
|
return ($(root, [
|
|
getFlattenedHierarchy,
|
|
fp.map(n => n.nodeId),
|
|
fp.max]) + 1);
|
|
};
|
|
|
|
const constructHierarchy = (node, parent) => {
|
|
construct(parent)(node);
|
|
if (node.indexes) {
|
|
_.each(node.indexes,
|
|
child => constructHierarchy(child, node));
|
|
}
|
|
if (node.aggregateGroups) {
|
|
_.each(node.aggregateGroups,
|
|
child => constructHierarchy(child, node));
|
|
}
|
|
if (node.children && node.children.length > 0) {
|
|
_.each(node.children,
|
|
child => constructHierarchy(child, node));
|
|
}
|
|
if (node.fields) {
|
|
_.each(node.fields,
|
|
f => _.each(f.typeOptions, (val, key) => {
|
|
const def = all$1[f.type].optionDefinitions[key];
|
|
if (!def) {
|
|
// unknown typeOption
|
|
delete f.typeOptions[key];
|
|
} else {
|
|
f.typeOptions[key] = def.parse(val);
|
|
}
|
|
}));
|
|
}
|
|
return node;
|
|
};
|
|
|
|
|
|
const getNewRootLevel = () => construct()({
|
|
name: 'root',
|
|
type: 'root',
|
|
children: [],
|
|
pathMaps: [],
|
|
indexes: [],
|
|
nodeId: 0,
|
|
});
|
|
|
|
const _getNewRecordTemplate = (parent, name, createDefaultIndex, isSingle) => {
|
|
const node = constructNode(parent, {
|
|
name,
|
|
type: 'record',
|
|
fields: [],
|
|
children: [],
|
|
validationRules: [],
|
|
nodeId: getNodeId(parent),
|
|
indexes: [],
|
|
allidsShardFactor: isRecord(parent) ? 1 : 64,
|
|
collectionName: '',
|
|
isSingle,
|
|
});
|
|
|
|
if (createDefaultIndex) {
|
|
const defaultIndex = getNewIndexTemplate(parent);
|
|
defaultIndex.name = `${name}_index`;
|
|
defaultIndex.allowedRecordNodeIds.push(node.nodeId);
|
|
}
|
|
|
|
return node;
|
|
};
|
|
|
|
const getNewRecordTemplate = (parent, name = '', createDefaultIndex = true) => _getNewRecordTemplate(parent, name, createDefaultIndex, false);
|
|
|
|
const getNewSingleRecordTemplate = parent => _getNewRecordTemplate(parent, '', false, true);
|
|
|
|
const getNewIndexTemplate = (parent, type = 'ancestor') => constructNode(parent, {
|
|
name: '',
|
|
type: 'index',
|
|
map: 'return {...record};',
|
|
filter: '',
|
|
indexType: type,
|
|
getShardName: '',
|
|
getSortKey: 'record.id',
|
|
aggregateGroups: [],
|
|
allowedRecordNodeIds: [],
|
|
nodeId: getNodeId(parent),
|
|
});
|
|
|
|
const getNewAggregateGroupTemplate = index => constructNode(index, {
|
|
name: '',
|
|
type: 'aggregateGroup',
|
|
groupBy: '',
|
|
aggregates: [],
|
|
condition: '',
|
|
nodeId: getNodeId(index),
|
|
});
|
|
|
|
const getNewAggregateTemplate = (set) => {
|
|
const aggregatedValue = {
|
|
name: '',
|
|
aggregatedValue: '',
|
|
};
|
|
set.aggregates.push(aggregatedValue);
|
|
return aggregatedValue;
|
|
};
|
|
|
|
const fieldErrors = {
|
|
AddFieldValidationFailed: 'Add field validation: ',
|
|
};
|
|
|
|
const allowedTypes = () => fp.keys(all$1);
|
|
|
|
const getNewField = type => ({
|
|
name: '', // how field is referenced internally
|
|
type,
|
|
typeOptions: getDefaultOptions$1(type),
|
|
label: '', // how field is displayed
|
|
getInitialValue: 'default', // function that gets value when initially created
|
|
getUndefinedValue: 'default', // function that gets value when field undefined on record
|
|
});
|
|
|
|
const fieldRules = allFields => [
|
|
makerule('name', 'field name is not set',
|
|
f => isNonEmptyString(f.name)),
|
|
makerule('type', 'field type is not set',
|
|
f => isNonEmptyString(f.type)),
|
|
makerule('label', 'field label is not set',
|
|
f => isNonEmptyString(f.label)),
|
|
makerule('getInitialValue', 'getInitialValue function is not set',
|
|
f => isNonEmptyString(f.getInitialValue)),
|
|
makerule('getUndefinedValue', 'getUndefinedValue function is not set',
|
|
f => isNonEmptyString(f.getUndefinedValue)),
|
|
makerule('name', 'field name is duplicated',
|
|
f => isNothingOrEmpty(f.name)
|
|
|| fp.countBy('name')(allFields)[f.name] === 1),
|
|
makerule('type', 'type is unknown',
|
|
f => isNothingOrEmpty(f.type)
|
|
|| fp.some(t => f.type === t)(allowedTypes())),
|
|
];
|
|
|
|
const typeOptionsRules = (field) => {
|
|
const type = all$1[field.type];
|
|
if (isNothing(type)) return [];
|
|
|
|
const def = optName => type.optionDefinitions[optName];
|
|
|
|
return $(field.typeOptions, [
|
|
fp.keys,
|
|
fp.filter(o => isSomething(def(o))
|
|
&& isSomething(def(o).isValid)),
|
|
fp.map(o => makerule(
|
|
`typeOptions.${o}`,
|
|
`${def(o).requirementDescription}`,
|
|
field => def(o).isValid(field.typeOptions[o]),
|
|
)),
|
|
]);
|
|
};
|
|
|
|
const validateField = allFields => (field) => {
|
|
const everySingleField = fp.includes(field)(allFields) ? allFields : [...allFields, field];
|
|
return applyRuleSet([...fieldRules(everySingleField), ...typeOptionsRules(field)])(field);
|
|
};
|
|
|
|
const validateAllFields = recordNode => $(recordNode.fields, [
|
|
fp.map(validateField(recordNode.fields)),
|
|
fp.flatten,
|
|
]);
|
|
|
|
const addField = (recordTemplate, field) => {
|
|
if (isNothingOrEmpty(field.label)) {
|
|
field.label = field.name;
|
|
}
|
|
const validationMessages = validateField([...recordTemplate.fields, field])(field);
|
|
if (validationMessages.length > 0) {
|
|
const errors = fp.map(m => m.error)(validationMessages);
|
|
throw new BadRequestError(`${fieldErrors.AddFieldValidationFailed} ${errors.join(', ')}`);
|
|
}
|
|
recordTemplate.fields.push(field);
|
|
};
|
|
|
|
const getNewRecordValidationRule = (invalidFields,
|
|
messageWhenInvalid,
|
|
expressionWhenValid) => ({
|
|
invalidFields, messageWhenInvalid, expressionWhenValid,
|
|
});
|
|
|
|
const getStaticValue = switchCase(
|
|
[fp.isNumber, v => v.toString()],
|
|
[fp.isBoolean, v => v.toString()],
|
|
[fp.defaultCase, v => `'${v}'`],
|
|
);
|
|
|
|
const commonRecordValidationRules = ({
|
|
|
|
fieldNotEmpty: fieldName => getNewRecordValidationRule(
|
|
[fieldName],
|
|
`${fieldName} is empty`,
|
|
`!_.isEmpty(record['${fieldName}'])`,
|
|
),
|
|
|
|
fieldBetween: (fieldName, min, max) => getNewRecordValidationRule(
|
|
[fieldName],
|
|
`${fieldName} must be between ${min.toString()} and ${max.toString()}`,
|
|
`record['${fieldName}'] >= ${getStaticValue(min)} && record['${fieldName}'] <= ${getStaticValue(max)} `,
|
|
),
|
|
|
|
fieldGreaterThan: (fieldName, min, max) => getNewRecordValidationRule(
|
|
[fieldName],
|
|
`${fieldName} must be greater than ${min.toString()} and ${max.toString()}`,
|
|
`record['${fieldName}'] >= ${getStaticValue(min)} `,
|
|
),
|
|
});
|
|
|
|
const addRecordValidationRule = recordNode => rule => recordNode.validationRules.push(rule);
|
|
|
|
const createTrigger = () => ({
|
|
actionName: '',
|
|
eventName: '',
|
|
// function, has access to event context,
|
|
// returns object that is used as parameter to action
|
|
// only used if triggered by event
|
|
optionsCreator: '',
|
|
// action runs if true,
|
|
// has access to event context
|
|
condition: '',
|
|
});
|
|
|
|
const createAction = () => ({
|
|
name: '',
|
|
behaviourSource: '',
|
|
// name of function in actionSource
|
|
behaviourName: '',
|
|
// parameter passed into behaviour.
|
|
// any other parms passed at runtime e.g.
|
|
// by trigger, or manually, will be merged into this
|
|
initialOptions: {},
|
|
});
|
|
|
|
const aggregateRules = [
|
|
makerule('name', 'choose a name for the aggregate',
|
|
a => isNonEmptyString(a.name)),
|
|
makerule('aggregatedValue', 'aggregatedValue does not compile',
|
|
a => _.isEmpty(a.aggregatedValue)
|
|
|| executesWithoutException(
|
|
() => compilerUtil.compileCode(a.aggregatedValue),
|
|
)),
|
|
];
|
|
|
|
const validateAggregate = aggregate => applyRuleSet(aggregateRules)(aggregate);
|
|
|
|
const validateAllAggregates = all => $(all, [
|
|
fp.map(validateAggregate),
|
|
fp.flatten,
|
|
]);
|
|
|
|
const ruleSet = (...sets) => fp.constant(fp.flatten([...sets]));
|
|
|
|
const commonRules = [
|
|
makerule('name', 'node name is not set',
|
|
node => stringNotEmpty(node.name)),
|
|
makerule('type', 'node type not recognised',
|
|
anyTrue(isRecord, isRoot, isIndex, isaggregateGroup)),
|
|
];
|
|
|
|
const recordRules = [
|
|
makerule('fields', 'no fields have been added to the record',
|
|
node => isNonEmptyArray(node.fields)),
|
|
makerule('validationRules', "validation rule is missing a 'messageWhenValid' member",
|
|
node => fp.every(r => _.has(r, 'messageWhenInvalid'))(node.validationRules)),
|
|
makerule('validationRules', "validation rule is missing a 'expressionWhenValid' member",
|
|
node => fp.every(r => _.has(r, 'expressionWhenValid'))(node.validationRules)),
|
|
];
|
|
|
|
|
|
const aggregateGroupRules = [
|
|
makerule('condition', 'condition does not compile',
|
|
a => fp.isEmpty(a.condition)
|
|
|| executesWithoutException(
|
|
() => compilerUtil.compileExpression(a.condition),
|
|
)),
|
|
];
|
|
|
|
const getRuleSet = node => switchCase(
|
|
|
|
[isRecord, ruleSet(
|
|
commonRules,
|
|
recordRules,
|
|
)],
|
|
|
|
[isIndex, ruleSet(
|
|
commonRules,
|
|
indexRuleSet,
|
|
)],
|
|
|
|
[isaggregateGroup, ruleSet(
|
|
commonRules,
|
|
aggregateGroupRules,
|
|
)],
|
|
|
|
[defaultCase, ruleSet(commonRules, [])],
|
|
)(node);
|
|
|
|
const validateNode = node => applyRuleSet(getRuleSet(node))(node);
|
|
|
|
const validateAll = (appHierarchy) => {
|
|
const flattened = getFlattenedHierarchy(
|
|
appHierarchy,
|
|
);
|
|
|
|
const duplicateNameRule = makerule(
|
|
'name', 'node names must be unique under shared parent',
|
|
n => fp.filter(f => f.parent() === n.parent()
|
|
&& f.name === n.name)(flattened).length === 1,
|
|
);
|
|
|
|
const duplicateNodeKeyErrors = $(flattened, [
|
|
fp.map(n => applyRuleSet([duplicateNameRule])(n)),
|
|
fp.filter(isSomething),
|
|
fp.flatten,
|
|
]);
|
|
|
|
const fieldErrors = $(flattened, [
|
|
fp.filter(isRecord),
|
|
fp.map(validateAllFields),
|
|
fp.flatten,
|
|
]);
|
|
|
|
const aggregateErrors = $(flattened, [
|
|
fp.filter(isaggregateGroup),
|
|
fp.map(s => validateAllAggregates(
|
|
s.aggregates,
|
|
)),
|
|
fp.flatten,
|
|
]);
|
|
|
|
return $(flattened, [
|
|
fp.map(validateNode),
|
|
fp.flatten,
|
|
fp.union(duplicateNodeKeyErrors),
|
|
fp.union(fieldErrors),
|
|
fp.union(aggregateErrors),
|
|
]);
|
|
};
|
|
|
|
const actionRules = [
|
|
makerule('name', 'action must have a name',
|
|
a => isNonEmptyString(a.name)),
|
|
makerule('behaviourName', 'must supply a behaviour name to the action',
|
|
a => isNonEmptyString(a.behaviourName)),
|
|
makerule('behaviourSource', 'must supply a behaviour source for the action',
|
|
a => isNonEmptyString(a.behaviourSource)),
|
|
];
|
|
|
|
const duplicateActionRule = makerule('', 'action name must be unique', () => {});
|
|
|
|
const validateAction = action => applyRuleSet(actionRules)(action);
|
|
|
|
|
|
const validateActions = (allActions) => {
|
|
const duplicateActions = $(allActions, [
|
|
fp.filter(a => fp.filter(a2 => a2.name === a.name)(allActions).length > 1),
|
|
fp.map(a => validationError(duplicateActionRule, a)),
|
|
]);
|
|
|
|
const errors = $(allActions, [
|
|
fp.map(validateAction),
|
|
fp.flatten,
|
|
fp.union(duplicateActions),
|
|
fp.uniqBy('name'),
|
|
]);
|
|
|
|
return errors;
|
|
};
|
|
|
|
const triggerRules = actions => ([
|
|
makerule('actionName', 'must specify an action',
|
|
t => isNonEmptyString(t.actionName)),
|
|
makerule('eventName', 'must specify and event',
|
|
t => isNonEmptyString(t.eventName)),
|
|
makerule('actionName', 'specified action not supplied',
|
|
t => !t.actionName
|
|
|| fp.some(a => a.name === t.actionName)(actions)),
|
|
makerule('eventName', 'invalid Event Name',
|
|
t => !t.eventName
|
|
|| fp.includes(t.eventName)(eventsList)),
|
|
makerule('optionsCreator', 'Options Creator does not compile - check your expression',
|
|
(t) => {
|
|
if (!t.optionsCreator) return true;
|
|
try {
|
|
compilerUtil.compileCode(t.optionsCreator);
|
|
return true;
|
|
} catch (_) { return false; }
|
|
}),
|
|
makerule('condition', 'Trigger condition does not compile - check your expression',
|
|
(t) => {
|
|
if (!t.condition) return true;
|
|
try {
|
|
compilerUtil.compileExpression(t.condition);
|
|
return true;
|
|
} catch (_) { return false; }
|
|
}),
|
|
]);
|
|
|
|
const validateTrigger = (trigger, allActions) => {
|
|
const errors = applyRuleSet(triggerRules(allActions))(trigger);
|
|
|
|
return errors;
|
|
};
|
|
|
|
const validateTriggers = (triggers, allActions) => $(triggers, [
|
|
fp.map(t => validateTrigger(t, allActions)),
|
|
fp.flatten,
|
|
]);
|
|
|
|
const getApplicationDefinition = datastore => async () => {
|
|
const exists = await datastore.exists(appDefinitionFile);
|
|
|
|
if (!exists) throw new Error('Application definition does not exist');
|
|
|
|
const appDefinition = await datastore.loadJson(appDefinitionFile);
|
|
appDefinition.hierarchy = constructHierarchy(
|
|
appDefinition.hierarchy,
|
|
);
|
|
return appDefinition;
|
|
};
|
|
|
|
const saveApplicationHierarchy = app => async hierarchy => apiWrapper(
|
|
app,
|
|
events.templateApi.saveApplicationHierarchy,
|
|
permission.writeTemplates.isAuthorized,
|
|
{ hierarchy },
|
|
_saveApplicationHierarchy, app.datastore, hierarchy,
|
|
);
|
|
|
|
|
|
const _saveApplicationHierarchy = async (datastore, hierarchy) => {
|
|
const validationErrors = await validateAll(hierarchy);
|
|
if (validationErrors.length > 0) {
|
|
throw new Error(`Hierarchy is invalid: ${_.join(
|
|
validationErrors.map(e => `${e.item.nodeKey ? e.item.nodeKey() : ''} : ${e.error}`),
|
|
',',
|
|
)}`);
|
|
}
|
|
|
|
if (await datastore.exists(appDefinitionFile)) {
|
|
const appDefinition = await datastore.loadJson(appDefinitionFile);
|
|
appDefinition.hierarchy = hierarchy;
|
|
await datastore.updateJson(appDefinitionFile, appDefinition);
|
|
} else {
|
|
await datastore.createFolder('/.config');
|
|
const appDefinition = { actions: [], triggers: [], hierarchy };
|
|
await datastore.createJson(appDefinitionFile, appDefinition);
|
|
}
|
|
};
|
|
|
|
const saveActionsAndTriggers = app => async (actions, triggers) => apiWrapper(
|
|
app,
|
|
events.templateApi.saveActionsAndTriggers,
|
|
permission.writeTemplates.isAuthorized,
|
|
{ actions, triggers },
|
|
_saveActionsAndTriggers, app.datastore, actions, triggers,
|
|
);
|
|
|
|
const _saveActionsAndTriggers = async (datastore, actions, triggers) => {
|
|
if (await datastore.exists(appDefinitionFile)) {
|
|
const appDefinition = await datastore.loadJson(appDefinitionFile);
|
|
appDefinition.actions = actions;
|
|
appDefinition.triggers = triggers;
|
|
|
|
const actionValidErrs = fp.map(e => e.error)(validateActions(actions));
|
|
|
|
if (actionValidErrs.length > 0) {
|
|
throw new BadRequestError(`Actions are invalid: ${_.join(actionValidErrs, ', ')}`);
|
|
}
|
|
|
|
const triggerValidErrs = fp.map(e => e.error)(validateTriggers(triggers, actions));
|
|
|
|
if (triggerValidErrs.length > 0) {
|
|
throw new BadRequestError(`Triggers are invalid: ${_.join(triggerValidErrs, ', ')}`);
|
|
}
|
|
|
|
await datastore.updateJson(appDefinitionFile, appDefinition);
|
|
} else {
|
|
throw new BadRequestError('Cannot save actions: Application definition does not exist');
|
|
}
|
|
};
|
|
|
|
const getBehaviourSources = async (datastore) => {
|
|
await datastore.loadFile('/.config/behaviourSources.js');
|
|
};
|
|
|
|
const api$1 = app => ({
|
|
|
|
getApplicationDefinition: getApplicationDefinition(app.datastore),
|
|
saveApplicationHierarchy: saveApplicationHierarchy(app),
|
|
saveActionsAndTriggers: saveActionsAndTriggers(app),
|
|
getBehaviourSources: () => getBehaviourSources(app.datastore),
|
|
getNewRootLevel,
|
|
constructNode,
|
|
getNewIndexTemplate,
|
|
getNewRecordTemplate,
|
|
getNewField,
|
|
validateField,
|
|
addField,
|
|
fieldErrors,
|
|
getNewRecordValidationRule,
|
|
commonRecordValidationRules,
|
|
addRecordValidationRule,
|
|
createAction,
|
|
createTrigger,
|
|
validateActions,
|
|
validateTrigger,
|
|
getNewAggregateGroupTemplate,
|
|
getNewAggregateTemplate,
|
|
constructHierarchy,
|
|
getNewSingleRecordTemplate,
|
|
allTypes: all$1,
|
|
validateNode,
|
|
validateAll,
|
|
validateTriggers,
|
|
});
|
|
|
|
|
|
const getTemplateApi = app => api$1(app);
|
|
|
|
const getUsers = app => async () => apiWrapper(
|
|
app,
|
|
events.authApi.getUsers,
|
|
permission.listUsers.isAuthorized,
|
|
{},
|
|
_getUsers, app,
|
|
);
|
|
|
|
const _getUsers = async app => $(await app.datastore.loadJson(USERS_LIST_FILE), [
|
|
fp.map(stripUserOfSensitiveStuff),
|
|
]);
|
|
|
|
const loadAccessLevels = app => async () => apiWrapper(
|
|
app,
|
|
events.authApi.loadAccessLevels,
|
|
permission.listAccessLevels.isAuthorized,
|
|
{},
|
|
_loadAccessLevels, app,
|
|
);
|
|
|
|
const _loadAccessLevels = async app => await app.datastore.loadJson(ACCESS_LEVELS_FILE);
|
|
|
|
const dummyHash = '$argon2i$v=19$m=4096,t=3,p=1$UZRo409UYBGjHJS3CV6Uxw$rU84qUqPeORFzKYmYY0ceBLDaPO+JWSH4PfNiKXfIKk';
|
|
|
|
const authenticate = app => async (username, password) => apiWrapper(
|
|
app,
|
|
events.authApi.authenticate,
|
|
alwaysAuthorized,
|
|
{ username, password },
|
|
_authenticate, app, username, password,
|
|
);
|
|
|
|
const _authenticate = async (app, username, password) => {
|
|
if (isNothingOrEmpty(username) || isNothingOrEmpty(password)) { return null; }
|
|
|
|
const allUsers = await _getUsers(app);
|
|
let user = getUserByName(
|
|
allUsers,
|
|
username,
|
|
);
|
|
|
|
const notAUser = 'not-a-user';
|
|
// continue with non-user - so time to verify remains consistent
|
|
// with verification of a valid user
|
|
if (!user || !user.enabled) { user = notAUser; }
|
|
|
|
let userAuth;
|
|
try {
|
|
userAuth = await app.datastore.loadJson(
|
|
userAuthFile(username),
|
|
);
|
|
} catch (_) {
|
|
userAuth = { accessLevels: [], passwordHash: dummyHash };
|
|
}
|
|
|
|
const permissions = await buildUserPermissions(app, user.accessLevels);
|
|
|
|
const verified = await app.crypto.verify(
|
|
userAuth.passwordHash,
|
|
password,
|
|
);
|
|
|
|
if (user === notAUser) { return null; }
|
|
|
|
return verified
|
|
? {
|
|
...user, permissions, temp: false, isUser: true,
|
|
}
|
|
: null;
|
|
};
|
|
|
|
const authenticateTemporaryAccess = app => async (tempAccessCode) => {
|
|
if (isNothingOrEmpty(tempAccessCode)) { return null; }
|
|
|
|
const temp = parseTemporaryCode(tempAccessCode);
|
|
let user = $(await _getUsers(app), [
|
|
fp.find(u => u.temporaryAccessId === temp.id),
|
|
]);
|
|
|
|
const notAUser = 'not-a-user';
|
|
if (!user || !user.enabled) { user = notAUser; }
|
|
|
|
let userAuth;
|
|
try {
|
|
userAuth = await app.datastore.loadJson(
|
|
userAuthFile(user.name),
|
|
);
|
|
} catch (e) {
|
|
userAuth = {
|
|
temporaryAccessHash: dummyHash,
|
|
temporaryAccessExpiryEpoch: (await app.getEpochTime() + 10000),
|
|
};
|
|
}
|
|
|
|
if (userAuth.temporaryAccessExpiryEpoch < await app.getEpochTime()) { user = notAUser; }
|
|
|
|
const tempCode = !temp.code ? shortid.generate() : temp.code;
|
|
const verified = await app.crypto.verify(
|
|
userAuth.temporaryAccessHash,
|
|
tempCode,
|
|
);
|
|
|
|
if (user === notAUser) { return null; }
|
|
|
|
return verified
|
|
? {
|
|
...user,
|
|
permissions: [],
|
|
temp: true,
|
|
isUser: true,
|
|
}
|
|
: null;
|
|
};
|
|
|
|
const buildUserPermissions = async (app, userAccessLevels) => {
|
|
const allAccessLevels = await _loadAccessLevels(app);
|
|
|
|
return $(allAccessLevels.levels, [
|
|
fp.filter(l => fp.some(ua => l.name === ua)(userAccessLevels)),
|
|
fp.map(l => l.permissions),
|
|
fp.flatten,
|
|
]);
|
|
};
|
|
|
|
const createTemporaryAccess$1 = app => async userName => apiWrapper(
|
|
app,
|
|
events.authApi.createTemporaryAccess,
|
|
alwaysAuthorized,
|
|
{ userName },
|
|
_createTemporaryAccess, app, userName,
|
|
);
|
|
|
|
const _createTemporaryAccess = async (app, userName) => {
|
|
const tempCode = await getTemporaryCode(app);
|
|
|
|
const lock = await getLock(
|
|
app, USERS_LOCK_FILE, 1000, 2,
|
|
);
|
|
|
|
if (isNolock(lock)) { throw new Error('Unable to create temporary access, could not get lock - try again'); }
|
|
|
|
try {
|
|
const users = await app.datastore.loadJson(USERS_LIST_FILE);
|
|
|
|
const user = getUserByName(users, userName);
|
|
user.temporaryAccessId = tempCode.temporaryAccessId;
|
|
|
|
await app.datastore.updateJson(
|
|
USERS_LIST_FILE,
|
|
users,
|
|
);
|
|
} finally {
|
|
await releaseLock(app, lock);
|
|
}
|
|
|
|
const userAuth = await app.datastore.loadJson(
|
|
userAuthFile(userName),
|
|
);
|
|
userAuth.temporaryAccessHash = tempCode.temporaryAccessHash;
|
|
|
|
userAuth.temporaryAccessExpiryEpoch = tempCode.temporaryAccessExpiryEpoch;
|
|
|
|
await app.datastore.updateJson(
|
|
userAuthFile(userName),
|
|
userAuth,
|
|
);
|
|
|
|
return tempCode.tempCode;
|
|
};
|
|
|
|
const getTemporaryCode = async (app) => {
|
|
const tempCode = shortid.generate()
|
|
+ shortid.generate()
|
|
+ shortid.generate()
|
|
+ shortid.generate();
|
|
|
|
const tempId = shortid.generate();
|
|
|
|
return {
|
|
temporaryAccessHash: await app.crypto.hash(
|
|
tempCode,
|
|
),
|
|
temporaryAccessExpiryEpoch:
|
|
(await app.getEpochTime()) + tempCodeExpiryLength,
|
|
tempCode: `tmp:${tempId}:${tempCode}`,
|
|
temporaryAccessId: tempId,
|
|
};
|
|
};
|
|
|
|
const userRules = allUsers => [
|
|
makerule('name', 'username must be set',
|
|
u => isNonEmptyString(u.name)),
|
|
makerule('accessLevels', 'user must have at least one access level',
|
|
u => u.accessLevels.length > 0),
|
|
makerule('name', 'username must be unique',
|
|
u => fp.filter(u2 => insensitiveEquals(u2.name, u.name))(allUsers).length === 1),
|
|
makerule('accessLevels', 'access levels must only contain stings',
|
|
u => all(isNonEmptyString)(u.accessLevels)),
|
|
];
|
|
|
|
const validateUser = () => (allusers, user) => applyRuleSet(userRules(allusers))(user);
|
|
|
|
const getNewUser = app => () => apiWrapperSync(
|
|
app,
|
|
events.authApi.getNewUser,
|
|
permission.createUser.isAuthorized,
|
|
{},
|
|
_getNewUser, app,
|
|
);
|
|
|
|
const _getNewUser = () => ({
|
|
name: '',
|
|
accessLevels: [],
|
|
enabled: true,
|
|
temporaryAccessId: '',
|
|
});
|
|
|
|
const getNewUserAuth = app => () => apiWrapperSync(
|
|
app,
|
|
events.authApi.getNewUserAuth,
|
|
permission.createUser.isAuthorized,
|
|
{},
|
|
_getNewUserAuth, app,
|
|
);
|
|
|
|
const _getNewUserAuth = () => ({
|
|
passwordHash: '',
|
|
temporaryAccessHash: '',
|
|
temporaryAccessExpiryEpoch: 0,
|
|
});
|
|
|
|
const isValidPassword = app => password => apiWrapperSync(
|
|
app,
|
|
events.authApi.isValidPassword,
|
|
alwaysAuthorized,
|
|
{ password },
|
|
_isValidPassword, app, password,
|
|
);
|
|
|
|
const _isValidPassword = (app, password) => scorePassword(password).score > 30;
|
|
|
|
const changeMyPassword = app => async (currentPw, newpassword) => apiWrapper(
|
|
app,
|
|
events.authApi.changeMyPassword,
|
|
alwaysAuthorized,
|
|
{ currentPw, newpassword },
|
|
_changeMyPassword, app, currentPw, newpassword,
|
|
);
|
|
|
|
const _changeMyPassword = async (app, currentPw, newpassword) => {
|
|
const existingAuth = await app.datastore.loadJson(
|
|
userAuthFile(app.user.name),
|
|
);
|
|
|
|
if (isSomething(existingAuth.passwordHash)) {
|
|
const verified = await app.crypto.verify(
|
|
existingAuth.passwordHash,
|
|
currentPw,
|
|
);
|
|
|
|
if (verified) {
|
|
await await doSet(
|
|
app, existingAuth,
|
|
app.user.name, newpassword,
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
const setPasswordFromTemporaryCode = app => async (tempCode, newpassword) => apiWrapper(
|
|
app,
|
|
events.authApi.setPasswordFromTemporaryCode,
|
|
alwaysAuthorized,
|
|
{ tempCode, newpassword },
|
|
_setPasswordFromTemporaryCode, app, tempCode, newpassword,
|
|
);
|
|
|
|
|
|
const _setPasswordFromTemporaryCode = async (app, tempCode, newpassword) => {
|
|
const currentTime = await app.getEpochTime();
|
|
|
|
const temp = parseTemporaryCode(tempCode);
|
|
|
|
const user = $(await _getUsers(app), [
|
|
fp.find(u => u.temporaryAccessId === temp.id),
|
|
]);
|
|
|
|
if (!user) { return false; }
|
|
|
|
const existingAuth = await app.datastore.loadJson(
|
|
userAuthFile(user.name),
|
|
);
|
|
|
|
if (isSomething(existingAuth.temporaryAccessHash)
|
|
&& existingAuth.temporaryAccessExpiryEpoch > currentTime) {
|
|
const verified = await app.crypto.verify(
|
|
existingAuth.temporaryAccessHash,
|
|
temp.code,
|
|
);
|
|
|
|
if (verified) {
|
|
await doSet(
|
|
app, existingAuth,
|
|
user.name, newpassword,
|
|
);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
};
|
|
|
|
const doSet = async (app, auth, username, newpassword) => {
|
|
auth.temporaryAccessHash = '';
|
|
auth.temporaryAccessExpiryEpoch = 0;
|
|
auth.passwordHash = await app.crypto.hash(
|
|
newpassword,
|
|
);
|
|
await app.datastore.updateJson(
|
|
userAuthFile(username),
|
|
auth,
|
|
);
|
|
};
|
|
|
|
const scorePassword = app => password => apiWrapperSync(
|
|
app,
|
|
events.authApi.scorePassword,
|
|
alwaysAuthorized,
|
|
{ password },
|
|
_scorePassword, password,
|
|
);
|
|
|
|
const _scorePassword = (password) => {
|
|
// from https://stackoverflow.com/questions/948172/password-strength-meter
|
|
// thank you https://stackoverflow.com/users/46617/tm-lv
|
|
|
|
let score = 0;
|
|
if (!password) { return score; }
|
|
|
|
// award every unique letter until 5 repetitions
|
|
const letters = new Object();
|
|
for (let i = 0; i < password.length; i++) {
|
|
letters[password[i]] = (letters[password[i]] || 0) + 1;
|
|
score += 5.0 / letters[password[i]];
|
|
}
|
|
|
|
// bonus points for mixing it up
|
|
const variations = {
|
|
digits: /\d/.test(password),
|
|
lower: /[a-z]/.test(password),
|
|
upper: /[A-Z]/.test(password),
|
|
nonWords: /\W/.test(password),
|
|
};
|
|
|
|
let variationCount = 0;
|
|
for (const check in variations) {
|
|
variationCount += (variations[check] == true) ? 1 : 0;
|
|
}
|
|
score += (variationCount - 1) * 10;
|
|
|
|
const strengthText = score > 80
|
|
? 'strong'
|
|
: score > 60
|
|
? 'good'
|
|
: score >= 30
|
|
? 'weak'
|
|
: 'very weak';
|
|
|
|
return {
|
|
score: parseInt(score),
|
|
strengthText,
|
|
};
|
|
};
|
|
|
|
const createUser$1 = app => async (user, password = null) => apiWrapper(
|
|
app,
|
|
events.authApi.createUser,
|
|
permission.createUser.isAuthorized,
|
|
{ user, password },
|
|
_createUser, app, user, password,
|
|
);
|
|
|
|
const _createUser = async (app, user, password = null) => {
|
|
const lock = await getLock(
|
|
app, USERS_LOCK_FILE, 1000, 2,
|
|
);
|
|
|
|
if (isNolock(lock)) { throw new Error('Unable to create user, could not get lock - try again'); }
|
|
|
|
const users = await app.datastore.loadJson(USERS_LIST_FILE);
|
|
|
|
const userErrors = validateUser()([...users, user], user);
|
|
if (userErrors.length > 0) { throw new BadRequestError(`User is invalid. ${fp.join('; ')(userErrors)}`); }
|
|
|
|
const { auth, tempCode, temporaryAccessId } = await getAccess(
|
|
app, password,
|
|
);
|
|
user.tempCode = tempCode;
|
|
user.temporaryAccessId = temporaryAccessId;
|
|
|
|
if (fp.some(u => insensitiveEquals(u.name, user.name))(users)) {
|
|
throw new BadRequestError('User already exists');
|
|
}
|
|
|
|
users.push(
|
|
stripUserOfSensitiveStuff(user),
|
|
);
|
|
|
|
await app.datastore.updateJson(
|
|
USERS_LIST_FILE,
|
|
users,
|
|
);
|
|
|
|
try {
|
|
await app.datastore.createJson(
|
|
userAuthFile(user.name),
|
|
auth,
|
|
);
|
|
} catch (_) {
|
|
await app.datastore.updateJson(
|
|
userAuthFile(user.name),
|
|
auth,
|
|
);
|
|
}
|
|
|
|
await releaseLock(app, lock);
|
|
|
|
return user;
|
|
};
|
|
|
|
const getAccess = async (app, password) => {
|
|
const auth = getNewUserAuth(app)();
|
|
|
|
if (isNonEmptyString(password)) {
|
|
if (isValidPassword(password)) {
|
|
auth.passwordHash = await app.crypto.hash(password);
|
|
auth.temporaryAccessHash = '';
|
|
auth.temporaryAccessId = '';
|
|
auth.temporaryAccessExpiryEpoch = 0;
|
|
return { auth };
|
|
}
|
|
throw new BadRequestError('Password does not meet requirements');
|
|
} else {
|
|
const tempAccess = await getTemporaryCode(app);
|
|
auth.temporaryAccessHash = tempAccess.temporaryAccessHash;
|
|
auth.temporaryAccessExpiryEpoch = tempAccess.temporaryAccessExpiryEpoch;
|
|
auth.passwordHash = '';
|
|
return ({
|
|
auth,
|
|
tempCode: tempAccess.tempCode,
|
|
temporaryAccessId: tempAccess.temporaryAccessId,
|
|
});
|
|
}
|
|
};
|
|
|
|
const enableUser = app => async username => apiWrapper(
|
|
app,
|
|
events.authApi.enableUser,
|
|
permission.enableDisableUser.isAuthorized,
|
|
{ username },
|
|
_enableUser, app, username,
|
|
);
|
|
|
|
const disableUser = app => async username => apiWrapper(
|
|
app,
|
|
events.authApi.disableUser,
|
|
permission.enableDisableUser.isAuthorized,
|
|
{ username },
|
|
_disableUser, app, username,
|
|
);
|
|
|
|
const _enableUser = async (app, username) => await toggleUser(app, username, true);
|
|
|
|
const _disableUser = async (app, username) => await toggleUser(app, username, false);
|
|
|
|
const toggleUser = async (app, username, enabled) => {
|
|
const lock = await getLock(app, USERS_LOCK_FILE, 1000, 1, 0);
|
|
|
|
const actionName = enabled ? 'enable' : 'disable';
|
|
|
|
if (isNolock(lock)) { throw new Error(`Could not ${actionName} user - cannot get lock`); }
|
|
|
|
try {
|
|
const users = await app.datastore.loadJson(USERS_LIST_FILE);
|
|
const user = getUserByName(users, username);
|
|
if (!user) { throw new NotFoundError(`Could not find user to ${actionName}`); }
|
|
|
|
if (user.enabled === !enabled) {
|
|
user.enabled = enabled;
|
|
await app.datastore.updateJson(USERS_LIST_FILE, users);
|
|
}
|
|
} finally {
|
|
releaseLock(app, lock);
|
|
}
|
|
};
|
|
|
|
const getNewAccessLevel = () => () => ({
|
|
name: '',
|
|
permissions: [],
|
|
default:false
|
|
});
|
|
|
|
const isAllowedType = t => $(permissionTypes, [
|
|
fp.values,
|
|
fp.includes(t),
|
|
]);
|
|
|
|
const isRecordOrIndexType = t => fp.some(p => p === t)([
|
|
permissionTypes.CREATE_RECORD,
|
|
permissionTypes.UPDATE_RECORD,
|
|
permissionTypes.DELETE_RECORD,
|
|
permissionTypes.READ_RECORD,
|
|
permissionTypes.READ_INDEX,
|
|
permissionTypes.EXECUTE_ACTION,
|
|
]);
|
|
|
|
|
|
const permissionRules = app => ([
|
|
makerule('type', 'type must be one of allowed types',
|
|
p => isAllowedType(p.type)),
|
|
makerule('nodeKey', 'record and index permissions must include a valid nodeKey',
|
|
p => (!isRecordOrIndexType(p.type))
|
|
|| isSomething(getNode(app.hierarchy, p.nodeKey))),
|
|
]);
|
|
|
|
const applyPermissionRules = app => applyRuleSet(permissionRules(app));
|
|
|
|
const accessLevelRules = allLevels => ([
|
|
makerule('name', 'name must be set',
|
|
l => isNonEmptyString(l.name)),
|
|
makerule('name', 'access level names must be unique',
|
|
l => fp.isEmpty(l.name)
|
|
|| fp.filter(a => insensitiveEquals(l.name, a.name))(allLevels).length === 1),
|
|
]);
|
|
|
|
const applyLevelRules = allLevels => applyRuleSet(accessLevelRules(allLevels));
|
|
|
|
const validateAccessLevel = app => (allLevels, level) => {
|
|
const errs = $(level.permissions, [
|
|
fp.map(applyPermissionRules(app)),
|
|
fp.flatten,
|
|
fp.concat(
|
|
applyLevelRules(allLevels)(level),
|
|
),
|
|
]);
|
|
|
|
return errs;
|
|
};
|
|
|
|
const validateAccessLevels = app => allLevels => apiWrapperSync(
|
|
app,
|
|
events.authApi.validateAccessLevels,
|
|
alwaysAuthorized,
|
|
{ allLevels },
|
|
_validateAccessLevels, app, allLevels,
|
|
);
|
|
|
|
const _validateAccessLevels = (app, allLevels) => $(allLevels, [
|
|
fp.map(l => validateAccessLevel(app)(allLevels, l)),
|
|
fp.flatten,
|
|
fp.uniqWith((x, y) => x.field === y.field
|
|
&& x.item === y.item
|
|
&& x.error === y.error),
|
|
]);
|
|
|
|
const saveAccessLevels = app => async accessLevels => apiWrapper(
|
|
app,
|
|
events.authApi.saveAccessLevels,
|
|
permission.writeAccessLevels.isAuthorized,
|
|
{ accessLevels },
|
|
_saveAccessLevels, app, accessLevels,
|
|
);
|
|
|
|
const _saveAccessLevels = async (app, accessLevels) => {
|
|
const validationErrors = validateAccessLevels(app)(accessLevels.levels);
|
|
if (validationErrors.length > 0) {
|
|
const errs = $(validationErrors, [
|
|
fp.map(e => e.error),
|
|
fp.join(', '),
|
|
]);
|
|
throw new Error(
|
|
`Access Levels Invalid: ${errs}`,
|
|
);
|
|
}
|
|
|
|
const lock = await getLock(
|
|
app, ACCESS_LEVELS_LOCK_FILE, 2000, 2,
|
|
);
|
|
|
|
if (isNolock(lock)) { throw new Error('Could not get lock to save access levels'); }
|
|
|
|
try {
|
|
const existing = await app.datastore.loadJson(ACCESS_LEVELS_FILE);
|
|
if (existing.version !== accessLevels.version) { throw new Error('Access levels have already been updated, since you loaded'); }
|
|
|
|
accessLevels.version++;
|
|
|
|
app.datastore.updateJson(ACCESS_LEVELS_FILE, accessLevels);
|
|
} finally {
|
|
await releaseLock(app, lock);
|
|
}
|
|
};
|
|
|
|
const generateFullPermissions = (app) => {
|
|
const allNodes = getFlattenedHierarchy(app.hierarchy);
|
|
const accessLevel = { permissions: [] };
|
|
|
|
const recordNodes = $(allNodes, [
|
|
fp.filter(isRecord),
|
|
]);
|
|
|
|
for (const n of recordNodes) {
|
|
permission.createRecord.add(n.nodeKey(), accessLevel);
|
|
permission.updateRecord.add(n.nodeKey(), accessLevel);
|
|
permission.deleteRecord.add(n.nodeKey(), accessLevel);
|
|
permission.readRecord.add(n.nodeKey(), accessLevel);
|
|
}
|
|
|
|
const indexNodes = $(allNodes, [
|
|
fp.filter(isIndex),
|
|
]);
|
|
|
|
for (const n of indexNodes) {
|
|
permission.readIndex.add(n.nodeKey(), accessLevel);
|
|
}
|
|
|
|
for (const a of fp.keys(app.actions)) {
|
|
permission.executeAction.add(a, accessLevel);
|
|
}
|
|
|
|
$(permission, [
|
|
fp.values,
|
|
fp.filter(p => !p.isNode),
|
|
fp.each(p => p.add(accessLevel)),
|
|
]);
|
|
|
|
return accessLevel.permissions;
|
|
};
|
|
|
|
const setUserAccessLevels$1 = app => async (userName, accessLevels) => apiWrapper(
|
|
app,
|
|
events.authApi.setUserAccessLevels,
|
|
permission.setUserAccessLevels.isAuthorized,
|
|
{ userName, accessLevels },
|
|
_setUserAccessLevels, app, userName, accessLevels,
|
|
);
|
|
|
|
const _setUserAccessLevels = async (app, username, accessLevels) => {
|
|
const lock = await getLock(app, USERS_LOCK_FILE, 1000, 1, 0);
|
|
|
|
const actualAccessLevels = $(
|
|
await app.datastore.loadJson(ACCESS_LEVELS_FILE),
|
|
[
|
|
l => l.levels,
|
|
fp.map(l => l.name),
|
|
],
|
|
);
|
|
|
|
const missing = fp.difference(accessLevels)(actualAccessLevels);
|
|
if (missing.length > 0) {
|
|
throw new Error(`Invalid access levels supplied: ${fp.join(', ', missing)}`);
|
|
}
|
|
|
|
if (isNolock(lock)) { throw new Error('Could set user access levels cannot get lock'); }
|
|
|
|
try {
|
|
const users = await app.datastore.loadJson(USERS_LIST_FILE);
|
|
const user = getUserByName(users, username);
|
|
if (!user) { throw new NotFoundError(`Could not find user with ${username}`); }
|
|
|
|
user.accessLevels = accessLevels;
|
|
await app.datastore.updateJson(USERS_LIST_FILE, users);
|
|
} finally {
|
|
releaseLock(app, lock);
|
|
}
|
|
};
|
|
|
|
const getAuthApi = app => ({
|
|
authenticate: authenticate(app),
|
|
authenticateTemporaryAccess: authenticateTemporaryAccess(app),
|
|
createTemporaryAccess: createTemporaryAccess$1(app),
|
|
createUser: createUser$1(app),
|
|
loadAccessLevels: loadAccessLevels(app),
|
|
enableUser: enableUser(app),
|
|
disableUser: disableUser(app),
|
|
getNewAccessLevel: getNewAccessLevel(),
|
|
getNewUser: getNewUser(app),
|
|
getNewUserAuth: getNewUserAuth(app),
|
|
getUsers: getUsers(app),
|
|
saveAccessLevels: saveAccessLevels(app),
|
|
isAuthorized: isAuthorized(app),
|
|
changeMyPassword: changeMyPassword(app),
|
|
setPasswordFromTemporaryCode: setPasswordFromTemporaryCode(app),
|
|
scorePassword,
|
|
isValidPassword: isValidPassword(app),
|
|
validateUser: validateUser(),
|
|
validateAccessLevels: validateAccessLevels(app),
|
|
generateFullPermissions: () => generateFullPermissions(app),
|
|
setUserAccessLevels: setUserAccessLevels$1(app),
|
|
});
|
|
|
|
const chain = index.$;
|
|
|
|
const events$1 = index.eventsList;
|
|
|
|
const getNode$1 = (hierarchy$1, nodeId) =>
|
|
chain(hierarchy$1, [
|
|
hierarchy.getFlattenedHierarchy,
|
|
fp.find(n => n.nodeId === nodeId || n.nodeKey() === nodeId)
|
|
]);
|
|
|
|
const constructHierarchy$1 = node => {
|
|
if(!node) return node;
|
|
return templateApi(node).constructHierarchy(node);
|
|
};
|
|
|
|
const templateApi = hierarchy => getTemplateApi({hierarchy});
|
|
const authApi = (hierarchy, actions) => getAuthApi({
|
|
hierarchy, actions: fp.keyBy("name")(actions), publish:()=>{}});
|
|
|
|
const allTypes$1 = templateApi({}).allTypes;
|
|
|
|
const validate = {
|
|
all: templateApi({}).validateAll,
|
|
node: templateApi({}).validateNode,
|
|
field: templateApi({}).validateField
|
|
};
|
|
|
|
const getPotentialReverseReferenceIndexes = (hierarchy$1, refIndex) => {
|
|
const res = chain(hierarchy$1, [
|
|
hierarchy.getFlattenedHierarchy,
|
|
fp.filter(n => hierarchy.isAncestor(refIndex)(n)
|
|
|| hierarchy.isAncestor(refIndex)(n.parent())),
|
|
fp.map(n => n.indexes),
|
|
fp.flatten,
|
|
fp.filter(hierarchy.isReferenceIndex)
|
|
]);
|
|
|
|
return res;
|
|
};
|
|
|
|
const getPotentialReferenceIndexes = (hierarchy$1, record) =>
|
|
chain(hierarchy$1, [
|
|
hierarchy.getFlattenedHierarchy,
|
|
fp.filter(hierarchy.isAncestorIndex),
|
|
fp.filter(i => hierarchy.isAncestor(record)(i.parent())
|
|
|| i.parent().nodeId === record.parent().nodeId
|
|
|| hierarchy.isRoot(i.parent()))
|
|
]);
|
|
|
|
const getDefaultTypeOptions = type =>
|
|
!type ? {} : allTypes$1[type].getDefaultOptions();
|
|
|
|
const getNewAction = () => templateApi({}).createAction();
|
|
const getNewTrigger = () => templateApi({}).createTrigger();
|
|
|
|
const validateActions$1 = actions => templateApi({}).validateActions(actions);
|
|
const validateTriggers$1 = (triggers, actions) => templateApi({}).validateTriggers(triggers, actions);
|
|
|
|
const generateFullPermissions$1 = (hierarchy, actions) =>
|
|
authApi(hierarchy,actions).generateFullPermissions();
|
|
|
|
const getNewAccessLevel$1 = () =>
|
|
authApi().getNewAccessLevel();
|
|
|
|
const validateAccessLevels$1 = (hierarchy, actions, accessLevels) =>
|
|
authApi(hierarchy, actions).validateAccessLevels(accessLevels);
|
|
|
|
const subscriber_queue = [];
|
|
/**
|
|
* Create a `Writable` store that allows both updating and reading by subscription.
|
|
* @param {*=}value initial value
|
|
* @param {StartStopNotifier=}start start and stop notifications for subscriptions
|
|
*/
|
|
function writable(value, start = noop) {
|
|
let stop;
|
|
const subscribers = [];
|
|
function set(new_value) {
|
|
if (safe_not_equal(value, new_value)) {
|
|
value = new_value;
|
|
if (stop) { // store is ready
|
|
const run_queue = !subscriber_queue.length;
|
|
for (let i = 0; i < subscribers.length; i += 1) {
|
|
const s = subscribers[i];
|
|
s[1]();
|
|
subscriber_queue.push(s, value);
|
|
}
|
|
if (run_queue) {
|
|
for (let i = 0; i < subscriber_queue.length; i += 2) {
|
|
subscriber_queue[i][0](subscriber_queue[i + 1]);
|
|
}
|
|
subscriber_queue.length = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function update(fn) {
|
|
set(fn(value));
|
|
}
|
|
function subscribe(run, invalidate = noop) {
|
|
const subscriber = [run, invalidate];
|
|
subscribers.push(subscriber);
|
|
if (subscribers.length === 1) {
|
|
stop = start(set) || noop;
|
|
}
|
|
run(value);
|
|
return () => {
|
|
const index = subscribers.indexOf(subscriber);
|
|
if (index !== -1) {
|
|
subscribers.splice(index, 1);
|
|
}
|
|
if (subscribers.length === 0) {
|
|
stop();
|
|
stop = null;
|
|
}
|
|
};
|
|
}
|
|
return { set, update, subscribe };
|
|
}
|
|
|
|
const defaultPagesObject = () => ({
|
|
main: {
|
|
index: {
|
|
_component : "./components/indexHtml"
|
|
},
|
|
appBody: "bbapp.main.json"
|
|
},
|
|
unauthenticated: {
|
|
index: {
|
|
_component : "./components/indexHtml"
|
|
},
|
|
appBody: "bbapp.unauthenticated.json"
|
|
},
|
|
componentLibraries: ["./components"]
|
|
});
|
|
|
|
const apiCall = (method) => (url, body, returnResponse=false) =>
|
|
fetch(url, {
|
|
method: method,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
body: body && JSON.stringify(body),
|
|
}).then(r => returnResponse ? r : r.json());
|
|
|
|
const post = apiCall("POST");
|
|
const get = apiCall("GET");
|
|
const patch = apiCall("PATCH");
|
|
const del = apiCall("DELETE");
|
|
|
|
var api = {
|
|
post, get, patch, delete:del
|
|
};
|
|
|
|
const pipe = index.$;
|
|
|
|
const getStore = () => {
|
|
|
|
const initial = {
|
|
apps:[],
|
|
appname:"",
|
|
hierarchy: {},
|
|
actions: [],
|
|
triggers: [],
|
|
pages:defaultPagesObject(),
|
|
mainUi:{},
|
|
unauthenticatedUi:{},
|
|
derivedComponents:[],
|
|
rootComponents:[],
|
|
currentNodeIsNew: false,
|
|
errors: [],
|
|
activeNav: "database",
|
|
hasAppPackage: false,
|
|
accessLevels: [],
|
|
currentNode: null,
|
|
};
|
|
|
|
const store = writable(initial);
|
|
|
|
store.initialise = initialise(store, initial);
|
|
store.newChildRecord = newRecord(store, false);
|
|
store.newRootRecord = newRecord(store, true);
|
|
store.selectExistingNode = selectExistingNode(store);
|
|
store.newChildIndex = newIndex(store, false);
|
|
store.newRootIndex = newIndex(store, true);
|
|
store.saveCurrentNode = saveCurrentNode(store);
|
|
store.importAppDefinition = importAppDefinition(store);
|
|
store.deleteCurrentNode = deleteCurrentNode(store);
|
|
store.saveField = saveField(store);
|
|
store.deleteField = deleteField(store);
|
|
store.saveAction = saveAction(store);
|
|
store.deleteAction = deleteAction(store);
|
|
store.saveTrigger = saveTrigger(store);
|
|
store.deleteTrigger = deleteTrigger(store);
|
|
store.saveLevel = saveLevel(store);
|
|
store.deleteLevel = deleteLevel(store);
|
|
store.setActiveNav = setActiveNav(store);
|
|
store.saveDerivedComponent = saveDerivedComponent(store);
|
|
store.refreshComponents = refreshComponents(store);
|
|
store.addComponentLibrary = addComponentLibrary(store);
|
|
store.renameDerivedComponent = renameDerivedComponent(store);
|
|
store.deleteDerivedComponent = deleteDerivedComponent(store);
|
|
return store;
|
|
};
|
|
|
|
const initialise = (store, initial) => async () => {
|
|
|
|
const appname = window.location.hash
|
|
? fp.last(window.location.hash.substr(1).split("/"))
|
|
: "";
|
|
|
|
if(!appname) {
|
|
initial.apps = await api.get(`/_builder/api/apps`);
|
|
initial.hasAppPackage = false;
|
|
store.set(initial);
|
|
return initial;
|
|
}
|
|
|
|
const pkg = await api.get(`/_builder/api/${appname}/appPackage`);
|
|
|
|
initial.appname = appname;
|
|
initial.hasAppPackage = true;
|
|
initial.hierarchy = pkg.appDefinition.hierarchy;
|
|
initial.accessLevels = pkg.accessLevels;
|
|
initial.derivedComponents = pkg.derivedComponents;
|
|
initial.rootComponents = pkg.rootComponents;
|
|
initial.actions = fp.reduce((arr, action) => {
|
|
arr.push(action);
|
|
return arr;
|
|
})(pkg.appDefinition.actions, []);
|
|
initial.triggers = pkg.appDefinition.triggers;
|
|
|
|
if(!!initial.hierarchy && !fp.isEmpty(initial.hierarchy)) {
|
|
initial.hierarchy = constructHierarchy$1(initial.hierarchy);
|
|
const shadowHierarchy = createShadowHierarchy(initial.hierarchy);
|
|
if(initial.currentNode !== null)
|
|
initial.currentNode = getNode$1(
|
|
shadowHierarchy, initial.currentNode.nodeId
|
|
);
|
|
}
|
|
store.set(initial);
|
|
return initial;
|
|
};
|
|
|
|
const newRecord = (store, useRoot) => () => {
|
|
store.update(s => {
|
|
s.currentNodeIsNew = true;
|
|
const shadowHierarchy = createShadowHierarchy(s.hierarchy);
|
|
parent = useRoot ? shadowHierarchy
|
|
: getNode$1(
|
|
shadowHierarchy,
|
|
s.currentNode.nodeId);
|
|
s.errors = [];
|
|
s.currentNode = templateApi(shadowHierarchy)
|
|
.getNewRecordTemplate(parent, "", true);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
|
|
const selectExistingNode = (store) => (nodeId) => {
|
|
store.update(s => {
|
|
const shadowHierarchy = createShadowHierarchy(s.hierarchy);
|
|
s.currentNode = getNode$1(
|
|
shadowHierarchy, nodeId
|
|
);
|
|
s.currentNodeIsNew = false;
|
|
s.errors = [];
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const newIndex = (store, useRoot) => () => {
|
|
store.update(s => {
|
|
s.currentNodeIsNew = true;
|
|
s.errors = [];
|
|
const shadowHierarchy = createShadowHierarchy(s.hierarchy);
|
|
parent = useRoot ? shadowHierarchy
|
|
: getNode$1(
|
|
shadowHierarchy,
|
|
s.currentNode.nodeId);
|
|
|
|
s.currentNode = templateApi(shadowHierarchy)
|
|
.getNewIndexTemplate(parent);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const saveCurrentNode = (store) => () => {
|
|
store.update(s => {
|
|
|
|
const errors = validate.node(s.currentNode);
|
|
s.errors = errors;
|
|
if(errors.length > 0) {
|
|
return s;
|
|
}
|
|
|
|
const parentNode = getNode$1(
|
|
s.hierarchy, s.currentNode.parent().nodeId);
|
|
|
|
const existingNode = getNode$1(
|
|
s.hierarchy, s.currentNode.nodeId);
|
|
|
|
let index = parentNode.children.length;
|
|
if(!!existingNode) {
|
|
// remove existing
|
|
index = existingNode.parent().children.indexOf(existingNode);
|
|
existingNode.parent().children = chain(existingNode.parent().children, [
|
|
fp.filter(c => c.nodeId !== existingNode.nodeId)
|
|
]);
|
|
}
|
|
|
|
// should add node into existing hierarchy
|
|
const cloned = fp.cloneDeep(s.currentNode);
|
|
templateApi(s.hierarchy).constructNode(
|
|
parentNode,
|
|
cloned
|
|
);
|
|
|
|
const newIndexOfchild = child => {
|
|
if(child === cloned) return index;
|
|
const currentIndex = parentNode.children.indexOf(child);
|
|
return currentIndex >= index ? currentIndex + 1 : currentIndex;
|
|
};
|
|
|
|
parentNode.children = chain(parentNode.children, [
|
|
fp.sortBy(newIndexOfchild)
|
|
]);
|
|
|
|
s.currentNodeIsNew = false;
|
|
|
|
savePackage(store, s);
|
|
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const importAppDefinition = store => appDefinition => {
|
|
store.update(s => {
|
|
s.hierarchy = appDefinition.hierarchy;
|
|
s.currentNode = appDefinition.hierarchy.children.length > 0
|
|
? appDefinition.hierarchy.children[0]
|
|
: null;
|
|
s.actions = appDefinition.actions;
|
|
s.triggers = appDefinition.triggers;
|
|
s.currentNodeIsNew = false;
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const deleteCurrentNode = store => () => {
|
|
store.update(s => {
|
|
const nodeToDelete = getNode$1(s.hierarchy, s.currentNode.nodeId);
|
|
s.currentNode = hierarchy.isRoot(nodeToDelete.parent())
|
|
? fp.find(n => n != s.currentNode)
|
|
(s.hierarchy.children)
|
|
: nodeToDelete.parent();
|
|
if(hierarchy.isRecord(nodeToDelete)) {
|
|
nodeToDelete.parent().children = fp.filter(c => c.nodeId !== nodeToDelete.nodeId)
|
|
(nodeToDelete.parent().children);
|
|
} else {
|
|
nodeToDelete.parent().indexes = fp.filter(c => c.nodeId !== nodeToDelete.nodeId)
|
|
(nodeToDelete.parent().indexes);
|
|
}
|
|
s.errors = [];
|
|
savePackage(store, s);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const saveField = databaseStore => (field) => {
|
|
databaseStore.update(db => {
|
|
db.currentNode.fields = fp.filter(f => f.name !== field.name)
|
|
(db.currentNode.fields);
|
|
|
|
templateApi(db.hierarchy).addField(db.currentNode, field);
|
|
return db;
|
|
});
|
|
};
|
|
|
|
|
|
const deleteField = databaseStore => field => {
|
|
databaseStore.update(db => {
|
|
db.currentNode.fields = fp.filter(f => f.name !== field.name)
|
|
(db.currentNode.fields);
|
|
|
|
return db;
|
|
});
|
|
};
|
|
|
|
|
|
const saveAction = store => (newAction, isNew, oldAction=null) => {
|
|
store.update(s => {
|
|
|
|
const existingAction = isNew
|
|
? null
|
|
: fp.find(a => a.name === oldAction.name)(s.actions);
|
|
|
|
if(existingAction) {
|
|
s.actions = chain(s.actions, [
|
|
fp.map(a => a === existingAction ? newAction : a)
|
|
]);
|
|
} else {
|
|
s.actions.push(newAction);
|
|
}
|
|
savePackage(store, s);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const deleteAction = store => action => {
|
|
store.update(s => {
|
|
s.actions = fp.filter(a => a.name !== action.name)(s.actions);
|
|
savePackage(store, s);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const saveTrigger = store => (newTrigger, isNew, oldTrigger=null) => {
|
|
store.update(s => {
|
|
|
|
const existingTrigger = isNew
|
|
? null
|
|
: fp.find(a => a.name === oldTrigger.name)(s.triggers);
|
|
|
|
if(existingTrigger) {
|
|
s.triggers = chain(s.triggers, [
|
|
fp.map(a => a === existingTrigger ? newTrigger : a)
|
|
]);
|
|
} else {
|
|
s.triggers.push(newTrigger);
|
|
}
|
|
savePackage(store, s);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const deleteTrigger = store => trigger => {
|
|
store.update(s => {
|
|
s.triggers = fp.filter(t => t.name !== trigger.name)(s.triggers);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const saveLevel = store => (newLevel, isNew, oldLevel=null) => {
|
|
store.update(s => {
|
|
|
|
const existingLevel = isNew
|
|
? null
|
|
: fp.find(a => a.name === oldLevel.name)(s.accessLevels);
|
|
|
|
if(existingLevel) {
|
|
s.accessLevels = chain(s.accessLevels, [
|
|
fp.map(a => a === existingLevel ? newLevel : a)
|
|
]);
|
|
} else {
|
|
s.accessLevels.push(newLevel);
|
|
}
|
|
savePackage(store, s);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const deleteLevel = store => level => {
|
|
store.update(s => {
|
|
s.accessLevels = fp.filter(t => t.name !== level.name)(s.accessLevels);
|
|
savePackage(store, s);
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const setActiveNav = store => navName => {
|
|
store.update(s => {
|
|
s.activeNav = navName;
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const createShadowHierarchy = hierarchy =>
|
|
constructHierarchy$1(JSON.parse(JSON.stringify(hierarchy)));
|
|
|
|
const saveDerivedComponent = store => (derivedComponent) => {
|
|
|
|
store.update(s => {
|
|
|
|
const derivedComponents = pipe(s.derivedComponents, [
|
|
fp.filter(c => c._name !== derivedComponent._name)
|
|
]);
|
|
|
|
s.derivedComponents = derivedComponents;
|
|
|
|
api.post(`/_builder/api/${s.appname}/derivedcomponent`, derivedComponent);
|
|
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const deleteDerivedComponent = store => name => {
|
|
store.update(s => {
|
|
|
|
const derivedComponents = pipe(s.derivedComponents, [
|
|
fp.filter(c => c._name !== name)
|
|
]);
|
|
|
|
s.derivedComponents = derivedComponents;
|
|
|
|
api.delete(`/_builder/api/${s.appname}/derivedcomponent/${name}`);
|
|
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const renameDerivedComponent = store => (oldname, newname) => {
|
|
store.update(s => {
|
|
|
|
const component = pipe(s.derivedComponents, [
|
|
fp.find(c => c._name === name)
|
|
]);
|
|
|
|
component._name = newname;
|
|
|
|
const derivedComponents = pipe(s.derivedComponents, [
|
|
fp.filter(c => c._name !== name),
|
|
fp.concat(component)
|
|
]);
|
|
|
|
s.derivedComponent = derivedComponents;
|
|
|
|
api.patch(`/_builder/api/${s.appname}/derivedcomponent`, {
|
|
oldname, newname
|
|
});
|
|
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const addComponentLibrary = store => async lib => {
|
|
|
|
const response =
|
|
await api.get(`/_builder/api/${db.appname}/components?${encodeURI(lib)}`,undefined, true);
|
|
|
|
const success = response.status === 200;
|
|
|
|
const error = response.status === 404
|
|
? `Could not find library ${lib}`
|
|
: success
|
|
? ""
|
|
: response.statusText;
|
|
|
|
const components = success
|
|
? await response.json()
|
|
: [];
|
|
|
|
store.update(s => {
|
|
s.componentsErrors.addComponent = error;
|
|
if(success) {
|
|
s.pages.componentLibraries.push(lib);
|
|
s.rootComponents = [...s.rootComponents, components];
|
|
}
|
|
|
|
return s;
|
|
});
|
|
|
|
|
|
};
|
|
|
|
const refreshComponents = store => async () => {
|
|
|
|
const components =
|
|
await api.get(`/_builder/api/${db.appname}/components`);
|
|
|
|
const rootComponents = pipe(components, [
|
|
fp.keys,
|
|
fp.map(k => ({...components[k], _name:k}))
|
|
]);
|
|
|
|
store.update(s => {
|
|
s.rootComponents = rootComponents;
|
|
return s;
|
|
});
|
|
};
|
|
|
|
const savePackage = (store, s) => {
|
|
|
|
const appDefinition = {
|
|
hierarchy:s.hierarchy,
|
|
triggers:s.triggers,
|
|
actions: fp.groupBy("name")(s.actions),
|
|
pages:s.pages,
|
|
mainUi: s.mainUi,
|
|
unauthenticatedUi: s.unauthenticatedUi
|
|
};
|
|
|
|
const data = {
|
|
appDefinition,
|
|
accessLevels:s.accessLevels
|
|
};
|
|
|
|
api.post(`/_builder/api/${s.appname}/appPackage`, data);
|
|
};
|
|
|
|
const database = getStore();
|
|
|
|
const initialise$1 = async () => {
|
|
try {
|
|
setupRouter(database);
|
|
await database.initialise();
|
|
} catch(err) {
|
|
console.log(err);
|
|
}
|
|
|
|
};
|
|
|
|
const setupRouter = (writable) => {
|
|
const pushState = history.pushState;
|
|
history.pushState = () => {
|
|
pushState.apply(history, arguments);
|
|
//fireEvents('pushState', arguments);
|
|
writable.initialise();
|
|
};
|
|
window.addEventListener('hashchange',()=>{
|
|
writable.initialise();
|
|
});
|
|
};
|
|
|
|
/* src\NoPackage.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$2 = "src\\NoPackage.svelte";
|
|
|
|
function get_each_context(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.app = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (17:16) {#each $database.apps as app}
|
|
function create_each_block(ctx) {
|
|
var a, t_value = ctx.app, t, a_href_value;
|
|
|
|
return {
|
|
c: function create() {
|
|
a = element("a");
|
|
t = text(t_value);
|
|
attr(a, "href", a_href_value = `#/${ctx.app}`);
|
|
attr(a, "class", "app-link svelte-jymnqv");
|
|
add_location(a, file$2, 17, 16, 458);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, a, anchor);
|
|
append(a, t);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.$database) && t_value !== (t_value = ctx.app)) {
|
|
set_data(t, t_value);
|
|
}
|
|
|
|
if ((changed.$database) && a_href_value !== (a_href_value = `#/${ctx.app}`)) {
|
|
attr(a, "href", a_href_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(a);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$1(ctx) {
|
|
var div3, div2, img, t0, div1, div0, h4, t2;
|
|
|
|
var each_value = ctx.$database.apps;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
div3 = element("div");
|
|
div2 = element("div");
|
|
img = element("img");
|
|
t0 = space();
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
h4 = element("h4");
|
|
h4.textContent = "Choose an Application";
|
|
t2 = space();
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(img, "src", "/_builder/assets/budibase-logo.png");
|
|
attr(img, "class", "logo svelte-jymnqv");
|
|
attr(img, "alt", "budibase logo");
|
|
add_location(img, file$2, 11, 8, 189);
|
|
set_style(h4, "margin-bottom", "20px");
|
|
add_location(h4, file$2, 15, 16, 335);
|
|
add_location(div0, file$2, 14, 12, 312);
|
|
add_location(div1, file$2, 12, 8, 279);
|
|
attr(div2, "class", "inner svelte-jymnqv");
|
|
add_location(div2, file$2, 10, 4, 160);
|
|
attr(div3, "class", "root svelte-jymnqv");
|
|
add_location(div3, file$2, 9, 0, 136);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div3, anchor);
|
|
append(div3, div2);
|
|
append(div2, img);
|
|
append(div2, t0);
|
|
append(div2, div1);
|
|
append(div1, div0);
|
|
append(div0, h4);
|
|
append(div0, t2);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div0, null);
|
|
}
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.$database) {
|
|
each_value = ctx.$database.apps;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div0, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div3);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$1($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
return { $database };
|
|
}
|
|
|
|
class NoPackage extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$1, create_fragment$1, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
|
|
|
|
function unwrapExports (x) {
|
|
return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
|
|
}
|
|
|
|
function createCommonjsModule(fn, module) {
|
|
return module = { exports: {} }, fn(module, module.exports), module.exports;
|
|
}
|
|
|
|
var feather = createCommonjsModule(function (module, exports) {
|
|
(function webpackUniversalModuleDefinition(root, factory) {
|
|
module.exports = factory();
|
|
})(typeof self !== 'undefined' ? self : commonjsGlobal, function() {
|
|
return /******/ (function(modules) { // webpackBootstrap
|
|
/******/ // The module cache
|
|
/******/ var installedModules = {};
|
|
/******/
|
|
/******/ // The require function
|
|
/******/ function __webpack_require__(moduleId) {
|
|
/******/
|
|
/******/ // Check if module is in cache
|
|
/******/ if(installedModules[moduleId]) {
|
|
/******/ return installedModules[moduleId].exports;
|
|
/******/ }
|
|
/******/ // Create a new module (and put it into the cache)
|
|
/******/ var module = installedModules[moduleId] = {
|
|
/******/ i: moduleId,
|
|
/******/ l: false,
|
|
/******/ exports: {}
|
|
/******/ };
|
|
/******/
|
|
/******/ // Execute the module function
|
|
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
|
|
/******/
|
|
/******/ // Flag the module as loaded
|
|
/******/ module.l = true;
|
|
/******/
|
|
/******/ // Return the exports of the module
|
|
/******/ return module.exports;
|
|
/******/ }
|
|
/******/
|
|
/******/
|
|
/******/ // expose the modules object (__webpack_modules__)
|
|
/******/ __webpack_require__.m = modules;
|
|
/******/
|
|
/******/ // expose the module cache
|
|
/******/ __webpack_require__.c = installedModules;
|
|
/******/
|
|
/******/ // define getter function for harmony exports
|
|
/******/ __webpack_require__.d = function(exports, name, getter) {
|
|
/******/ if(!__webpack_require__.o(exports, name)) {
|
|
/******/ Object.defineProperty(exports, name, {
|
|
/******/ configurable: false,
|
|
/******/ enumerable: true,
|
|
/******/ get: getter
|
|
/******/ });
|
|
/******/ }
|
|
/******/ };
|
|
/******/
|
|
/******/ // define __esModule on exports
|
|
/******/ __webpack_require__.r = function(exports) {
|
|
/******/ Object.defineProperty(exports, '__esModule', { value: true });
|
|
/******/ };
|
|
/******/
|
|
/******/ // getDefaultExport function for compatibility with non-harmony modules
|
|
/******/ __webpack_require__.n = function(module) {
|
|
/******/ var getter = module && module.__esModule ?
|
|
/******/ function getDefault() { return module['default']; } :
|
|
/******/ function getModuleExports() { return module; };
|
|
/******/ __webpack_require__.d(getter, 'a', getter);
|
|
/******/ return getter;
|
|
/******/ };
|
|
/******/
|
|
/******/ // Object.prototype.hasOwnProperty.call
|
|
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
|
|
/******/
|
|
/******/ // __webpack_public_path__
|
|
/******/ __webpack_require__.p = "";
|
|
/******/
|
|
/******/
|
|
/******/ // Load entry module and return exports
|
|
/******/ return __webpack_require__(__webpack_require__.s = 0);
|
|
/******/ })
|
|
/************************************************************************/
|
|
/******/ ({
|
|
|
|
/***/ "./dist/icons.json":
|
|
/*!*************************!*\
|
|
!*** ./dist/icons.json ***!
|
|
\*************************/
|
|
/*! exports provided: activity, airplay, alert-circle, alert-octagon, alert-triangle, align-center, align-justify, align-left, align-right, anchor, aperture, archive, arrow-down-circle, arrow-down-left, arrow-down-right, arrow-down, arrow-left-circle, arrow-left, arrow-right-circle, arrow-right, arrow-up-circle, arrow-up-left, arrow-up-right, arrow-up, at-sign, award, bar-chart-2, bar-chart, battery-charging, battery, bell-off, bell, bluetooth, bold, book-open, book, bookmark, box, briefcase, calendar, camera-off, camera, cast, check-circle, check-square, check, chevron-down, chevron-left, chevron-right, chevron-up, chevrons-down, chevrons-left, chevrons-right, chevrons-up, chrome, circle, clipboard, clock, cloud-drizzle, cloud-lightning, cloud-off, cloud-rain, cloud-snow, cloud, code, codepen, codesandbox, coffee, columns, command, compass, copy, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, cpu, credit-card, crop, crosshair, database, delete, disc, dollar-sign, download-cloud, download, droplet, edit-2, edit-3, edit, external-link, eye-off, eye, facebook, fast-forward, feather, figma, file-minus, file-plus, file-text, file, film, filter, flag, folder-minus, folder-plus, folder, framer, frown, gift, git-branch, git-commit, git-merge, git-pull-request, github, gitlab, globe, grid, hard-drive, hash, headphones, heart, help-circle, hexagon, home, image, inbox, info, instagram, italic, key, layers, layout, life-buoy, link-2, link, linkedin, list, loader, lock, log-in, log-out, mail, map-pin, map, maximize-2, maximize, meh, menu, message-circle, message-square, mic-off, mic, minimize-2, minimize, minus-circle, minus-square, minus, monitor, moon, more-horizontal, more-vertical, mouse-pointer, move, music, navigation-2, navigation, octagon, package, paperclip, pause-circle, pause, pen-tool, percent, phone-call, phone-forwarded, phone-incoming, phone-missed, phone-off, phone-outgoing, phone, pie-chart, play-circle, play, plus-circle, plus-square, plus, pocket, power, printer, radio, refresh-ccw, refresh-cw, repeat, rewind, rotate-ccw, rotate-cw, rss, save, scissors, search, send, server, settings, share-2, share, shield-off, shield, shopping-bag, shopping-cart, shuffle, sidebar, skip-back, skip-forward, slack, slash, sliders, smartphone, smile, speaker, square, star, stop-circle, sun, sunrise, sunset, tablet, tag, target, terminal, thermometer, thumbs-down, thumbs-up, toggle-left, toggle-right, trash-2, trash, trello, trending-down, trending-up, triangle, truck, tv, twitter, type, umbrella, underline, unlock, upload-cloud, upload, user-check, user-minus, user-plus, user-x, user, users, video-off, video, voicemail, volume-1, volume-2, volume-x, volume, watch, wifi-off, wifi, wind, x-circle, x-octagon, x-square, x, youtube, zap-off, zap, zoom-in, zoom-out, default */
|
|
/***/ (function(module) {
|
|
|
|
module.exports = {"activity":"<polyline points=\"22 12 18 12 15 21 9 3 6 12 2 12\"></polyline>","airplay":"<path d=\"M5 17H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2h-1\"></path><polygon points=\"12 15 17 21 7 21 12 15\"></polygon>","alert-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"12\"></line><line x1=\"12\" y1=\"16\" x2=\"12\" y2=\"16\"></line>","alert-octagon":"<polygon points=\"7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2\"></polygon><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"12\"></line><line x1=\"12\" y1=\"16\" x2=\"12\" y2=\"16\"></line>","alert-triangle":"<path d=\"M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z\"></path><line x1=\"12\" y1=\"9\" x2=\"12\" y2=\"13\"></line><line x1=\"12\" y1=\"17\" x2=\"12\" y2=\"17\"></line>","align-center":"<line x1=\"18\" y1=\"10\" x2=\"6\" y2=\"10\"></line><line x1=\"21\" y1=\"6\" x2=\"3\" y2=\"6\"></line><line x1=\"21\" y1=\"14\" x2=\"3\" y2=\"14\"></line><line x1=\"18\" y1=\"18\" x2=\"6\" y2=\"18\"></line>","align-justify":"<line x1=\"21\" y1=\"10\" x2=\"3\" y2=\"10\"></line><line x1=\"21\" y1=\"6\" x2=\"3\" y2=\"6\"></line><line x1=\"21\" y1=\"14\" x2=\"3\" y2=\"14\"></line><line x1=\"21\" y1=\"18\" x2=\"3\" y2=\"18\"></line>","align-left":"<line x1=\"17\" y1=\"10\" x2=\"3\" y2=\"10\"></line><line x1=\"21\" y1=\"6\" x2=\"3\" y2=\"6\"></line><line x1=\"21\" y1=\"14\" x2=\"3\" y2=\"14\"></line><line x1=\"17\" y1=\"18\" x2=\"3\" y2=\"18\"></line>","align-right":"<line x1=\"21\" y1=\"10\" x2=\"7\" y2=\"10\"></line><line x1=\"21\" y1=\"6\" x2=\"3\" y2=\"6\"></line><line x1=\"21\" y1=\"14\" x2=\"3\" y2=\"14\"></line><line x1=\"21\" y1=\"18\" x2=\"7\" y2=\"18\"></line>","anchor":"<circle cx=\"12\" cy=\"5\" r=\"3\"></circle><line x1=\"12\" y1=\"22\" x2=\"12\" y2=\"8\"></line><path d=\"M5 12H2a10 10 0 0 0 20 0h-3\"></path>","aperture":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"14.31\" y1=\"8\" x2=\"20.05\" y2=\"17.94\"></line><line x1=\"9.69\" y1=\"8\" x2=\"21.17\" y2=\"8\"></line><line x1=\"7.38\" y1=\"12\" x2=\"13.12\" y2=\"2.06\"></line><line x1=\"9.69\" y1=\"16\" x2=\"3.95\" y2=\"6.06\"></line><line x1=\"14.31\" y1=\"16\" x2=\"2.83\" y2=\"16\"></line><line x1=\"16.62\" y1=\"12\" x2=\"10.88\" y2=\"21.94\"></line>","archive":"<polyline points=\"21 8 21 21 3 21 3 8\"></polyline><rect x=\"1\" y=\"3\" width=\"22\" height=\"5\"></rect><line x1=\"10\" y1=\"12\" x2=\"14\" y2=\"12\"></line>","arrow-down-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><polyline points=\"8 12 12 16 16 12\"></polyline><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"16\"></line>","arrow-down-left":"<line x1=\"17\" y1=\"7\" x2=\"7\" y2=\"17\"></line><polyline points=\"17 17 7 17 7 7\"></polyline>","arrow-down-right":"<line x1=\"7\" y1=\"7\" x2=\"17\" y2=\"17\"></line><polyline points=\"17 7 17 17 7 17\"></polyline>","arrow-down":"<line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><polyline points=\"19 12 12 19 5 12\"></polyline>","arrow-left-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><polyline points=\"12 8 8 12 12 16\"></polyline><line x1=\"16\" y1=\"12\" x2=\"8\" y2=\"12\"></line>","arrow-left":"<line x1=\"19\" y1=\"12\" x2=\"5\" y2=\"12\"></line><polyline points=\"12 19 5 12 12 5\"></polyline>","arrow-right-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><polyline points=\"12 16 16 12 12 8\"></polyline><line x1=\"8\" y1=\"12\" x2=\"16\" y2=\"12\"></line>","arrow-right":"<line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line><polyline points=\"12 5 19 12 12 19\"></polyline>","arrow-up-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><polyline points=\"16 12 12 8 8 12\"></polyline><line x1=\"12\" y1=\"16\" x2=\"12\" y2=\"8\"></line>","arrow-up-left":"<line x1=\"17\" y1=\"17\" x2=\"7\" y2=\"7\"></line><polyline points=\"7 17 7 7 17 7\"></polyline>","arrow-up-right":"<line x1=\"7\" y1=\"17\" x2=\"17\" y2=\"7\"></line><polyline points=\"7 7 17 7 17 17\"></polyline>","arrow-up":"<line x1=\"12\" y1=\"19\" x2=\"12\" y2=\"5\"></line><polyline points=\"5 12 12 5 19 12\"></polyline>","at-sign":"<circle cx=\"12\" cy=\"12\" r=\"4\"></circle><path d=\"M16 8v5a3 3 0 0 0 6 0v-1a10 10 0 1 0-3.92 7.94\"></path>","award":"<circle cx=\"12\" cy=\"8\" r=\"7\"></circle><polyline points=\"8.21 13.89 7 23 12 20 17 23 15.79 13.88\"></polyline>","bar-chart-2":"<line x1=\"18\" y1=\"20\" x2=\"18\" y2=\"10\"></line><line x1=\"12\" y1=\"20\" x2=\"12\" y2=\"4\"></line><line x1=\"6\" y1=\"20\" x2=\"6\" y2=\"14\"></line>","bar-chart":"<line x1=\"12\" y1=\"20\" x2=\"12\" y2=\"10\"></line><line x1=\"18\" y1=\"20\" x2=\"18\" y2=\"4\"></line><line x1=\"6\" y1=\"20\" x2=\"6\" y2=\"16\"></line>","battery-charging":"<path d=\"M5 18H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3.19M15 6h2a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2h-3.19\"></path><line x1=\"23\" y1=\"13\" x2=\"23\" y2=\"11\"></line><polyline points=\"11 6 7 12 13 12 9 18\"></polyline>","battery":"<rect x=\"1\" y=\"6\" width=\"18\" height=\"12\" rx=\"2\" ry=\"2\"></rect><line x1=\"23\" y1=\"13\" x2=\"23\" y2=\"11\"></line>","bell-off":"<path d=\"M13.73 21a2 2 0 0 1-3.46 0\"></path><path d=\"M18.63 13A17.89 17.89 0 0 1 18 8\"></path><path d=\"M6.26 6.26A5.86 5.86 0 0 0 6 8c0 7-3 9-3 9h14\"></path><path d=\"M18 8a6 6 0 0 0-9.33-5\"></path><line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line>","bell":"<path d=\"M18 8A6 6 0 0 0 6 8c0 7-3 9-3 9h18s-3-2-3-9\"></path><path d=\"M13.73 21a2 2 0 0 1-3.46 0\"></path>","bluetooth":"<polyline points=\"6.5 6.5 17.5 17.5 12 23 12 1 17.5 6.5 6.5 17.5\"></polyline>","bold":"<path d=\"M6 4h8a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z\"></path><path d=\"M6 12h9a4 4 0 0 1 4 4 4 4 0 0 1-4 4H6z\"></path>","book-open":"<path d=\"M2 3h6a4 4 0 0 1 4 4v14a3 3 0 0 0-3-3H2z\"></path><path d=\"M22 3h-6a4 4 0 0 0-4 4v14a3 3 0 0 1 3-3h7z\"></path>","book":"<path d=\"M4 19.5A2.5 2.5 0 0 1 6.5 17H20\"></path><path d=\"M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z\"></path>","bookmark":"<path d=\"M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z\"></path>","box":"<path d=\"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z\"></path><polyline points=\"3.27 6.96 12 12.01 20.73 6.96\"></polyline><line x1=\"12\" y1=\"22.08\" x2=\"12\" y2=\"12\"></line>","briefcase":"<rect x=\"2\" y=\"7\" width=\"20\" height=\"14\" rx=\"2\" ry=\"2\"></rect><path d=\"M16 21V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v16\"></path>","calendar":"<rect x=\"3\" y=\"4\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><line x1=\"16\" y1=\"2\" x2=\"16\" y2=\"6\"></line><line x1=\"8\" y1=\"2\" x2=\"8\" y2=\"6\"></line><line x1=\"3\" y1=\"10\" x2=\"21\" y2=\"10\"></line>","camera-off":"<line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line><path d=\"M21 21H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h3m3-3h6l2 3h4a2 2 0 0 1 2 2v9.34m-7.72-2.06a4 4 0 1 1-5.56-5.56\"></path>","camera":"<path d=\"M23 19a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h4l2-3h6l2 3h4a2 2 0 0 1 2 2z\"></path><circle cx=\"12\" cy=\"13\" r=\"4\"></circle>","cast":"<path d=\"M2 16.1A5 5 0 0 1 5.9 20M2 12.05A9 9 0 0 1 9.95 20M2 8V6a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-6\"></path><line x1=\"2\" y1=\"20\" x2=\"2\" y2=\"20\"></line>","check-circle":"<path d=\"M22 11.08V12a10 10 0 1 1-5.93-9.14\"></path><polyline points=\"22 4 12 14.01 9 11.01\"></polyline>","check-square":"<polyline points=\"9 11 12 14 22 4\"></polyline><path d=\"M21 12v7a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11\"></path>","check":"<polyline points=\"20 6 9 17 4 12\"></polyline>","chevron-down":"<polyline points=\"6 9 12 15 18 9\"></polyline>","chevron-left":"<polyline points=\"15 18 9 12 15 6\"></polyline>","chevron-right":"<polyline points=\"9 18 15 12 9 6\"></polyline>","chevron-up":"<polyline points=\"18 15 12 9 6 15\"></polyline>","chevrons-down":"<polyline points=\"7 13 12 18 17 13\"></polyline><polyline points=\"7 6 12 11 17 6\"></polyline>","chevrons-left":"<polyline points=\"11 17 6 12 11 7\"></polyline><polyline points=\"18 17 13 12 18 7\"></polyline>","chevrons-right":"<polyline points=\"13 17 18 12 13 7\"></polyline><polyline points=\"6 17 11 12 6 7\"></polyline>","chevrons-up":"<polyline points=\"17 11 12 6 7 11\"></polyline><polyline points=\"17 18 12 13 7 18\"></polyline>","chrome":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><circle cx=\"12\" cy=\"12\" r=\"4\"></circle><line x1=\"21.17\" y1=\"8\" x2=\"12\" y2=\"8\"></line><line x1=\"3.95\" y1=\"6.06\" x2=\"8.54\" y2=\"14\"></line><line x1=\"10.88\" y1=\"21.94\" x2=\"15.46\" y2=\"14\"></line>","circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle>","clipboard":"<path d=\"M16 4h2a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2h2\"></path><rect x=\"8\" y=\"2\" width=\"8\" height=\"4\" rx=\"1\" ry=\"1\"></rect>","clock":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><polyline points=\"12 6 12 12 16 14\"></polyline>","cloud-drizzle":"<line x1=\"8\" y1=\"19\" x2=\"8\" y2=\"21\"></line><line x1=\"8\" y1=\"13\" x2=\"8\" y2=\"15\"></line><line x1=\"16\" y1=\"19\" x2=\"16\" y2=\"21\"></line><line x1=\"16\" y1=\"13\" x2=\"16\" y2=\"15\"></line><line x1=\"12\" y1=\"21\" x2=\"12\" y2=\"23\"></line><line x1=\"12\" y1=\"15\" x2=\"12\" y2=\"17\"></line><path d=\"M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25\"></path>","cloud-lightning":"<path d=\"M19 16.9A5 5 0 0 0 18 7h-1.26a8 8 0 1 0-11.62 9\"></path><polyline points=\"13 11 9 17 15 17 11 23\"></polyline>","cloud-off":"<path d=\"M22.61 16.95A5 5 0 0 0 18 10h-1.26a8 8 0 0 0-7.05-6M5 5a8 8 0 0 0 4 15h9a5 5 0 0 0 1.7-.3\"></path><line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line>","cloud-rain":"<line x1=\"16\" y1=\"13\" x2=\"16\" y2=\"21\"></line><line x1=\"8\" y1=\"13\" x2=\"8\" y2=\"21\"></line><line x1=\"12\" y1=\"15\" x2=\"12\" y2=\"23\"></line><path d=\"M20 16.58A5 5 0 0 0 18 7h-1.26A8 8 0 1 0 4 15.25\"></path>","cloud-snow":"<path d=\"M20 17.58A5 5 0 0 0 18 8h-1.26A8 8 0 1 0 4 16.25\"></path><line x1=\"8\" y1=\"16\" x2=\"8\" y2=\"16\"></line><line x1=\"8\" y1=\"20\" x2=\"8\" y2=\"20\"></line><line x1=\"12\" y1=\"18\" x2=\"12\" y2=\"18\"></line><line x1=\"12\" y1=\"22\" x2=\"12\" y2=\"22\"></line><line x1=\"16\" y1=\"16\" x2=\"16\" y2=\"16\"></line><line x1=\"16\" y1=\"20\" x2=\"16\" y2=\"20\"></line>","cloud":"<path d=\"M18 10h-1.26A8 8 0 1 0 9 20h9a5 5 0 0 0 0-10z\"></path>","code":"<polyline points=\"16 18 22 12 16 6\"></polyline><polyline points=\"8 6 2 12 8 18\"></polyline>","codepen":"<polygon points=\"12 2 22 8.5 22 15.5 12 22 2 15.5 2 8.5 12 2\"></polygon><line x1=\"12\" y1=\"22\" x2=\"12\" y2=\"15.5\"></line><polyline points=\"22 8.5 12 15.5 2 8.5\"></polyline><polyline points=\"2 15.5 12 8.5 22 15.5\"></polyline><line x1=\"12\" y1=\"2\" x2=\"12\" y2=\"8.5\"></line>","codesandbox":"<path d=\"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z\"></path><polyline points=\"7.5 4.21 12 6.81 16.5 4.21\"></polyline><polyline points=\"7.5 19.79 7.5 14.6 3 12\"></polyline><polyline points=\"21 12 16.5 14.6 16.5 19.79\"></polyline><polyline points=\"3.27 6.96 12 12.01 20.73 6.96\"></polyline><line x1=\"12\" y1=\"22.08\" x2=\"12\" y2=\"12\"></line>","coffee":"<path d=\"M18 8h1a4 4 0 0 1 0 8h-1\"></path><path d=\"M2 8h16v9a4 4 0 0 1-4 4H6a4 4 0 0 1-4-4V8z\"></path><line x1=\"6\" y1=\"1\" x2=\"6\" y2=\"4\"></line><line x1=\"10\" y1=\"1\" x2=\"10\" y2=\"4\"></line><line x1=\"14\" y1=\"1\" x2=\"14\" y2=\"4\"></line>","columns":"<path d=\"M12 3h7a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-7m0-18H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h7m0-18v18\"></path>","command":"<path d=\"M18 3a3 3 0 0 0-3 3v12a3 3 0 0 0 3 3 3 3 0 0 0 3-3 3 3 0 0 0-3-3H6a3 3 0 0 0-3 3 3 3 0 0 0 3 3 3 3 0 0 0 3-3V6a3 3 0 0 0-3-3 3 3 0 0 0-3 3 3 3 0 0 0 3 3h12a3 3 0 0 0 3-3 3 3 0 0 0-3-3z\"></path>","compass":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><polygon points=\"16.24 7.76 14.12 14.12 7.76 16.24 9.88 9.88 16.24 7.76\"></polygon>","copy":"<rect x=\"9\" y=\"9\" width=\"13\" height=\"13\" rx=\"2\" ry=\"2\"></rect><path d=\"M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1\"></path>","corner-down-left":"<polyline points=\"9 10 4 15 9 20\"></polyline><path d=\"M20 4v7a4 4 0 0 1-4 4H4\"></path>","corner-down-right":"<polyline points=\"15 10 20 15 15 20\"></polyline><path d=\"M4 4v7a4 4 0 0 0 4 4h12\"></path>","corner-left-down":"<polyline points=\"14 15 9 20 4 15\"></polyline><path d=\"M20 4h-7a4 4 0 0 0-4 4v12\"></path>","corner-left-up":"<polyline points=\"14 9 9 4 4 9\"></polyline><path d=\"M20 20h-7a4 4 0 0 1-4-4V4\"></path>","corner-right-down":"<polyline points=\"10 15 15 20 20 15\"></polyline><path d=\"M4 4h7a4 4 0 0 1 4 4v12\"></path>","corner-right-up":"<polyline points=\"10 9 15 4 20 9\"></polyline><path d=\"M4 20h7a4 4 0 0 0 4-4V4\"></path>","corner-up-left":"<polyline points=\"9 14 4 9 9 4\"></polyline><path d=\"M20 20v-7a4 4 0 0 0-4-4H4\"></path>","corner-up-right":"<polyline points=\"15 14 20 9 15 4\"></polyline><path d=\"M4 20v-7a4 4 0 0 1 4-4h12\"></path>","cpu":"<rect x=\"4\" y=\"4\" width=\"16\" height=\"16\" rx=\"2\" ry=\"2\"></rect><rect x=\"9\" y=\"9\" width=\"6\" height=\"6\"></rect><line x1=\"9\" y1=\"1\" x2=\"9\" y2=\"4\"></line><line x1=\"15\" y1=\"1\" x2=\"15\" y2=\"4\"></line><line x1=\"9\" y1=\"20\" x2=\"9\" y2=\"23\"></line><line x1=\"15\" y1=\"20\" x2=\"15\" y2=\"23\"></line><line x1=\"20\" y1=\"9\" x2=\"23\" y2=\"9\"></line><line x1=\"20\" y1=\"14\" x2=\"23\" y2=\"14\"></line><line x1=\"1\" y1=\"9\" x2=\"4\" y2=\"9\"></line><line x1=\"1\" y1=\"14\" x2=\"4\" y2=\"14\"></line>","credit-card":"<rect x=\"1\" y=\"4\" width=\"22\" height=\"16\" rx=\"2\" ry=\"2\"></rect><line x1=\"1\" y1=\"10\" x2=\"23\" y2=\"10\"></line>","crop":"<path d=\"M6.13 1L6 16a2 2 0 0 0 2 2h15\"></path><path d=\"M1 6.13L16 6a2 2 0 0 1 2 2v15\"></path>","crosshair":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"22\" y1=\"12\" x2=\"18\" y2=\"12\"></line><line x1=\"6\" y1=\"12\" x2=\"2\" y2=\"12\"></line><line x1=\"12\" y1=\"6\" x2=\"12\" y2=\"2\"></line><line x1=\"12\" y1=\"22\" x2=\"12\" y2=\"18\"></line>","database":"<ellipse cx=\"12\" cy=\"5\" rx=\"9\" ry=\"3\"></ellipse><path d=\"M21 12c0 1.66-4 3-9 3s-9-1.34-9-3\"></path><path d=\"M3 5v14c0 1.66 4 3 9 3s9-1.34 9-3V5\"></path>","delete":"<path d=\"M21 4H8l-7 8 7 8h13a2 2 0 0 0 2-2V6a2 2 0 0 0-2-2z\"></path><line x1=\"18\" y1=\"9\" x2=\"12\" y2=\"15\"></line><line x1=\"12\" y1=\"9\" x2=\"18\" y2=\"15\"></line>","disc":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><circle cx=\"12\" cy=\"12\" r=\"3\"></circle>","dollar-sign":"<line x1=\"12\" y1=\"1\" x2=\"12\" y2=\"23\"></line><path d=\"M17 5H9.5a3.5 3.5 0 0 0 0 7h5a3.5 3.5 0 0 1 0 7H6\"></path>","download-cloud":"<polyline points=\"8 17 12 21 16 17\"></polyline><line x1=\"12\" y1=\"12\" x2=\"12\" y2=\"21\"></line><path d=\"M20.88 18.09A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.29\"></path>","download":"<path d=\"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4\"></path><polyline points=\"7 10 12 15 17 10\"></polyline><line x1=\"12\" y1=\"15\" x2=\"12\" y2=\"3\"></line>","droplet":"<path d=\"M12 2.69l5.66 5.66a8 8 0 1 1-11.31 0z\"></path>","edit-2":"<path d=\"M17 3a2.828 2.828 0 1 1 4 4L7.5 20.5 2 22l1.5-5.5L17 3z\"></path>","edit-3":"<path d=\"M12 20h9\"></path><path d=\"M16.5 3.5a2.121 2.121 0 0 1 3 3L7 19l-4 1 1-4L16.5 3.5z\"></path>","edit":"<path d=\"M11 4H4a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2v-7\"></path><path d=\"M18.5 2.5a2.121 2.121 0 0 1 3 3L12 15l-4 1 1-4 9.5-9.5z\"></path>","external-link":"<path d=\"M18 13v6a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8a2 2 0 0 1 2-2h6\"></path><polyline points=\"15 3 21 3 21 9\"></polyline><line x1=\"10\" y1=\"14\" x2=\"21\" y2=\"3\"></line>","eye-off":"<path d=\"M17.94 17.94A10.07 10.07 0 0 1 12 20c-7 0-11-8-11-8a18.45 18.45 0 0 1 5.06-5.94M9.9 4.24A9.12 9.12 0 0 1 12 4c7 0 11 8 11 8a18.5 18.5 0 0 1-2.16 3.19m-6.72-1.07a3 3 0 1 1-4.24-4.24\"></path><line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line>","eye":"<path d=\"M1 12s4-8 11-8 11 8 11 8-4 8-11 8-11-8-11-8z\"></path><circle cx=\"12\" cy=\"12\" r=\"3\"></circle>","facebook":"<path d=\"M18 2h-3a5 5 0 0 0-5 5v3H7v4h3v8h4v-8h3l1-4h-4V7a1 1 0 0 1 1-1h3z\"></path>","fast-forward":"<polygon points=\"13 19 22 12 13 5 13 19\"></polygon><polygon points=\"2 19 11 12 2 5 2 19\"></polygon>","feather":"<path d=\"M20.24 12.24a6 6 0 0 0-8.49-8.49L5 10.5V19h8.5z\"></path><line x1=\"16\" y1=\"8\" x2=\"2\" y2=\"22\"></line><line x1=\"17.5\" y1=\"15\" x2=\"9\" y2=\"15\"></line>","figma":"<path d=\"M5 5.5A3.5 3.5 0 0 1 8.5 2H12v7H8.5A3.5 3.5 0 0 1 5 5.5z\"></path><path d=\"M12 2h3.5a3.5 3.5 0 1 1 0 7H12V2z\"></path><path d=\"M12 12.5a3.5 3.5 0 1 1 7 0 3.5 3.5 0 1 1-7 0z\"></path><path d=\"M5 19.5A3.5 3.5 0 0 1 8.5 16H12v3.5a3.5 3.5 0 1 1-7 0z\"></path><path d=\"M5 12.5A3.5 3.5 0 0 1 8.5 9H12v7H8.5A3.5 3.5 0 0 1 5 12.5z\"></path>","file-minus":"<path d=\"M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z\"></path><polyline points=\"14 2 14 8 20 8\"></polyline><line x1=\"9\" y1=\"15\" x2=\"15\" y2=\"15\"></line>","file-plus":"<path d=\"M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z\"></path><polyline points=\"14 2 14 8 20 8\"></polyline><line x1=\"12\" y1=\"18\" x2=\"12\" y2=\"12\"></line><line x1=\"9\" y1=\"15\" x2=\"15\" y2=\"15\"></line>","file-text":"<path d=\"M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z\"></path><polyline points=\"14 2 14 8 20 8\"></polyline><line x1=\"16\" y1=\"13\" x2=\"8\" y2=\"13\"></line><line x1=\"16\" y1=\"17\" x2=\"8\" y2=\"17\"></line><polyline points=\"10 9 9 9 8 9\"></polyline>","file":"<path d=\"M13 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V9z\"></path><polyline points=\"13 2 13 9 20 9\"></polyline>","film":"<rect x=\"2\" y=\"2\" width=\"20\" height=\"20\" rx=\"2.18\" ry=\"2.18\"></rect><line x1=\"7\" y1=\"2\" x2=\"7\" y2=\"22\"></line><line x1=\"17\" y1=\"2\" x2=\"17\" y2=\"22\"></line><line x1=\"2\" y1=\"12\" x2=\"22\" y2=\"12\"></line><line x1=\"2\" y1=\"7\" x2=\"7\" y2=\"7\"></line><line x1=\"2\" y1=\"17\" x2=\"7\" y2=\"17\"></line><line x1=\"17\" y1=\"17\" x2=\"22\" y2=\"17\"></line><line x1=\"17\" y1=\"7\" x2=\"22\" y2=\"7\"></line>","filter":"<polygon points=\"22 3 2 3 10 12.46 10 19 14 21 14 12.46 22 3\"></polygon>","flag":"<path d=\"M4 15s1-1 4-1 5 2 8 2 4-1 4-1V3s-1 1-4 1-5-2-8-2-4 1-4 1z\"></path><line x1=\"4\" y1=\"22\" x2=\"4\" y2=\"15\"></line>","folder-minus":"<path d=\"M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z\"></path><line x1=\"9\" y1=\"14\" x2=\"15\" y2=\"14\"></line>","folder-plus":"<path d=\"M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z\"></path><line x1=\"12\" y1=\"11\" x2=\"12\" y2=\"17\"></line><line x1=\"9\" y1=\"14\" x2=\"15\" y2=\"14\"></line>","folder":"<path d=\"M22 19a2 2 0 0 1-2 2H4a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h5l2 3h9a2 2 0 0 1 2 2z\"></path>","framer":"<path d=\"M5 16V9h14V2H5l14 14h-7m-7 0l7 7v-7m-7 0h7\"></path>","frown":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><path d=\"M16 16s-1.5-2-4-2-4 2-4 2\"></path><line x1=\"9\" y1=\"9\" x2=\"9.01\" y2=\"9\"></line><line x1=\"15\" y1=\"9\" x2=\"15.01\" y2=\"9\"></line>","gift":"<polyline points=\"20 12 20 22 4 22 4 12\"></polyline><rect x=\"2\" y=\"7\" width=\"20\" height=\"5\"></rect><line x1=\"12\" y1=\"22\" x2=\"12\" y2=\"7\"></line><path d=\"M12 7H7.5a2.5 2.5 0 0 1 0-5C11 2 12 7 12 7z\"></path><path d=\"M12 7h4.5a2.5 2.5 0 0 0 0-5C13 2 12 7 12 7z\"></path>","git-branch":"<line x1=\"6\" y1=\"3\" x2=\"6\" y2=\"15\"></line><circle cx=\"18\" cy=\"6\" r=\"3\"></circle><circle cx=\"6\" cy=\"18\" r=\"3\"></circle><path d=\"M18 9a9 9 0 0 1-9 9\"></path>","git-commit":"<circle cx=\"12\" cy=\"12\" r=\"4\"></circle><line x1=\"1.05\" y1=\"12\" x2=\"7\" y2=\"12\"></line><line x1=\"17.01\" y1=\"12\" x2=\"22.96\" y2=\"12\"></line>","git-merge":"<circle cx=\"18\" cy=\"18\" r=\"3\"></circle><circle cx=\"6\" cy=\"6\" r=\"3\"></circle><path d=\"M6 21V9a9 9 0 0 0 9 9\"></path>","git-pull-request":"<circle cx=\"18\" cy=\"18\" r=\"3\"></circle><circle cx=\"6\" cy=\"6\" r=\"3\"></circle><path d=\"M13 6h3a2 2 0 0 1 2 2v7\"></path><line x1=\"6\" y1=\"9\" x2=\"6\" y2=\"21\"></line>","github":"<path d=\"M9 19c-5 1.5-5-2.5-7-3m14 6v-3.87a3.37 3.37 0 0 0-.94-2.61c3.14-.35 6.44-1.54 6.44-7A5.44 5.44 0 0 0 20 4.77 5.07 5.07 0 0 0 19.91 1S18.73.65 16 2.48a13.38 13.38 0 0 0-7 0C6.27.65 5.09 1 5.09 1A5.07 5.07 0 0 0 5 4.77a5.44 5.44 0 0 0-1.5 3.78c0 5.42 3.3 6.61 6.44 7A3.37 3.37 0 0 0 9 18.13V22\"></path>","gitlab":"<path d=\"M22.65 14.39L12 22.13 1.35 14.39a.84.84 0 0 1-.3-.94l1.22-3.78 2.44-7.51A.42.42 0 0 1 4.82 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.49h8.1l2.44-7.51A.42.42 0 0 1 18.6 2a.43.43 0 0 1 .58 0 .42.42 0 0 1 .11.18l2.44 7.51L23 13.45a.84.84 0 0 1-.35.94z\"></path>","globe":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"2\" y1=\"12\" x2=\"22\" y2=\"12\"></line><path d=\"M12 2a15.3 15.3 0 0 1 4 10 15.3 15.3 0 0 1-4 10 15.3 15.3 0 0 1-4-10 15.3 15.3 0 0 1 4-10z\"></path>","grid":"<rect x=\"3\" y=\"3\" width=\"7\" height=\"7\"></rect><rect x=\"14\" y=\"3\" width=\"7\" height=\"7\"></rect><rect x=\"14\" y=\"14\" width=\"7\" height=\"7\"></rect><rect x=\"3\" y=\"14\" width=\"7\" height=\"7\"></rect>","hard-drive":"<line x1=\"22\" y1=\"12\" x2=\"2\" y2=\"12\"></line><path d=\"M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z\"></path><line x1=\"6\" y1=\"16\" x2=\"6\" y2=\"16\"></line><line x1=\"10\" y1=\"16\" x2=\"10\" y2=\"16\"></line>","hash":"<line x1=\"4\" y1=\"9\" x2=\"20\" y2=\"9\"></line><line x1=\"4\" y1=\"15\" x2=\"20\" y2=\"15\"></line><line x1=\"10\" y1=\"3\" x2=\"8\" y2=\"21\"></line><line x1=\"16\" y1=\"3\" x2=\"14\" y2=\"21\"></line>","headphones":"<path d=\"M3 18v-6a9 9 0 0 1 18 0v6\"></path><path d=\"M21 19a2 2 0 0 1-2 2h-1a2 2 0 0 1-2-2v-3a2 2 0 0 1 2-2h3zM3 19a2 2 0 0 0 2 2h1a2 2 0 0 0 2-2v-3a2 2 0 0 0-2-2H3z\"></path>","heart":"<path d=\"M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z\"></path>","help-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><path d=\"M9.09 9a3 3 0 0 1 5.83 1c0 2-3 3-3 3\"></path><line x1=\"12\" y1=\"17\" x2=\"12\" y2=\"17\"></line>","hexagon":"<path d=\"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z\"></path>","home":"<path d=\"M3 9l9-7 9 7v11a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2z\"></path><polyline points=\"9 22 9 12 15 12 15 22\"></polyline>","image":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><circle cx=\"8.5\" cy=\"8.5\" r=\"1.5\"></circle><polyline points=\"21 15 16 10 5 21\"></polyline>","inbox":"<polyline points=\"22 12 16 12 14 15 10 15 8 12 2 12\"></polyline><path d=\"M5.45 5.11L2 12v6a2 2 0 0 0 2 2h16a2 2 0 0 0 2-2v-6l-3.45-6.89A2 2 0 0 0 16.76 4H7.24a2 2 0 0 0-1.79 1.11z\"></path>","info":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"12\" y1=\"16\" x2=\"12\" y2=\"12\"></line><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"8\"></line>","instagram":"<rect x=\"2\" y=\"2\" width=\"20\" height=\"20\" rx=\"5\" ry=\"5\"></rect><path d=\"M16 11.37A4 4 0 1 1 12.63 8 4 4 0 0 1 16 11.37z\"></path><line x1=\"17.5\" y1=\"6.5\" x2=\"17.5\" y2=\"6.5\"></line>","italic":"<line x1=\"19\" y1=\"4\" x2=\"10\" y2=\"4\"></line><line x1=\"14\" y1=\"20\" x2=\"5\" y2=\"20\"></line><line x1=\"15\" y1=\"4\" x2=\"9\" y2=\"20\"></line>","key":"<path d=\"M21 2l-2 2m-7.61 7.61a5.5 5.5 0 1 1-7.778 7.778 5.5 5.5 0 0 1 7.777-7.777zm0 0L15.5 7.5m0 0l3 3L22 7l-3-3m-3.5 3.5L19 4\"></path>","layers":"<polygon points=\"12 2 2 7 12 12 22 7 12 2\"></polygon><polyline points=\"2 17 12 22 22 17\"></polyline><polyline points=\"2 12 12 17 22 12\"></polyline>","layout":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><line x1=\"3\" y1=\"9\" x2=\"21\" y2=\"9\"></line><line x1=\"9\" y1=\"21\" x2=\"9\" y2=\"9\"></line>","life-buoy":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><circle cx=\"12\" cy=\"12\" r=\"4\"></circle><line x1=\"4.93\" y1=\"4.93\" x2=\"9.17\" y2=\"9.17\"></line><line x1=\"14.83\" y1=\"14.83\" x2=\"19.07\" y2=\"19.07\"></line><line x1=\"14.83\" y1=\"9.17\" x2=\"19.07\" y2=\"4.93\"></line><line x1=\"14.83\" y1=\"9.17\" x2=\"18.36\" y2=\"5.64\"></line><line x1=\"4.93\" y1=\"19.07\" x2=\"9.17\" y2=\"14.83\"></line>","link-2":"<path d=\"M15 7h3a5 5 0 0 1 5 5 5 5 0 0 1-5 5h-3m-6 0H6a5 5 0 0 1-5-5 5 5 0 0 1 5-5h3\"></path><line x1=\"8\" y1=\"12\" x2=\"16\" y2=\"12\"></line>","link":"<path d=\"M10 13a5 5 0 0 0 7.54.54l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71\"></path><path d=\"M14 11a5 5 0 0 0-7.54-.54l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71\"></path>","linkedin":"<path d=\"M16 8a6 6 0 0 1 6 6v7h-4v-7a2 2 0 0 0-2-2 2 2 0 0 0-2 2v7h-4v-7a6 6 0 0 1 6-6z\"></path><rect x=\"2\" y=\"9\" width=\"4\" height=\"12\"></rect><circle cx=\"4\" cy=\"4\" r=\"2\"></circle>","list":"<line x1=\"8\" y1=\"6\" x2=\"21\" y2=\"6\"></line><line x1=\"8\" y1=\"12\" x2=\"21\" y2=\"12\"></line><line x1=\"8\" y1=\"18\" x2=\"21\" y2=\"18\"></line><line x1=\"3\" y1=\"6\" x2=\"3\" y2=\"6\"></line><line x1=\"3\" y1=\"12\" x2=\"3\" y2=\"12\"></line><line x1=\"3\" y1=\"18\" x2=\"3\" y2=\"18\"></line>","loader":"<line x1=\"12\" y1=\"2\" x2=\"12\" y2=\"6\"></line><line x1=\"12\" y1=\"18\" x2=\"12\" y2=\"22\"></line><line x1=\"4.93\" y1=\"4.93\" x2=\"7.76\" y2=\"7.76\"></line><line x1=\"16.24\" y1=\"16.24\" x2=\"19.07\" y2=\"19.07\"></line><line x1=\"2\" y1=\"12\" x2=\"6\" y2=\"12\"></line><line x1=\"18\" y1=\"12\" x2=\"22\" y2=\"12\"></line><line x1=\"4.93\" y1=\"19.07\" x2=\"7.76\" y2=\"16.24\"></line><line x1=\"16.24\" y1=\"7.76\" x2=\"19.07\" y2=\"4.93\"></line>","lock":"<rect x=\"3\" y=\"11\" width=\"18\" height=\"11\" rx=\"2\" ry=\"2\"></rect><path d=\"M7 11V7a5 5 0 0 1 10 0v4\"></path>","log-in":"<path d=\"M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4\"></path><polyline points=\"10 17 15 12 10 7\"></polyline><line x1=\"15\" y1=\"12\" x2=\"3\" y2=\"12\"></line>","log-out":"<path d=\"M9 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h4\"></path><polyline points=\"16 17 21 12 16 7\"></polyline><line x1=\"21\" y1=\"12\" x2=\"9\" y2=\"12\"></line>","mail":"<path d=\"M4 4h16c1.1 0 2 .9 2 2v12c0 1.1-.9 2-2 2H4c-1.1 0-2-.9-2-2V6c0-1.1.9-2 2-2z\"></path><polyline points=\"22,6 12,13 2,6\"></polyline>","map-pin":"<path d=\"M21 10c0 7-9 13-9 13s-9-6-9-13a9 9 0 0 1 18 0z\"></path><circle cx=\"12\" cy=\"10\" r=\"3\"></circle>","map":"<polygon points=\"1 6 1 22 8 18 16 22 23 18 23 2 16 6 8 2 1 6\"></polygon><line x1=\"8\" y1=\"2\" x2=\"8\" y2=\"18\"></line><line x1=\"16\" y1=\"6\" x2=\"16\" y2=\"22\"></line>","maximize-2":"<polyline points=\"15 3 21 3 21 9\"></polyline><polyline points=\"9 21 3 21 3 15\"></polyline><line x1=\"21\" y1=\"3\" x2=\"14\" y2=\"10\"></line><line x1=\"3\" y1=\"21\" x2=\"10\" y2=\"14\"></line>","maximize":"<path d=\"M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3\"></path>","meh":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"8\" y1=\"15\" x2=\"16\" y2=\"15\"></line><line x1=\"9\" y1=\"9\" x2=\"9.01\" y2=\"9\"></line><line x1=\"15\" y1=\"9\" x2=\"15.01\" y2=\"9\"></line>","menu":"<line x1=\"3\" y1=\"12\" x2=\"21\" y2=\"12\"></line><line x1=\"3\" y1=\"6\" x2=\"21\" y2=\"6\"></line><line x1=\"3\" y1=\"18\" x2=\"21\" y2=\"18\"></line>","message-circle":"<path d=\"M21 11.5a8.38 8.38 0 0 1-.9 3.8 8.5 8.5 0 0 1-7.6 4.7 8.38 8.38 0 0 1-3.8-.9L3 21l1.9-5.7a8.38 8.38 0 0 1-.9-3.8 8.5 8.5 0 0 1 4.7-7.6 8.38 8.38 0 0 1 3.8-.9h.5a8.48 8.48 0 0 1 8 8v.5z\"></path>","message-square":"<path d=\"M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z\"></path>","mic-off":"<line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line><path d=\"M9 9v3a3 3 0 0 0 5.12 2.12M15 9.34V4a3 3 0 0 0-5.94-.6\"></path><path d=\"M17 16.95A7 7 0 0 1 5 12v-2m14 0v2a7 7 0 0 1-.11 1.23\"></path><line x1=\"12\" y1=\"19\" x2=\"12\" y2=\"23\"></line><line x1=\"8\" y1=\"23\" x2=\"16\" y2=\"23\"></line>","mic":"<path d=\"M12 1a3 3 0 0 0-3 3v8a3 3 0 0 0 6 0V4a3 3 0 0 0-3-3z\"></path><path d=\"M19 10v2a7 7 0 0 1-14 0v-2\"></path><line x1=\"12\" y1=\"19\" x2=\"12\" y2=\"23\"></line><line x1=\"8\" y1=\"23\" x2=\"16\" y2=\"23\"></line>","minimize-2":"<polyline points=\"4 14 10 14 10 20\"></polyline><polyline points=\"20 10 14 10 14 4\"></polyline><line x1=\"14\" y1=\"10\" x2=\"21\" y2=\"3\"></line><line x1=\"3\" y1=\"21\" x2=\"10\" y2=\"14\"></line>","minimize":"<path d=\"M8 3v3a2 2 0 0 1-2 2H3m18 0h-3a2 2 0 0 1-2-2V3m0 18v-3a2 2 0 0 1 2-2h3M3 16h3a2 2 0 0 1 2 2v3\"></path>","minus-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"8\" y1=\"12\" x2=\"16\" y2=\"12\"></line>","minus-square":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><line x1=\"8\" y1=\"12\" x2=\"16\" y2=\"12\"></line>","minus":"<line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line>","monitor":"<rect x=\"2\" y=\"3\" width=\"20\" height=\"14\" rx=\"2\" ry=\"2\"></rect><line x1=\"8\" y1=\"21\" x2=\"16\" y2=\"21\"></line><line x1=\"12\" y1=\"17\" x2=\"12\" y2=\"21\"></line>","moon":"<path d=\"M21 12.79A9 9 0 1 1 11.21 3 7 7 0 0 0 21 12.79z\"></path>","more-horizontal":"<circle cx=\"12\" cy=\"12\" r=\"1\"></circle><circle cx=\"19\" cy=\"12\" r=\"1\"></circle><circle cx=\"5\" cy=\"12\" r=\"1\"></circle>","more-vertical":"<circle cx=\"12\" cy=\"12\" r=\"1\"></circle><circle cx=\"12\" cy=\"5\" r=\"1\"></circle><circle cx=\"12\" cy=\"19\" r=\"1\"></circle>","mouse-pointer":"<path d=\"M3 3l7.07 16.97 2.51-7.39 7.39-2.51L3 3z\"></path><path d=\"M13 13l6 6\"></path>","move":"<polyline points=\"5 9 2 12 5 15\"></polyline><polyline points=\"9 5 12 2 15 5\"></polyline><polyline points=\"15 19 12 22 9 19\"></polyline><polyline points=\"19 9 22 12 19 15\"></polyline><line x1=\"2\" y1=\"12\" x2=\"22\" y2=\"12\"></line><line x1=\"12\" y1=\"2\" x2=\"12\" y2=\"22\"></line>","music":"<path d=\"M9 18V5l12-2v13\"></path><circle cx=\"6\" cy=\"18\" r=\"3\"></circle><circle cx=\"18\" cy=\"16\" r=\"3\"></circle>","navigation-2":"<polygon points=\"12 2 19 21 12 17 5 21 12 2\"></polygon>","navigation":"<polygon points=\"3 11 22 2 13 21 11 13 3 11\"></polygon>","octagon":"<polygon points=\"7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2\"></polygon>","package":"<line x1=\"16.5\" y1=\"9.4\" x2=\"7.5\" y2=\"4.21\"></line><path d=\"M21 16V8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16z\"></path><polyline points=\"3.27 6.96 12 12.01 20.73 6.96\"></polyline><line x1=\"12\" y1=\"22.08\" x2=\"12\" y2=\"12\"></line>","paperclip":"<path d=\"M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48\"></path>","pause-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"10\" y1=\"15\" x2=\"10\" y2=\"9\"></line><line x1=\"14\" y1=\"15\" x2=\"14\" y2=\"9\"></line>","pause":"<rect x=\"6\" y=\"4\" width=\"4\" height=\"16\"></rect><rect x=\"14\" y=\"4\" width=\"4\" height=\"16\"></rect>","pen-tool":"<path d=\"M12 19l7-7 3 3-7 7-3-3z\"></path><path d=\"M18 13l-1.5-7.5L2 2l3.5 14.5L13 18l5-5z\"></path><path d=\"M2 2l7.586 7.586\"></path><circle cx=\"11\" cy=\"11\" r=\"2\"></circle>","percent":"<line x1=\"19\" y1=\"5\" x2=\"5\" y2=\"19\"></line><circle cx=\"6.5\" cy=\"6.5\" r=\"2.5\"></circle><circle cx=\"17.5\" cy=\"17.5\" r=\"2.5\"></circle>","phone-call":"<path d=\"M15.05 5A5 5 0 0 1 19 8.95M15.05 1A9 9 0 0 1 23 8.94m-1 7.98v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z\"></path>","phone-forwarded":"<polyline points=\"19 1 23 5 19 9\"></polyline><line x1=\"15\" y1=\"5\" x2=\"23\" y2=\"5\"></line><path d=\"M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z\"></path>","phone-incoming":"<polyline points=\"16 2 16 8 22 8\"></polyline><line x1=\"23\" y1=\"1\" x2=\"16\" y2=\"8\"></line><path d=\"M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z\"></path>","phone-missed":"<line x1=\"23\" y1=\"1\" x2=\"17\" y2=\"7\"></line><line x1=\"17\" y1=\"1\" x2=\"23\" y2=\"7\"></line><path d=\"M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z\"></path>","phone-off":"<path d=\"M10.68 13.31a16 16 0 0 0 3.41 2.6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7 2 2 0 0 1 1.72 2v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.42 19.42 0 0 1-3.33-2.67m-2.67-3.34a19.79 19.79 0 0 1-3.07-8.63A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91\"></path><line x1=\"23\" y1=\"1\" x2=\"1\" y2=\"23\"></line>","phone-outgoing":"<polyline points=\"23 7 23 1 17 1\"></polyline><line x1=\"16\" y1=\"8\" x2=\"23\" y2=\"1\"></line><path d=\"M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z\"></path>","phone":"<path d=\"M22 16.92v3a2 2 0 0 1-2.18 2 19.79 19.79 0 0 1-8.63-3.07 19.5 19.5 0 0 1-6-6 19.79 19.79 0 0 1-3.07-8.67A2 2 0 0 1 4.11 2h3a2 2 0 0 1 2 1.72 12.84 12.84 0 0 0 .7 2.81 2 2 0 0 1-.45 2.11L8.09 9.91a16 16 0 0 0 6 6l1.27-1.27a2 2 0 0 1 2.11-.45 12.84 12.84 0 0 0 2.81.7A2 2 0 0 1 22 16.92z\"></path>","pie-chart":"<path d=\"M21.21 15.89A10 10 0 1 1 8 2.83\"></path><path d=\"M22 12A10 10 0 0 0 12 2v10z\"></path>","play-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><polygon points=\"10 8 16 12 10 16 10 8\"></polygon>","play":"<polygon points=\"5 3 19 12 5 21 5 3\"></polygon>","plus-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"16\"></line><line x1=\"8\" y1=\"12\" x2=\"16\" y2=\"12\"></line>","plus-square":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"16\"></line><line x1=\"8\" y1=\"12\" x2=\"16\" y2=\"12\"></line>","plus":"<line x1=\"12\" y1=\"5\" x2=\"12\" y2=\"19\"></line><line x1=\"5\" y1=\"12\" x2=\"19\" y2=\"12\"></line>","pocket":"<path d=\"M4 3h16a2 2 0 0 1 2 2v6a10 10 0 0 1-10 10A10 10 0 0 1 2 11V5a2 2 0 0 1 2-2z\"></path><polyline points=\"8 10 12 14 16 10\"></polyline>","power":"<path d=\"M18.36 6.64a9 9 0 1 1-12.73 0\"></path><line x1=\"12\" y1=\"2\" x2=\"12\" y2=\"12\"></line>","printer":"<polyline points=\"6 9 6 2 18 2 18 9\"></polyline><path d=\"M6 18H4a2 2 0 0 1-2-2v-5a2 2 0 0 1 2-2h16a2 2 0 0 1 2 2v5a2 2 0 0 1-2 2h-2\"></path><rect x=\"6\" y=\"14\" width=\"12\" height=\"8\"></rect>","radio":"<circle cx=\"12\" cy=\"12\" r=\"2\"></circle><path d=\"M16.24 7.76a6 6 0 0 1 0 8.49m-8.48-.01a6 6 0 0 1 0-8.49m11.31-2.82a10 10 0 0 1 0 14.14m-14.14 0a10 10 0 0 1 0-14.14\"></path>","refresh-ccw":"<polyline points=\"1 4 1 10 7 10\"></polyline><polyline points=\"23 20 23 14 17 14\"></polyline><path d=\"M20.49 9A9 9 0 0 0 5.64 5.64L1 10m22 4l-4.64 4.36A9 9 0 0 1 3.51 15\"></path>","refresh-cw":"<polyline points=\"23 4 23 10 17 10\"></polyline><polyline points=\"1 20 1 14 7 14\"></polyline><path d=\"M3.51 9a9 9 0 0 1 14.85-3.36L23 10M1 14l4.64 4.36A9 9 0 0 0 20.49 15\"></path>","repeat":"<polyline points=\"17 1 21 5 17 9\"></polyline><path d=\"M3 11V9a4 4 0 0 1 4-4h14\"></path><polyline points=\"7 23 3 19 7 15\"></polyline><path d=\"M21 13v2a4 4 0 0 1-4 4H3\"></path>","rewind":"<polygon points=\"11 19 2 12 11 5 11 19\"></polygon><polygon points=\"22 19 13 12 22 5 22 19\"></polygon>","rotate-ccw":"<polyline points=\"1 4 1 10 7 10\"></polyline><path d=\"M3.51 15a9 9 0 1 0 2.13-9.36L1 10\"></path>","rotate-cw":"<polyline points=\"23 4 23 10 17 10\"></polyline><path d=\"M20.49 15a9 9 0 1 1-2.12-9.36L23 10\"></path>","rss":"<path d=\"M4 11a9 9 0 0 1 9 9\"></path><path d=\"M4 4a16 16 0 0 1 16 16\"></path><circle cx=\"5\" cy=\"19\" r=\"1\"></circle>","save":"<path d=\"M19 21H5a2 2 0 0 1-2-2V5a2 2 0 0 1 2-2h11l5 5v11a2 2 0 0 1-2 2z\"></path><polyline points=\"17 21 17 13 7 13 7 21\"></polyline><polyline points=\"7 3 7 8 15 8\"></polyline>","scissors":"<circle cx=\"6\" cy=\"6\" r=\"3\"></circle><circle cx=\"6\" cy=\"18\" r=\"3\"></circle><line x1=\"20\" y1=\"4\" x2=\"8.12\" y2=\"15.88\"></line><line x1=\"14.47\" y1=\"14.48\" x2=\"20\" y2=\"20\"></line><line x1=\"8.12\" y1=\"8.12\" x2=\"12\" y2=\"12\"></line>","search":"<circle cx=\"11\" cy=\"11\" r=\"8\"></circle><line x1=\"21\" y1=\"21\" x2=\"16.65\" y2=\"16.65\"></line>","send":"<line x1=\"22\" y1=\"2\" x2=\"11\" y2=\"13\"></line><polygon points=\"22 2 15 22 11 13 2 9 22 2\"></polygon>","server":"<rect x=\"2\" y=\"2\" width=\"20\" height=\"8\" rx=\"2\" ry=\"2\"></rect><rect x=\"2\" y=\"14\" width=\"20\" height=\"8\" rx=\"2\" ry=\"2\"></rect><line x1=\"6\" y1=\"6\" x2=\"6\" y2=\"6\"></line><line x1=\"6\" y1=\"18\" x2=\"6\" y2=\"18\"></line>","settings":"<circle cx=\"12\" cy=\"12\" r=\"3\"></circle><path d=\"M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 0 1 0 2.83 2 2 0 0 1-2.83 0l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 0 1-2 2 2 2 0 0 1-2-2v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 0 1-2.83 0 2 2 0 0 1 0-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 0 1-2-2 2 2 0 0 1 2-2h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 0 1 0-2.83 2 2 0 0 1 2.83 0l.06.06a1.65 1.65 0 0 0 1.82.33H9a1.65 1.65 0 0 0 1-1.51V3a2 2 0 0 1 2-2 2 2 0 0 1 2 2v.09a1.65 1.65 0 0 0 1 1.51 1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 0 1 2.83 0 2 2 0 0 1 0 2.83l-.06.06a1.65 1.65 0 0 0-.33 1.82V9a1.65 1.65 0 0 0 1.51 1H21a2 2 0 0 1 2 2 2 2 0 0 1-2 2h-.09a1.65 1.65 0 0 0-1.51 1z\"></path>","share-2":"<circle cx=\"18\" cy=\"5\" r=\"3\"></circle><circle cx=\"6\" cy=\"12\" r=\"3\"></circle><circle cx=\"18\" cy=\"19\" r=\"3\"></circle><line x1=\"8.59\" y1=\"13.51\" x2=\"15.42\" y2=\"17.49\"></line><line x1=\"15.41\" y1=\"6.51\" x2=\"8.59\" y2=\"10.49\"></line>","share":"<path d=\"M4 12v8a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2v-8\"></path><polyline points=\"16 6 12 2 8 6\"></polyline><line x1=\"12\" y1=\"2\" x2=\"12\" y2=\"15\"></line>","shield-off":"<path d=\"M19.69 14a6.9 6.9 0 0 0 .31-2V5l-8-3-3.16 1.18\"></path><path d=\"M4.73 4.73L4 5v7c0 6 8 10 8 10a20.29 20.29 0 0 0 5.62-4.38\"></path><line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line>","shield":"<path d=\"M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z\"></path>","shopping-bag":"<path d=\"M6 2L3 6v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V6l-3-4z\"></path><line x1=\"3\" y1=\"6\" x2=\"21\" y2=\"6\"></line><path d=\"M16 10a4 4 0 0 1-8 0\"></path>","shopping-cart":"<circle cx=\"9\" cy=\"21\" r=\"1\"></circle><circle cx=\"20\" cy=\"21\" r=\"1\"></circle><path d=\"M1 1h4l2.68 13.39a2 2 0 0 0 2 1.61h9.72a2 2 0 0 0 2-1.61L23 6H6\"></path>","shuffle":"<polyline points=\"16 3 21 3 21 8\"></polyline><line x1=\"4\" y1=\"20\" x2=\"21\" y2=\"3\"></line><polyline points=\"21 16 21 21 16 21\"></polyline><line x1=\"15\" y1=\"15\" x2=\"21\" y2=\"21\"></line><line x1=\"4\" y1=\"4\" x2=\"9\" y2=\"9\"></line>","sidebar":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><line x1=\"9\" y1=\"3\" x2=\"9\" y2=\"21\"></line>","skip-back":"<polygon points=\"19 20 9 12 19 4 19 20\"></polygon><line x1=\"5\" y1=\"19\" x2=\"5\" y2=\"5\"></line>","skip-forward":"<polygon points=\"5 4 15 12 5 20 5 4\"></polygon><line x1=\"19\" y1=\"5\" x2=\"19\" y2=\"19\"></line>","slack":"<path d=\"M14.5 10c-.83 0-1.5-.67-1.5-1.5v-5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5z\"></path><path d=\"M20.5 10H19V8.5c0-.83.67-1.5 1.5-1.5s1.5.67 1.5 1.5-.67 1.5-1.5 1.5z\"></path><path d=\"M9.5 14c.83 0 1.5.67 1.5 1.5v5c0 .83-.67 1.5-1.5 1.5S8 21.33 8 20.5v-5c0-.83.67-1.5 1.5-1.5z\"></path><path d=\"M3.5 14H5v1.5c0 .83-.67 1.5-1.5 1.5S2 16.33 2 15.5 2.67 14 3.5 14z\"></path><path d=\"M14 14.5c0-.83.67-1.5 1.5-1.5h5c.83 0 1.5.67 1.5 1.5s-.67 1.5-1.5 1.5h-5c-.83 0-1.5-.67-1.5-1.5z\"></path><path d=\"M15.5 19H14v1.5c0 .83.67 1.5 1.5 1.5s1.5-.67 1.5-1.5-.67-1.5-1.5-1.5z\"></path><path d=\"M10 9.5C10 8.67 9.33 8 8.5 8h-5C2.67 8 2 8.67 2 9.5S2.67 11 3.5 11h5c.83 0 1.5-.67 1.5-1.5z\"></path><path d=\"M8.5 5H10V3.5C10 2.67 9.33 2 8.5 2S7 2.67 7 3.5 7.67 5 8.5 5z\"></path>","slash":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"4.93\" y1=\"4.93\" x2=\"19.07\" y2=\"19.07\"></line>","sliders":"<line x1=\"4\" y1=\"21\" x2=\"4\" y2=\"14\"></line><line x1=\"4\" y1=\"10\" x2=\"4\" y2=\"3\"></line><line x1=\"12\" y1=\"21\" x2=\"12\" y2=\"12\"></line><line x1=\"12\" y1=\"8\" x2=\"12\" y2=\"3\"></line><line x1=\"20\" y1=\"21\" x2=\"20\" y2=\"16\"></line><line x1=\"20\" y1=\"12\" x2=\"20\" y2=\"3\"></line><line x1=\"1\" y1=\"14\" x2=\"7\" y2=\"14\"></line><line x1=\"9\" y1=\"8\" x2=\"15\" y2=\"8\"></line><line x1=\"17\" y1=\"16\" x2=\"23\" y2=\"16\"></line>","smartphone":"<rect x=\"5\" y=\"2\" width=\"14\" height=\"20\" rx=\"2\" ry=\"2\"></rect><line x1=\"12\" y1=\"18\" x2=\"12\" y2=\"18\"></line>","smile":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><path d=\"M8 14s1.5 2 4 2 4-2 4-2\"></path><line x1=\"9\" y1=\"9\" x2=\"9.01\" y2=\"9\"></line><line x1=\"15\" y1=\"9\" x2=\"15.01\" y2=\"9\"></line>","speaker":"<rect x=\"4\" y=\"2\" width=\"16\" height=\"20\" rx=\"2\" ry=\"2\"></rect><circle cx=\"12\" cy=\"14\" r=\"4\"></circle><line x1=\"12\" y1=\"6\" x2=\"12\" y2=\"6\"></line>","square":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect>","star":"<polygon points=\"12 2 15.09 8.26 22 9.27 17 14.14 18.18 21.02 12 17.77 5.82 21.02 7 14.14 2 9.27 8.91 8.26 12 2\"></polygon>","stop-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><rect x=\"9\" y=\"9\" width=\"6\" height=\"6\"></rect>","sun":"<circle cx=\"12\" cy=\"12\" r=\"5\"></circle><line x1=\"12\" y1=\"1\" x2=\"12\" y2=\"3\"></line><line x1=\"12\" y1=\"21\" x2=\"12\" y2=\"23\"></line><line x1=\"4.22\" y1=\"4.22\" x2=\"5.64\" y2=\"5.64\"></line><line x1=\"18.36\" y1=\"18.36\" x2=\"19.78\" y2=\"19.78\"></line><line x1=\"1\" y1=\"12\" x2=\"3\" y2=\"12\"></line><line x1=\"21\" y1=\"12\" x2=\"23\" y2=\"12\"></line><line x1=\"4.22\" y1=\"19.78\" x2=\"5.64\" y2=\"18.36\"></line><line x1=\"18.36\" y1=\"5.64\" x2=\"19.78\" y2=\"4.22\"></line>","sunrise":"<path d=\"M17 18a5 5 0 0 0-10 0\"></path><line x1=\"12\" y1=\"2\" x2=\"12\" y2=\"9\"></line><line x1=\"4.22\" y1=\"10.22\" x2=\"5.64\" y2=\"11.64\"></line><line x1=\"1\" y1=\"18\" x2=\"3\" y2=\"18\"></line><line x1=\"21\" y1=\"18\" x2=\"23\" y2=\"18\"></line><line x1=\"18.36\" y1=\"11.64\" x2=\"19.78\" y2=\"10.22\"></line><line x1=\"23\" y1=\"22\" x2=\"1\" y2=\"22\"></line><polyline points=\"8 6 12 2 16 6\"></polyline>","sunset":"<path d=\"M17 18a5 5 0 0 0-10 0\"></path><line x1=\"12\" y1=\"9\" x2=\"12\" y2=\"2\"></line><line x1=\"4.22\" y1=\"10.22\" x2=\"5.64\" y2=\"11.64\"></line><line x1=\"1\" y1=\"18\" x2=\"3\" y2=\"18\"></line><line x1=\"21\" y1=\"18\" x2=\"23\" y2=\"18\"></line><line x1=\"18.36\" y1=\"11.64\" x2=\"19.78\" y2=\"10.22\"></line><line x1=\"23\" y1=\"22\" x2=\"1\" y2=\"22\"></line><polyline points=\"16 5 12 9 8 5\"></polyline>","tablet":"<rect x=\"4\" y=\"2\" width=\"16\" height=\"20\" rx=\"2\" ry=\"2\" transform=\"rotate(180 12 12)\"></rect><line x1=\"12\" y1=\"18\" x2=\"12\" y2=\"18\"></line>","tag":"<path d=\"M20.59 13.41l-7.17 7.17a2 2 0 0 1-2.83 0L2 12V2h10l8.59 8.59a2 2 0 0 1 0 2.82z\"></path><line x1=\"7\" y1=\"7\" x2=\"7\" y2=\"7\"></line>","target":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><circle cx=\"12\" cy=\"12\" r=\"6\"></circle><circle cx=\"12\" cy=\"12\" r=\"2\"></circle>","terminal":"<polyline points=\"4 17 10 11 4 5\"></polyline><line x1=\"12\" y1=\"19\" x2=\"20\" y2=\"19\"></line>","thermometer":"<path d=\"M14 14.76V3.5a2.5 2.5 0 0 0-5 0v11.26a4.5 4.5 0 1 0 5 0z\"></path>","thumbs-down":"<path d=\"M10 15v4a3 3 0 0 0 3 3l4-9V2H5.72a2 2 0 0 0-2 1.7l-1.38 9a2 2 0 0 0 2 2.3zm7-13h2.67A2.31 2.31 0 0 1 22 4v7a2.31 2.31 0 0 1-2.33 2H17\"></path>","thumbs-up":"<path d=\"M14 9V5a3 3 0 0 0-3-3l-4 9v11h11.28a2 2 0 0 0 2-1.7l1.38-9a2 2 0 0 0-2-2.3zM7 22H4a2 2 0 0 1-2-2v-7a2 2 0 0 1 2-2h3\"></path>","toggle-left":"<rect x=\"1\" y=\"5\" width=\"22\" height=\"14\" rx=\"7\" ry=\"7\"></rect><circle cx=\"8\" cy=\"12\" r=\"3\"></circle>","toggle-right":"<rect x=\"1\" y=\"5\" width=\"22\" height=\"14\" rx=\"7\" ry=\"7\"></rect><circle cx=\"16\" cy=\"12\" r=\"3\"></circle>","trash-2":"<polyline points=\"3 6 5 6 21 6\"></polyline><path d=\"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2\"></path><line x1=\"10\" y1=\"11\" x2=\"10\" y2=\"17\"></line><line x1=\"14\" y1=\"11\" x2=\"14\" y2=\"17\"></line>","trash":"<polyline points=\"3 6 5 6 21 6\"></polyline><path d=\"M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6m3 0V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2\"></path>","trello":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><rect x=\"7\" y=\"7\" width=\"3\" height=\"9\"></rect><rect x=\"14\" y=\"7\" width=\"3\" height=\"5\"></rect>","trending-down":"<polyline points=\"23 18 13.5 8.5 8.5 13.5 1 6\"></polyline><polyline points=\"17 18 23 18 23 12\"></polyline>","trending-up":"<polyline points=\"23 6 13.5 15.5 8.5 10.5 1 18\"></polyline><polyline points=\"17 6 23 6 23 12\"></polyline>","triangle":"<path d=\"M10.29 3.86L1.82 18a2 2 0 0 0 1.71 3h16.94a2 2 0 0 0 1.71-3L13.71 3.86a2 2 0 0 0-3.42 0z\"></path>","truck":"<rect x=\"1\" y=\"3\" width=\"15\" height=\"13\"></rect><polygon points=\"16 8 20 8 23 11 23 16 16 16 16 8\"></polygon><circle cx=\"5.5\" cy=\"18.5\" r=\"2.5\"></circle><circle cx=\"18.5\" cy=\"18.5\" r=\"2.5\"></circle>","tv":"<rect x=\"2\" y=\"7\" width=\"20\" height=\"15\" rx=\"2\" ry=\"2\"></rect><polyline points=\"17 2 12 7 7 2\"></polyline>","twitter":"<path d=\"M23 3a10.9 10.9 0 0 1-3.14 1.53 4.48 4.48 0 0 0-7.86 3v1A10.66 10.66 0 0 1 3 4s-4 9 5 13a11.64 11.64 0 0 1-7 2c9 5 20 0 20-11.5a4.5 4.5 0 0 0-.08-.83A7.72 7.72 0 0 0 23 3z\"></path>","type":"<polyline points=\"4 7 4 4 20 4 20 7\"></polyline><line x1=\"9\" y1=\"20\" x2=\"15\" y2=\"20\"></line><line x1=\"12\" y1=\"4\" x2=\"12\" y2=\"20\"></line>","umbrella":"<path d=\"M23 12a11.05 11.05 0 0 0-22 0zm-5 7a3 3 0 0 1-6 0v-7\"></path>","underline":"<path d=\"M6 3v7a6 6 0 0 0 6 6 6 6 0 0 0 6-6V3\"></path><line x1=\"4\" y1=\"21\" x2=\"20\" y2=\"21\"></line>","unlock":"<rect x=\"3\" y=\"11\" width=\"18\" height=\"11\" rx=\"2\" ry=\"2\"></rect><path d=\"M7 11V7a5 5 0 0 1 9.9-1\"></path>","upload-cloud":"<polyline points=\"16 16 12 12 8 16\"></polyline><line x1=\"12\" y1=\"12\" x2=\"12\" y2=\"21\"></line><path d=\"M20.39 18.39A5 5 0 0 0 18 9h-1.26A8 8 0 1 0 3 16.3\"></path><polyline points=\"16 16 12 12 8 16\"></polyline>","upload":"<path d=\"M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4\"></path><polyline points=\"17 8 12 3 7 8\"></polyline><line x1=\"12\" y1=\"3\" x2=\"12\" y2=\"15\"></line>","user-check":"<path d=\"M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2\"></path><circle cx=\"8.5\" cy=\"7\" r=\"4\"></circle><polyline points=\"17 11 19 13 23 9\"></polyline>","user-minus":"<path d=\"M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2\"></path><circle cx=\"8.5\" cy=\"7\" r=\"4\"></circle><line x1=\"23\" y1=\"11\" x2=\"17\" y2=\"11\"></line>","user-plus":"<path d=\"M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2\"></path><circle cx=\"8.5\" cy=\"7\" r=\"4\"></circle><line x1=\"20\" y1=\"8\" x2=\"20\" y2=\"14\"></line><line x1=\"23\" y1=\"11\" x2=\"17\" y2=\"11\"></line>","user-x":"<path d=\"M16 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2\"></path><circle cx=\"8.5\" cy=\"7\" r=\"4\"></circle><line x1=\"18\" y1=\"8\" x2=\"23\" y2=\"13\"></line><line x1=\"23\" y1=\"8\" x2=\"18\" y2=\"13\"></line>","user":"<path d=\"M20 21v-2a4 4 0 0 0-4-4H8a4 4 0 0 0-4 4v2\"></path><circle cx=\"12\" cy=\"7\" r=\"4\"></circle>","users":"<path d=\"M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2\"></path><circle cx=\"9\" cy=\"7\" r=\"4\"></circle><path d=\"M23 21v-2a4 4 0 0 0-3-3.87\"></path><path d=\"M16 3.13a4 4 0 0 1 0 7.75\"></path>","video-off":"<path d=\"M16 16v1a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V7a2 2 0 0 1 2-2h2m5.66 0H14a2 2 0 0 1 2 2v3.34l1 1L23 7v10\"></path><line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line>","video":"<polygon points=\"23 7 16 12 23 17 23 7\"></polygon><rect x=\"1\" y=\"5\" width=\"15\" height=\"14\" rx=\"2\" ry=\"2\"></rect>","voicemail":"<circle cx=\"5.5\" cy=\"11.5\" r=\"4.5\"></circle><circle cx=\"18.5\" cy=\"11.5\" r=\"4.5\"></circle><line x1=\"5.5\" y1=\"16\" x2=\"18.5\" y2=\"16\"></line>","volume-1":"<polygon points=\"11 5 6 9 2 9 2 15 6 15 11 19 11 5\"></polygon><path d=\"M15.54 8.46a5 5 0 0 1 0 7.07\"></path>","volume-2":"<polygon points=\"11 5 6 9 2 9 2 15 6 15 11 19 11 5\"></polygon><path d=\"M19.07 4.93a10 10 0 0 1 0 14.14M15.54 8.46a5 5 0 0 1 0 7.07\"></path>","volume-x":"<polygon points=\"11 5 6 9 2 9 2 15 6 15 11 19 11 5\"></polygon><line x1=\"23\" y1=\"9\" x2=\"17\" y2=\"15\"></line><line x1=\"17\" y1=\"9\" x2=\"23\" y2=\"15\"></line>","volume":"<polygon points=\"11 5 6 9 2 9 2 15 6 15 11 19 11 5\"></polygon>","watch":"<circle cx=\"12\" cy=\"12\" r=\"7\"></circle><polyline points=\"12 9 12 12 13.5 13.5\"></polyline><path d=\"M16.51 17.35l-.35 3.83a2 2 0 0 1-2 1.82H9.83a2 2 0 0 1-2-1.82l-.35-3.83m.01-10.7l.35-3.83A2 2 0 0 1 9.83 1h4.35a2 2 0 0 1 2 1.82l.35 3.83\"></path>","wifi-off":"<line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line><path d=\"M16.72 11.06A10.94 10.94 0 0 1 19 12.55\"></path><path d=\"M5 12.55a10.94 10.94 0 0 1 5.17-2.39\"></path><path d=\"M10.71 5.05A16 16 0 0 1 22.58 9\"></path><path d=\"M1.42 9a15.91 15.91 0 0 1 4.7-2.88\"></path><path d=\"M8.53 16.11a6 6 0 0 1 6.95 0\"></path><line x1=\"12\" y1=\"20\" x2=\"12\" y2=\"20\"></line>","wifi":"<path d=\"M5 12.55a11 11 0 0 1 14.08 0\"></path><path d=\"M1.42 9a16 16 0 0 1 21.16 0\"></path><path d=\"M8.53 16.11a6 6 0 0 1 6.95 0\"></path><line x1=\"12\" y1=\"20\" x2=\"12\" y2=\"20\"></line>","wind":"<path d=\"M9.59 4.59A2 2 0 1 1 11 8H2m10.59 11.41A2 2 0 1 0 14 16H2m15.73-8.27A2.5 2.5 0 1 1 19.5 12H2\"></path>","x-circle":"<circle cx=\"12\" cy=\"12\" r=\"10\"></circle><line x1=\"15\" y1=\"9\" x2=\"9\" y2=\"15\"></line><line x1=\"9\" y1=\"9\" x2=\"15\" y2=\"15\"></line>","x-octagon":"<polygon points=\"7.86 2 16.14 2 22 7.86 22 16.14 16.14 22 7.86 22 2 16.14 2 7.86 7.86 2\"></polygon><line x1=\"15\" y1=\"9\" x2=\"9\" y2=\"15\"></line><line x1=\"9\" y1=\"9\" x2=\"15\" y2=\"15\"></line>","x-square":"<rect x=\"3\" y=\"3\" width=\"18\" height=\"18\" rx=\"2\" ry=\"2\"></rect><line x1=\"9\" y1=\"9\" x2=\"15\" y2=\"15\"></line><line x1=\"15\" y1=\"9\" x2=\"9\" y2=\"15\"></line>","x":"<line x1=\"18\" y1=\"6\" x2=\"6\" y2=\"18\"></line><line x1=\"6\" y1=\"6\" x2=\"18\" y2=\"18\"></line>","youtube":"<path d=\"M22.54 6.42a2.78 2.78 0 0 0-1.94-2C18.88 4 12 4 12 4s-6.88 0-8.6.46a2.78 2.78 0 0 0-1.94 2A29 29 0 0 0 1 11.75a29 29 0 0 0 .46 5.33A2.78 2.78 0 0 0 3.4 19c1.72.46 8.6.46 8.6.46s6.88 0 8.6-.46a2.78 2.78 0 0 0 1.94-2 29 29 0 0 0 .46-5.25 29 29 0 0 0-.46-5.33z\"></path><polygon points=\"9.75 15.02 15.5 11.75 9.75 8.48 9.75 15.02\"></polygon>","zap-off":"<polyline points=\"12.41 6.75 13 2 10.57 4.92\"></polyline><polyline points=\"18.57 12.91 21 10 15.66 10\"></polyline><polyline points=\"8 8 3 14 12 14 11 22 16 16\"></polyline><line x1=\"1\" y1=\"1\" x2=\"23\" y2=\"23\"></line>","zap":"<polygon points=\"13 2 3 14 12 14 11 22 21 10 12 10 13 2\"></polygon>","zoom-in":"<circle cx=\"11\" cy=\"11\" r=\"8\"></circle><line x1=\"21\" y1=\"21\" x2=\"16.65\" y2=\"16.65\"></line><line x1=\"11\" y1=\"8\" x2=\"11\" y2=\"14\"></line><line x1=\"8\" y1=\"11\" x2=\"14\" y2=\"11\"></line>","zoom-out":"<circle cx=\"11\" cy=\"11\" r=\"8\"></circle><line x1=\"21\" y1=\"21\" x2=\"16.65\" y2=\"16.65\"></line><line x1=\"8\" y1=\"11\" x2=\"14\" y2=\"11\"></line>"};
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/classnames/dedupe.js":
|
|
/*!*******************************************!*\
|
|
!*** ./node_modules/classnames/dedupe.js ***!
|
|
\*******************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var __WEBPACK_AMD_DEFINE_ARRAY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!
|
|
Copyright (c) 2016 Jed Watson.
|
|
Licensed under the MIT License (MIT), see
|
|
http://jedwatson.github.io/classnames
|
|
*/
|
|
/* global define */
|
|
|
|
(function () {
|
|
|
|
var classNames = (function () {
|
|
// don't inherit from Object so we can skip hasOwnProperty check later
|
|
// http://stackoverflow.com/questions/15518328/creating-js-object-with-object-createnull#answer-21079232
|
|
function StorageObject() {}
|
|
StorageObject.prototype = Object.create(null);
|
|
|
|
function _parseArray (resultSet, array) {
|
|
var length = array.length;
|
|
|
|
for (var i = 0; i < length; ++i) {
|
|
_parse(resultSet, array[i]);
|
|
}
|
|
}
|
|
|
|
var hasOwn = {}.hasOwnProperty;
|
|
|
|
function _parseNumber (resultSet, num) {
|
|
resultSet[num] = true;
|
|
}
|
|
|
|
function _parseObject (resultSet, object) {
|
|
for (var k in object) {
|
|
if (hasOwn.call(object, k)) {
|
|
// set value to false instead of deleting it to avoid changing object structure
|
|
// https://www.smashingmagazine.com/2012/11/writing-fast-memory-efficient-javascript/#de-referencing-misconceptions
|
|
resultSet[k] = !!object[k];
|
|
}
|
|
}
|
|
}
|
|
|
|
var SPACE = /\s+/;
|
|
function _parseString (resultSet, str) {
|
|
var array = str.split(SPACE);
|
|
var length = array.length;
|
|
|
|
for (var i = 0; i < length; ++i) {
|
|
resultSet[array[i]] = true;
|
|
}
|
|
}
|
|
|
|
function _parse (resultSet, arg) {
|
|
if (!arg) return;
|
|
var argType = typeof arg;
|
|
|
|
// 'foo bar'
|
|
if (argType === 'string') {
|
|
_parseString(resultSet, arg);
|
|
|
|
// ['foo', 'bar', ...]
|
|
} else if (Array.isArray(arg)) {
|
|
_parseArray(resultSet, arg);
|
|
|
|
// { 'foo': true, ... }
|
|
} else if (argType === 'object') {
|
|
_parseObject(resultSet, arg);
|
|
|
|
// '130'
|
|
} else if (argType === 'number') {
|
|
_parseNumber(resultSet, arg);
|
|
}
|
|
}
|
|
|
|
function _classNames () {
|
|
// don't leak arguments
|
|
// https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#32-leaking-arguments
|
|
var len = arguments.length;
|
|
var args = Array(len);
|
|
for (var i = 0; i < len; i++) {
|
|
args[i] = arguments[i];
|
|
}
|
|
|
|
var classSet = new StorageObject();
|
|
_parseArray(classSet, args);
|
|
|
|
var list = [];
|
|
|
|
for (var k in classSet) {
|
|
if (classSet[k]) {
|
|
list.push(k);
|
|
}
|
|
}
|
|
|
|
return list.join(' ');
|
|
}
|
|
|
|
return _classNames;
|
|
})();
|
|
|
|
if (typeof module !== 'undefined' && module.exports) {
|
|
module.exports = classNames;
|
|
} else {
|
|
// register as 'classnames', consistent with npm package name
|
|
!(__WEBPACK_AMD_DEFINE_ARRAY__ = [], __WEBPACK_AMD_DEFINE_RESULT__ = (function () {
|
|
return classNames;
|
|
}).apply(exports, __WEBPACK_AMD_DEFINE_ARRAY__),
|
|
__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));
|
|
}
|
|
}());
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/es/array/from.js":
|
|
/*!***********************************************!*\
|
|
!*** ./node_modules/core-js/es/array/from.js ***!
|
|
\***********************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
__webpack_require__(/*! ../../modules/es.string.iterator */ "./node_modules/core-js/modules/es.string.iterator.js");
|
|
__webpack_require__(/*! ../../modules/es.array.from */ "./node_modules/core-js/modules/es.array.from.js");
|
|
var path = __webpack_require__(/*! ../../internals/path */ "./node_modules/core-js/internals/path.js");
|
|
|
|
module.exports = path.Array.from;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/a-function.js":
|
|
/*!******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/a-function.js ***!
|
|
\******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = function (it) {
|
|
if (typeof it != 'function') {
|
|
throw TypeError(String(it) + ' is not a function');
|
|
} return it;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/an-object.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/an-object.js ***!
|
|
\*****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isObject = __webpack_require__(/*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js");
|
|
|
|
module.exports = function (it) {
|
|
if (!isObject(it)) {
|
|
throw TypeError(String(it) + ' is not an object');
|
|
} return it;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/array-from.js":
|
|
/*!******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/array-from.js ***!
|
|
\******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var bind = __webpack_require__(/*! ../internals/bind-context */ "./node_modules/core-js/internals/bind-context.js");
|
|
var toObject = __webpack_require__(/*! ../internals/to-object */ "./node_modules/core-js/internals/to-object.js");
|
|
var callWithSafeIterationClosing = __webpack_require__(/*! ../internals/call-with-safe-iteration-closing */ "./node_modules/core-js/internals/call-with-safe-iteration-closing.js");
|
|
var isArrayIteratorMethod = __webpack_require__(/*! ../internals/is-array-iterator-method */ "./node_modules/core-js/internals/is-array-iterator-method.js");
|
|
var toLength = __webpack_require__(/*! ../internals/to-length */ "./node_modules/core-js/internals/to-length.js");
|
|
var createProperty = __webpack_require__(/*! ../internals/create-property */ "./node_modules/core-js/internals/create-property.js");
|
|
var getIteratorMethod = __webpack_require__(/*! ../internals/get-iterator-method */ "./node_modules/core-js/internals/get-iterator-method.js");
|
|
|
|
// `Array.from` method
|
|
// https://tc39.github.io/ecma262/#sec-array.from
|
|
module.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {
|
|
var O = toObject(arrayLike);
|
|
var C = typeof this == 'function' ? this : Array;
|
|
var argumentsLength = arguments.length;
|
|
var mapfn = argumentsLength > 1 ? arguments[1] : undefined;
|
|
var mapping = mapfn !== undefined;
|
|
var index = 0;
|
|
var iteratorMethod = getIteratorMethod(O);
|
|
var length, result, step, iterator;
|
|
if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);
|
|
// if the target is not iterable or it's an array with the default iterator - use a simple case
|
|
if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {
|
|
iterator = iteratorMethod.call(O);
|
|
result = new C();
|
|
for (;!(step = iterator.next()).done; index++) {
|
|
createProperty(result, index, mapping
|
|
? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true)
|
|
: step.value
|
|
);
|
|
}
|
|
} else {
|
|
length = toLength(O.length);
|
|
result = new C(length);
|
|
for (;length > index; index++) {
|
|
createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
|
|
}
|
|
}
|
|
result.length = index;
|
|
return result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/array-includes.js":
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/array-includes.js ***!
|
|
\**********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "./node_modules/core-js/internals/to-indexed-object.js");
|
|
var toLength = __webpack_require__(/*! ../internals/to-length */ "./node_modules/core-js/internals/to-length.js");
|
|
var toAbsoluteIndex = __webpack_require__(/*! ../internals/to-absolute-index */ "./node_modules/core-js/internals/to-absolute-index.js");
|
|
|
|
// `Array.prototype.{ indexOf, includes }` methods implementation
|
|
// false -> Array#indexOf
|
|
// https://tc39.github.io/ecma262/#sec-array.prototype.indexof
|
|
// true -> Array#includes
|
|
// https://tc39.github.io/ecma262/#sec-array.prototype.includes
|
|
module.exports = function (IS_INCLUDES) {
|
|
return function ($this, el, fromIndex) {
|
|
var O = toIndexedObject($this);
|
|
var length = toLength(O.length);
|
|
var index = toAbsoluteIndex(fromIndex, length);
|
|
var value;
|
|
// Array#includes uses SameValueZero equality algorithm
|
|
// eslint-disable-next-line no-self-compare
|
|
if (IS_INCLUDES && el != el) while (length > index) {
|
|
value = O[index++];
|
|
// eslint-disable-next-line no-self-compare
|
|
if (value != value) return true;
|
|
// Array#indexOf ignores holes, Array#includes - not
|
|
} else for (;length > index; index++) if (IS_INCLUDES || index in O) {
|
|
if (O[index] === el) return IS_INCLUDES || index || 0;
|
|
} return !IS_INCLUDES && -1;
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/bind-context.js":
|
|
/*!********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/bind-context.js ***!
|
|
\********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var aFunction = __webpack_require__(/*! ../internals/a-function */ "./node_modules/core-js/internals/a-function.js");
|
|
|
|
// optional / simple context binding
|
|
module.exports = function (fn, that, length) {
|
|
aFunction(fn);
|
|
if (that === undefined) return fn;
|
|
switch (length) {
|
|
case 0: return function () {
|
|
return fn.call(that);
|
|
};
|
|
case 1: return function (a) {
|
|
return fn.call(that, a);
|
|
};
|
|
case 2: return function (a, b) {
|
|
return fn.call(that, a, b);
|
|
};
|
|
case 3: return function (a, b, c) {
|
|
return fn.call(that, a, b, c);
|
|
};
|
|
}
|
|
return function (/* ...args */) {
|
|
return fn.apply(that, arguments);
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/call-with-safe-iteration-closing.js":
|
|
/*!****************************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/call-with-safe-iteration-closing.js ***!
|
|
\****************************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var anObject = __webpack_require__(/*! ../internals/an-object */ "./node_modules/core-js/internals/an-object.js");
|
|
|
|
// call something on iterator step with safe closing on error
|
|
module.exports = function (iterator, fn, value, ENTRIES) {
|
|
try {
|
|
return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
|
|
// 7.4.6 IteratorClose(iterator, completion)
|
|
} catch (error) {
|
|
var returnMethod = iterator['return'];
|
|
if (returnMethod !== undefined) anObject(returnMethod.call(iterator));
|
|
throw error;
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/check-correctness-of-iteration.js":
|
|
/*!**************************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/check-correctness-of-iteration.js ***!
|
|
\**************************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "./node_modules/core-js/internals/well-known-symbol.js");
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var SAFE_CLOSING = false;
|
|
|
|
try {
|
|
var called = 0;
|
|
var iteratorWithReturn = {
|
|
next: function () {
|
|
return { done: !!called++ };
|
|
},
|
|
'return': function () {
|
|
SAFE_CLOSING = true;
|
|
}
|
|
};
|
|
iteratorWithReturn[ITERATOR] = function () {
|
|
return this;
|
|
};
|
|
// eslint-disable-next-line no-throw-literal
|
|
Array.from(iteratorWithReturn, function () { throw 2; });
|
|
} catch (error) { /* empty */ }
|
|
|
|
module.exports = function (exec, SKIP_CLOSING) {
|
|
if (!SKIP_CLOSING && !SAFE_CLOSING) return false;
|
|
var ITERATION_SUPPORT = false;
|
|
try {
|
|
var object = {};
|
|
object[ITERATOR] = function () {
|
|
return {
|
|
next: function () {
|
|
return { done: ITERATION_SUPPORT = true };
|
|
}
|
|
};
|
|
};
|
|
exec(object);
|
|
} catch (error) { /* empty */ }
|
|
return ITERATION_SUPPORT;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/classof-raw.js":
|
|
/*!*******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/classof-raw.js ***!
|
|
\*******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
var toString = {}.toString;
|
|
|
|
module.exports = function (it) {
|
|
return toString.call(it).slice(8, -1);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/classof.js":
|
|
/*!***************************************************!*\
|
|
!*** ./node_modules/core-js/internals/classof.js ***!
|
|
\***************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var classofRaw = __webpack_require__(/*! ../internals/classof-raw */ "./node_modules/core-js/internals/classof-raw.js");
|
|
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "./node_modules/core-js/internals/well-known-symbol.js");
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
// ES3 wrong here
|
|
var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';
|
|
|
|
// fallback for IE11 Script Access Denied error
|
|
var tryGet = function (it, key) {
|
|
try {
|
|
return it[key];
|
|
} catch (error) { /* empty */ }
|
|
};
|
|
|
|
// getting tag from ES6+ `Object.prototype.toString`
|
|
module.exports = function (it) {
|
|
var O, tag, result;
|
|
return it === undefined ? 'Undefined' : it === null ? 'Null'
|
|
// @@toStringTag case
|
|
: typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag
|
|
// builtinTag case
|
|
: CORRECT_ARGUMENTS ? classofRaw(O)
|
|
// ES3 arguments fallback
|
|
: (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/copy-constructor-properties.js":
|
|
/*!***********************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/copy-constructor-properties.js ***!
|
|
\***********************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var has = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var ownKeys = __webpack_require__(/*! ../internals/own-keys */ "./node_modules/core-js/internals/own-keys.js");
|
|
var getOwnPropertyDescriptorModule = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "./node_modules/core-js/internals/object-get-own-property-descriptor.js");
|
|
var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "./node_modules/core-js/internals/object-define-property.js");
|
|
|
|
module.exports = function (target, source) {
|
|
var keys = ownKeys(source);
|
|
var defineProperty = definePropertyModule.f;
|
|
var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
|
|
for (var i = 0; i < keys.length; i++) {
|
|
var key = keys[i];
|
|
if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/correct-prototype-getter.js":
|
|
/*!********************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/correct-prototype-getter.js ***!
|
|
\********************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var fails = __webpack_require__(/*! ../internals/fails */ "./node_modules/core-js/internals/fails.js");
|
|
|
|
module.exports = !fails(function () {
|
|
function F() { /* empty */ }
|
|
F.prototype.constructor = null;
|
|
return Object.getPrototypeOf(new F()) !== F.prototype;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/create-iterator-constructor.js":
|
|
/*!***********************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/create-iterator-constructor.js ***!
|
|
\***********************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var IteratorPrototype = __webpack_require__(/*! ../internals/iterators-core */ "./node_modules/core-js/internals/iterators-core.js").IteratorPrototype;
|
|
var create = __webpack_require__(/*! ../internals/object-create */ "./node_modules/core-js/internals/object-create.js");
|
|
var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "./node_modules/core-js/internals/create-property-descriptor.js");
|
|
var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ "./node_modules/core-js/internals/set-to-string-tag.js");
|
|
var Iterators = __webpack_require__(/*! ../internals/iterators */ "./node_modules/core-js/internals/iterators.js");
|
|
|
|
var returnThis = function () { return this; };
|
|
|
|
module.exports = function (IteratorConstructor, NAME, next) {
|
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });
|
|
setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
|
|
Iterators[TO_STRING_TAG] = returnThis;
|
|
return IteratorConstructor;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/create-property-descriptor.js":
|
|
/*!**********************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/create-property-descriptor.js ***!
|
|
\**********************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = function (bitmap, value) {
|
|
return {
|
|
enumerable: !(bitmap & 1),
|
|
configurable: !(bitmap & 2),
|
|
writable: !(bitmap & 4),
|
|
value: value
|
|
};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/create-property.js":
|
|
/*!***********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/create-property.js ***!
|
|
\***********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var toPrimitive = __webpack_require__(/*! ../internals/to-primitive */ "./node_modules/core-js/internals/to-primitive.js");
|
|
var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "./node_modules/core-js/internals/object-define-property.js");
|
|
var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "./node_modules/core-js/internals/create-property-descriptor.js");
|
|
|
|
module.exports = function (object, key, value) {
|
|
var propertyKey = toPrimitive(key);
|
|
if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
|
|
else object[propertyKey] = value;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/define-iterator.js":
|
|
/*!***********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/define-iterator.js ***!
|
|
\***********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var $ = __webpack_require__(/*! ../internals/export */ "./node_modules/core-js/internals/export.js");
|
|
var createIteratorConstructor = __webpack_require__(/*! ../internals/create-iterator-constructor */ "./node_modules/core-js/internals/create-iterator-constructor.js");
|
|
var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ "./node_modules/core-js/internals/object-get-prototype-of.js");
|
|
var setPrototypeOf = __webpack_require__(/*! ../internals/object-set-prototype-of */ "./node_modules/core-js/internals/object-set-prototype-of.js");
|
|
var setToStringTag = __webpack_require__(/*! ../internals/set-to-string-tag */ "./node_modules/core-js/internals/set-to-string-tag.js");
|
|
var hide = __webpack_require__(/*! ../internals/hide */ "./node_modules/core-js/internals/hide.js");
|
|
var redefine = __webpack_require__(/*! ../internals/redefine */ "./node_modules/core-js/internals/redefine.js");
|
|
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "./node_modules/core-js/internals/well-known-symbol.js");
|
|
var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "./node_modules/core-js/internals/is-pure.js");
|
|
var Iterators = __webpack_require__(/*! ../internals/iterators */ "./node_modules/core-js/internals/iterators.js");
|
|
var IteratorsCore = __webpack_require__(/*! ../internals/iterators-core */ "./node_modules/core-js/internals/iterators-core.js");
|
|
|
|
var IteratorPrototype = IteratorsCore.IteratorPrototype;
|
|
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var KEYS = 'keys';
|
|
var VALUES = 'values';
|
|
var ENTRIES = 'entries';
|
|
|
|
var returnThis = function () { return this; };
|
|
|
|
module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
|
|
createIteratorConstructor(IteratorConstructor, NAME, next);
|
|
|
|
var getIterationMethod = function (KIND) {
|
|
if (KIND === DEFAULT && defaultIterator) return defaultIterator;
|
|
if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];
|
|
switch (KIND) {
|
|
case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };
|
|
case VALUES: return function values() { return new IteratorConstructor(this, KIND); };
|
|
case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };
|
|
} return function () { return new IteratorConstructor(this); };
|
|
};
|
|
|
|
var TO_STRING_TAG = NAME + ' Iterator';
|
|
var INCORRECT_VALUES_NAME = false;
|
|
var IterablePrototype = Iterable.prototype;
|
|
var nativeIterator = IterablePrototype[ITERATOR]
|
|
|| IterablePrototype['@@iterator']
|
|
|| DEFAULT && IterablePrototype[DEFAULT];
|
|
var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
|
|
var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
|
|
var CurrentIteratorPrototype, methods, KEY;
|
|
|
|
// fix native
|
|
if (anyNativeIterator) {
|
|
CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
|
|
if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
|
|
if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
|
|
if (setPrototypeOf) {
|
|
setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
|
|
} else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {
|
|
hide(CurrentIteratorPrototype, ITERATOR, returnThis);
|
|
}
|
|
}
|
|
// Set @@toStringTag to native iterators
|
|
setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
|
|
if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;
|
|
}
|
|
}
|
|
|
|
// fix Array#{values, @@iterator}.name in V8 / FF
|
|
if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
|
|
INCORRECT_VALUES_NAME = true;
|
|
defaultIterator = function values() { return nativeIterator.call(this); };
|
|
}
|
|
|
|
// define iterator
|
|
if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
|
|
hide(IterablePrototype, ITERATOR, defaultIterator);
|
|
}
|
|
Iterators[NAME] = defaultIterator;
|
|
|
|
// export additional methods
|
|
if (DEFAULT) {
|
|
methods = {
|
|
values: getIterationMethod(VALUES),
|
|
keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
|
|
entries: getIterationMethod(ENTRIES)
|
|
};
|
|
if (FORCED) for (KEY in methods) {
|
|
if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
|
|
redefine(IterablePrototype, KEY, methods[KEY]);
|
|
}
|
|
} else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);
|
|
}
|
|
|
|
return methods;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/descriptors.js":
|
|
/*!*******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/descriptors.js ***!
|
|
\*******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var fails = __webpack_require__(/*! ../internals/fails */ "./node_modules/core-js/internals/fails.js");
|
|
|
|
// Thank's IE8 for his funny defineProperty
|
|
module.exports = !fails(function () {
|
|
return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/document-create-element.js":
|
|
/*!*******************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/document-create-element.js ***!
|
|
\*******************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var isObject = __webpack_require__(/*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js");
|
|
|
|
var document = global.document;
|
|
// typeof document.createElement is 'object' in old IE
|
|
var exist = isObject(document) && isObject(document.createElement);
|
|
|
|
module.exports = function (it) {
|
|
return exist ? document.createElement(it) : {};
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/enum-bug-keys.js":
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/enum-bug-keys.js ***!
|
|
\*********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
// IE8- don't enum bug keys
|
|
module.exports = [
|
|
'constructor',
|
|
'hasOwnProperty',
|
|
'isPrototypeOf',
|
|
'propertyIsEnumerable',
|
|
'toLocaleString',
|
|
'toString',
|
|
'valueOf'
|
|
];
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/export.js":
|
|
/*!**************************************************!*\
|
|
!*** ./node_modules/core-js/internals/export.js ***!
|
|
\**************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var getOwnPropertyDescriptor = __webpack_require__(/*! ../internals/object-get-own-property-descriptor */ "./node_modules/core-js/internals/object-get-own-property-descriptor.js").f;
|
|
var hide = __webpack_require__(/*! ../internals/hide */ "./node_modules/core-js/internals/hide.js");
|
|
var redefine = __webpack_require__(/*! ../internals/redefine */ "./node_modules/core-js/internals/redefine.js");
|
|
var setGlobal = __webpack_require__(/*! ../internals/set-global */ "./node_modules/core-js/internals/set-global.js");
|
|
var copyConstructorProperties = __webpack_require__(/*! ../internals/copy-constructor-properties */ "./node_modules/core-js/internals/copy-constructor-properties.js");
|
|
var isForced = __webpack_require__(/*! ../internals/is-forced */ "./node_modules/core-js/internals/is-forced.js");
|
|
|
|
/*
|
|
options.target - name of the target object
|
|
options.global - target is the global object
|
|
options.stat - export as static methods of target
|
|
options.proto - export as prototype methods of target
|
|
options.real - real prototype method for the `pure` version
|
|
options.forced - export even if the native feature is available
|
|
options.bind - bind methods to the target, required for the `pure` version
|
|
options.wrap - wrap constructors to preventing global pollution, required for the `pure` version
|
|
options.unsafe - use the simple assignment of property instead of delete + defineProperty
|
|
options.sham - add a flag to not completely full polyfills
|
|
options.enumerable - export as enumerable property
|
|
options.noTargetGet - prevent calling a getter on target
|
|
*/
|
|
module.exports = function (options, source) {
|
|
var TARGET = options.target;
|
|
var GLOBAL = options.global;
|
|
var STATIC = options.stat;
|
|
var FORCED, target, key, targetProperty, sourceProperty, descriptor;
|
|
if (GLOBAL) {
|
|
target = global;
|
|
} else if (STATIC) {
|
|
target = global[TARGET] || setGlobal(TARGET, {});
|
|
} else {
|
|
target = (global[TARGET] || {}).prototype;
|
|
}
|
|
if (target) for (key in source) {
|
|
sourceProperty = source[key];
|
|
if (options.noTargetGet) {
|
|
descriptor = getOwnPropertyDescriptor(target, key);
|
|
targetProperty = descriptor && descriptor.value;
|
|
} else targetProperty = target[key];
|
|
FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
|
|
// contained in target
|
|
if (!FORCED && targetProperty !== undefined) {
|
|
if (typeof sourceProperty === typeof targetProperty) continue;
|
|
copyConstructorProperties(sourceProperty, targetProperty);
|
|
}
|
|
// add a flag to not completely full polyfills
|
|
if (options.sham || (targetProperty && targetProperty.sham)) {
|
|
hide(sourceProperty, 'sham', true);
|
|
}
|
|
// extend global
|
|
redefine(target, key, sourceProperty, options);
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/fails.js":
|
|
/*!*************************************************!*\
|
|
!*** ./node_modules/core-js/internals/fails.js ***!
|
|
\*************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = function (exec) {
|
|
try {
|
|
return !!exec();
|
|
} catch (error) {
|
|
return true;
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/function-to-string.js":
|
|
/*!**************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/function-to-string.js ***!
|
|
\**************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var shared = __webpack_require__(/*! ../internals/shared */ "./node_modules/core-js/internals/shared.js");
|
|
|
|
module.exports = shared('native-function-to-string', Function.toString);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/get-iterator-method.js":
|
|
/*!***************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/get-iterator-method.js ***!
|
|
\***************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var classof = __webpack_require__(/*! ../internals/classof */ "./node_modules/core-js/internals/classof.js");
|
|
var Iterators = __webpack_require__(/*! ../internals/iterators */ "./node_modules/core-js/internals/iterators.js");
|
|
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "./node_modules/core-js/internals/well-known-symbol.js");
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
|
|
module.exports = function (it) {
|
|
if (it != undefined) return it[ITERATOR]
|
|
|| it['@@iterator']
|
|
|| Iterators[classof(it)];
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/global.js":
|
|
/*!**************************************************!*\
|
|
!*** ./node_modules/core-js/internals/global.js ***!
|
|
\**************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
/* WEBPACK VAR INJECTION */(function(global) {var O = 'object';
|
|
var check = function (it) {
|
|
return it && it.Math == Math && it;
|
|
};
|
|
|
|
// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
|
|
module.exports =
|
|
// eslint-disable-next-line no-undef
|
|
check(typeof globalThis == O && globalThis) ||
|
|
check(typeof window == O && window) ||
|
|
check(typeof self == O && self) ||
|
|
check(typeof global == O && global) ||
|
|
// eslint-disable-next-line no-new-func
|
|
Function('return this')();
|
|
|
|
/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../webpack/buildin/global.js */ "./node_modules/webpack/buildin/global.js")));
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/has.js":
|
|
/*!***********************************************!*\
|
|
!*** ./node_modules/core-js/internals/has.js ***!
|
|
\***********************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
var hasOwnProperty = {}.hasOwnProperty;
|
|
|
|
module.exports = function (it, key) {
|
|
return hasOwnProperty.call(it, key);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/hidden-keys.js":
|
|
/*!*******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/hidden-keys.js ***!
|
|
\*******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = {};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/hide.js":
|
|
/*!************************************************!*\
|
|
!*** ./node_modules/core-js/internals/hide.js ***!
|
|
\************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "./node_modules/core-js/internals/descriptors.js");
|
|
var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "./node_modules/core-js/internals/object-define-property.js");
|
|
var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "./node_modules/core-js/internals/create-property-descriptor.js");
|
|
|
|
module.exports = DESCRIPTORS ? function (object, key, value) {
|
|
return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
|
|
} : function (object, key, value) {
|
|
object[key] = value;
|
|
return object;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/html.js":
|
|
/*!************************************************!*\
|
|
!*** ./node_modules/core-js/internals/html.js ***!
|
|
\************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
|
|
var document = global.document;
|
|
|
|
module.exports = document && document.documentElement;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/ie8-dom-define.js":
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/ie8-dom-define.js ***!
|
|
\**********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "./node_modules/core-js/internals/descriptors.js");
|
|
var fails = __webpack_require__(/*! ../internals/fails */ "./node_modules/core-js/internals/fails.js");
|
|
var createElement = __webpack_require__(/*! ../internals/document-create-element */ "./node_modules/core-js/internals/document-create-element.js");
|
|
|
|
// Thank's IE8 for his funny defineProperty
|
|
module.exports = !DESCRIPTORS && !fails(function () {
|
|
return Object.defineProperty(createElement('div'), 'a', {
|
|
get: function () { return 7; }
|
|
}).a != 7;
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/indexed-object.js":
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/indexed-object.js ***!
|
|
\**********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
// fallback for non-array-like ES3 and non-enumerable old V8 strings
|
|
var fails = __webpack_require__(/*! ../internals/fails */ "./node_modules/core-js/internals/fails.js");
|
|
var classof = __webpack_require__(/*! ../internals/classof-raw */ "./node_modules/core-js/internals/classof-raw.js");
|
|
|
|
var split = ''.split;
|
|
|
|
module.exports = fails(function () {
|
|
// throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
|
|
// eslint-disable-next-line no-prototype-builtins
|
|
return !Object('z').propertyIsEnumerable(0);
|
|
}) ? function (it) {
|
|
return classof(it) == 'String' ? split.call(it, '') : Object(it);
|
|
} : Object;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/internal-state.js":
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/internal-state.js ***!
|
|
\**********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var NATIVE_WEAK_MAP = __webpack_require__(/*! ../internals/native-weak-map */ "./node_modules/core-js/internals/native-weak-map.js");
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var isObject = __webpack_require__(/*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js");
|
|
var hide = __webpack_require__(/*! ../internals/hide */ "./node_modules/core-js/internals/hide.js");
|
|
var objectHas = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var sharedKey = __webpack_require__(/*! ../internals/shared-key */ "./node_modules/core-js/internals/shared-key.js");
|
|
var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "./node_modules/core-js/internals/hidden-keys.js");
|
|
|
|
var WeakMap = global.WeakMap;
|
|
var set, get, has;
|
|
|
|
var enforce = function (it) {
|
|
return has(it) ? get(it) : set(it, {});
|
|
};
|
|
|
|
var getterFor = function (TYPE) {
|
|
return function (it) {
|
|
var state;
|
|
if (!isObject(it) || (state = get(it)).type !== TYPE) {
|
|
throw TypeError('Incompatible receiver, ' + TYPE + ' required');
|
|
} return state;
|
|
};
|
|
};
|
|
|
|
if (NATIVE_WEAK_MAP) {
|
|
var store = new WeakMap();
|
|
var wmget = store.get;
|
|
var wmhas = store.has;
|
|
var wmset = store.set;
|
|
set = function (it, metadata) {
|
|
wmset.call(store, it, metadata);
|
|
return metadata;
|
|
};
|
|
get = function (it) {
|
|
return wmget.call(store, it) || {};
|
|
};
|
|
has = function (it) {
|
|
return wmhas.call(store, it);
|
|
};
|
|
} else {
|
|
var STATE = sharedKey('state');
|
|
hiddenKeys[STATE] = true;
|
|
set = function (it, metadata) {
|
|
hide(it, STATE, metadata);
|
|
return metadata;
|
|
};
|
|
get = function (it) {
|
|
return objectHas(it, STATE) ? it[STATE] : {};
|
|
};
|
|
has = function (it) {
|
|
return objectHas(it, STATE);
|
|
};
|
|
}
|
|
|
|
module.exports = {
|
|
set: set,
|
|
get: get,
|
|
has: has,
|
|
enforce: enforce,
|
|
getterFor: getterFor
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/is-array-iterator-method.js":
|
|
/*!********************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/is-array-iterator-method.js ***!
|
|
\********************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "./node_modules/core-js/internals/well-known-symbol.js");
|
|
var Iterators = __webpack_require__(/*! ../internals/iterators */ "./node_modules/core-js/internals/iterators.js");
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var ArrayPrototype = Array.prototype;
|
|
|
|
// check on default Array iterator
|
|
module.exports = function (it) {
|
|
return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/is-forced.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/is-forced.js ***!
|
|
\*****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var fails = __webpack_require__(/*! ../internals/fails */ "./node_modules/core-js/internals/fails.js");
|
|
|
|
var replacement = /#|\.prototype\./;
|
|
|
|
var isForced = function (feature, detection) {
|
|
var value = data[normalize(feature)];
|
|
return value == POLYFILL ? true
|
|
: value == NATIVE ? false
|
|
: typeof detection == 'function' ? fails(detection)
|
|
: !!detection;
|
|
};
|
|
|
|
var normalize = isForced.normalize = function (string) {
|
|
return String(string).replace(replacement, '.').toLowerCase();
|
|
};
|
|
|
|
var data = isForced.data = {};
|
|
var NATIVE = isForced.NATIVE = 'N';
|
|
var POLYFILL = isForced.POLYFILL = 'P';
|
|
|
|
module.exports = isForced;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/is-object.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/is-object.js ***!
|
|
\*****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = function (it) {
|
|
return typeof it === 'object' ? it !== null : typeof it === 'function';
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/is-pure.js":
|
|
/*!***************************************************!*\
|
|
!*** ./node_modules/core-js/internals/is-pure.js ***!
|
|
\***************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = false;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/iterators-core.js":
|
|
/*!**********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/iterators-core.js ***!
|
|
\**********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var getPrototypeOf = __webpack_require__(/*! ../internals/object-get-prototype-of */ "./node_modules/core-js/internals/object-get-prototype-of.js");
|
|
var hide = __webpack_require__(/*! ../internals/hide */ "./node_modules/core-js/internals/hide.js");
|
|
var has = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "./node_modules/core-js/internals/well-known-symbol.js");
|
|
var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "./node_modules/core-js/internals/is-pure.js");
|
|
|
|
var ITERATOR = wellKnownSymbol('iterator');
|
|
var BUGGY_SAFARI_ITERATORS = false;
|
|
|
|
var returnThis = function () { return this; };
|
|
|
|
// `%IteratorPrototype%` object
|
|
// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object
|
|
var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
|
|
|
|
if ([].keys) {
|
|
arrayIterator = [].keys();
|
|
// Safari 8 has buggy iterators w/o `next`
|
|
if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
|
|
else {
|
|
PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
|
|
if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
|
|
}
|
|
}
|
|
|
|
if (IteratorPrototype == undefined) IteratorPrototype = {};
|
|
|
|
// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()
|
|
if (!IS_PURE && !has(IteratorPrototype, ITERATOR)) hide(IteratorPrototype, ITERATOR, returnThis);
|
|
|
|
module.exports = {
|
|
IteratorPrototype: IteratorPrototype,
|
|
BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/iterators.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/iterators.js ***!
|
|
\*****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
module.exports = {};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/native-symbol.js":
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/native-symbol.js ***!
|
|
\*********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var fails = __webpack_require__(/*! ../internals/fails */ "./node_modules/core-js/internals/fails.js");
|
|
|
|
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
|
|
// Chrome 38 Symbol has incorrect toString conversion
|
|
// eslint-disable-next-line no-undef
|
|
return !String(Symbol());
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/native-weak-map.js":
|
|
/*!***********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/native-weak-map.js ***!
|
|
\***********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var nativeFunctionToString = __webpack_require__(/*! ../internals/function-to-string */ "./node_modules/core-js/internals/function-to-string.js");
|
|
|
|
var WeakMap = global.WeakMap;
|
|
|
|
module.exports = typeof WeakMap === 'function' && /native code/.test(nativeFunctionToString.call(WeakMap));
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-create.js":
|
|
/*!*********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-create.js ***!
|
|
\*********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var anObject = __webpack_require__(/*! ../internals/an-object */ "./node_modules/core-js/internals/an-object.js");
|
|
var defineProperties = __webpack_require__(/*! ../internals/object-define-properties */ "./node_modules/core-js/internals/object-define-properties.js");
|
|
var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ "./node_modules/core-js/internals/enum-bug-keys.js");
|
|
var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "./node_modules/core-js/internals/hidden-keys.js");
|
|
var html = __webpack_require__(/*! ../internals/html */ "./node_modules/core-js/internals/html.js");
|
|
var documentCreateElement = __webpack_require__(/*! ../internals/document-create-element */ "./node_modules/core-js/internals/document-create-element.js");
|
|
var sharedKey = __webpack_require__(/*! ../internals/shared-key */ "./node_modules/core-js/internals/shared-key.js");
|
|
var IE_PROTO = sharedKey('IE_PROTO');
|
|
|
|
var PROTOTYPE = 'prototype';
|
|
var Empty = function () { /* empty */ };
|
|
|
|
// Create object with fake `null` prototype: use iframe Object with cleared prototype
|
|
var createDict = function () {
|
|
// Thrash, waste and sodomy: IE GC bug
|
|
var iframe = documentCreateElement('iframe');
|
|
var length = enumBugKeys.length;
|
|
var lt = '<';
|
|
var script = 'script';
|
|
var gt = '>';
|
|
var js = 'java' + script + ':';
|
|
var iframeDocument;
|
|
iframe.style.display = 'none';
|
|
html.appendChild(iframe);
|
|
iframe.src = String(js);
|
|
iframeDocument = iframe.contentWindow.document;
|
|
iframeDocument.open();
|
|
iframeDocument.write(lt + script + gt + 'document.F=Object' + lt + '/' + script + gt);
|
|
iframeDocument.close();
|
|
createDict = iframeDocument.F;
|
|
while (length--) delete createDict[PROTOTYPE][enumBugKeys[length]];
|
|
return createDict();
|
|
};
|
|
|
|
// 19.1.2.2 / 15.2.3.5 Object.create(O [, Properties])
|
|
module.exports = Object.create || function create(O, Properties) {
|
|
var result;
|
|
if (O !== null) {
|
|
Empty[PROTOTYPE] = anObject(O);
|
|
result = new Empty();
|
|
Empty[PROTOTYPE] = null;
|
|
// add "__proto__" for Object.getPrototypeOf polyfill
|
|
result[IE_PROTO] = O;
|
|
} else result = createDict();
|
|
return Properties === undefined ? result : defineProperties(result, Properties);
|
|
};
|
|
|
|
hiddenKeys[IE_PROTO] = true;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-define-properties.js":
|
|
/*!********************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-define-properties.js ***!
|
|
\********************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "./node_modules/core-js/internals/descriptors.js");
|
|
var definePropertyModule = __webpack_require__(/*! ../internals/object-define-property */ "./node_modules/core-js/internals/object-define-property.js");
|
|
var anObject = __webpack_require__(/*! ../internals/an-object */ "./node_modules/core-js/internals/an-object.js");
|
|
var objectKeys = __webpack_require__(/*! ../internals/object-keys */ "./node_modules/core-js/internals/object-keys.js");
|
|
|
|
module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
|
|
anObject(O);
|
|
var keys = objectKeys(Properties);
|
|
var length = keys.length;
|
|
var i = 0;
|
|
var key;
|
|
while (length > i) definePropertyModule.f(O, key = keys[i++], Properties[key]);
|
|
return O;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-define-property.js":
|
|
/*!******************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-define-property.js ***!
|
|
\******************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "./node_modules/core-js/internals/descriptors.js");
|
|
var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ "./node_modules/core-js/internals/ie8-dom-define.js");
|
|
var anObject = __webpack_require__(/*! ../internals/an-object */ "./node_modules/core-js/internals/an-object.js");
|
|
var toPrimitive = __webpack_require__(/*! ../internals/to-primitive */ "./node_modules/core-js/internals/to-primitive.js");
|
|
|
|
var nativeDefineProperty = Object.defineProperty;
|
|
|
|
exports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {
|
|
anObject(O);
|
|
P = toPrimitive(P, true);
|
|
anObject(Attributes);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return nativeDefineProperty(O, P, Attributes);
|
|
} catch (error) { /* empty */ }
|
|
if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');
|
|
if ('value' in Attributes) O[P] = Attributes.value;
|
|
return O;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-get-own-property-descriptor.js":
|
|
/*!******************************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-get-own-property-descriptor.js ***!
|
|
\******************************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var DESCRIPTORS = __webpack_require__(/*! ../internals/descriptors */ "./node_modules/core-js/internals/descriptors.js");
|
|
var propertyIsEnumerableModule = __webpack_require__(/*! ../internals/object-property-is-enumerable */ "./node_modules/core-js/internals/object-property-is-enumerable.js");
|
|
var createPropertyDescriptor = __webpack_require__(/*! ../internals/create-property-descriptor */ "./node_modules/core-js/internals/create-property-descriptor.js");
|
|
var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "./node_modules/core-js/internals/to-indexed-object.js");
|
|
var toPrimitive = __webpack_require__(/*! ../internals/to-primitive */ "./node_modules/core-js/internals/to-primitive.js");
|
|
var has = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var IE8_DOM_DEFINE = __webpack_require__(/*! ../internals/ie8-dom-define */ "./node_modules/core-js/internals/ie8-dom-define.js");
|
|
|
|
var nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
exports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
|
|
O = toIndexedObject(O);
|
|
P = toPrimitive(P, true);
|
|
if (IE8_DOM_DEFINE) try {
|
|
return nativeGetOwnPropertyDescriptor(O, P);
|
|
} catch (error) { /* empty */ }
|
|
if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-get-own-property-names.js":
|
|
/*!*************************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-get-own-property-names.js ***!
|
|
\*************************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
// 19.1.2.7 / 15.2.3.4 Object.getOwnPropertyNames(O)
|
|
var internalObjectKeys = __webpack_require__(/*! ../internals/object-keys-internal */ "./node_modules/core-js/internals/object-keys-internal.js");
|
|
var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ "./node_modules/core-js/internals/enum-bug-keys.js");
|
|
|
|
var hiddenKeys = enumBugKeys.concat('length', 'prototype');
|
|
|
|
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
|
|
return internalObjectKeys(O, hiddenKeys);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-get-own-property-symbols.js":
|
|
/*!***************************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-get-own-property-symbols.js ***!
|
|
\***************************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
exports.f = Object.getOwnPropertySymbols;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-get-prototype-of.js":
|
|
/*!*******************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-get-prototype-of.js ***!
|
|
\*******************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var has = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var toObject = __webpack_require__(/*! ../internals/to-object */ "./node_modules/core-js/internals/to-object.js");
|
|
var sharedKey = __webpack_require__(/*! ../internals/shared-key */ "./node_modules/core-js/internals/shared-key.js");
|
|
var CORRECT_PROTOTYPE_GETTER = __webpack_require__(/*! ../internals/correct-prototype-getter */ "./node_modules/core-js/internals/correct-prototype-getter.js");
|
|
|
|
var IE_PROTO = sharedKey('IE_PROTO');
|
|
var ObjectPrototype = Object.prototype;
|
|
|
|
// 19.1.2.9 / 15.2.3.2 Object.getPrototypeOf(O)
|
|
module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
|
|
O = toObject(O);
|
|
if (has(O, IE_PROTO)) return O[IE_PROTO];
|
|
if (typeof O.constructor == 'function' && O instanceof O.constructor) {
|
|
return O.constructor.prototype;
|
|
} return O instanceof Object ? ObjectPrototype : null;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-keys-internal.js":
|
|
/*!****************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-keys-internal.js ***!
|
|
\****************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var has = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var toIndexedObject = __webpack_require__(/*! ../internals/to-indexed-object */ "./node_modules/core-js/internals/to-indexed-object.js");
|
|
var arrayIncludes = __webpack_require__(/*! ../internals/array-includes */ "./node_modules/core-js/internals/array-includes.js");
|
|
var hiddenKeys = __webpack_require__(/*! ../internals/hidden-keys */ "./node_modules/core-js/internals/hidden-keys.js");
|
|
|
|
var arrayIndexOf = arrayIncludes(false);
|
|
|
|
module.exports = function (object, names) {
|
|
var O = toIndexedObject(object);
|
|
var i = 0;
|
|
var result = [];
|
|
var key;
|
|
for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);
|
|
// Don't enum bug & hidden keys
|
|
while (names.length > i) if (has(O, key = names[i++])) {
|
|
~arrayIndexOf(result, key) || result.push(key);
|
|
}
|
|
return result;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-keys.js":
|
|
/*!*******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-keys.js ***!
|
|
\*******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var internalObjectKeys = __webpack_require__(/*! ../internals/object-keys-internal */ "./node_modules/core-js/internals/object-keys-internal.js");
|
|
var enumBugKeys = __webpack_require__(/*! ../internals/enum-bug-keys */ "./node_modules/core-js/internals/enum-bug-keys.js");
|
|
|
|
// 19.1.2.14 / 15.2.3.14 Object.keys(O)
|
|
module.exports = Object.keys || function keys(O) {
|
|
return internalObjectKeys(O, enumBugKeys);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-property-is-enumerable.js":
|
|
/*!*************************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-property-is-enumerable.js ***!
|
|
\*************************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var nativePropertyIsEnumerable = {}.propertyIsEnumerable;
|
|
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
|
|
|
|
// Nashorn ~ JDK8 bug
|
|
var NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);
|
|
|
|
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
|
|
var descriptor = getOwnPropertyDescriptor(this, V);
|
|
return !!descriptor && descriptor.enumerable;
|
|
} : nativePropertyIsEnumerable;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/object-set-prototype-of.js":
|
|
/*!*******************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/object-set-prototype-of.js ***!
|
|
\*******************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var validateSetPrototypeOfArguments = __webpack_require__(/*! ../internals/validate-set-prototype-of-arguments */ "./node_modules/core-js/internals/validate-set-prototype-of-arguments.js");
|
|
|
|
// Works with __proto__ only. Old v8 can't work with null proto objects.
|
|
/* eslint-disable no-proto */
|
|
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
|
|
var correctSetter = false;
|
|
var test = {};
|
|
var setter;
|
|
try {
|
|
setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
|
|
setter.call(test, []);
|
|
correctSetter = test instanceof Array;
|
|
} catch (error) { /* empty */ }
|
|
return function setPrototypeOf(O, proto) {
|
|
validateSetPrototypeOfArguments(O, proto);
|
|
if (correctSetter) setter.call(O, proto);
|
|
else O.__proto__ = proto;
|
|
return O;
|
|
};
|
|
}() : undefined);
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/own-keys.js":
|
|
/*!****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/own-keys.js ***!
|
|
\****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var getOwnPropertyNamesModule = __webpack_require__(/*! ../internals/object-get-own-property-names */ "./node_modules/core-js/internals/object-get-own-property-names.js");
|
|
var getOwnPropertySymbolsModule = __webpack_require__(/*! ../internals/object-get-own-property-symbols */ "./node_modules/core-js/internals/object-get-own-property-symbols.js");
|
|
var anObject = __webpack_require__(/*! ../internals/an-object */ "./node_modules/core-js/internals/an-object.js");
|
|
|
|
var Reflect = global.Reflect;
|
|
|
|
// all object keys, includes non-enumerable and symbols
|
|
module.exports = Reflect && Reflect.ownKeys || function ownKeys(it) {
|
|
var keys = getOwnPropertyNamesModule.f(anObject(it));
|
|
var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
|
|
return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/path.js":
|
|
/*!************************************************!*\
|
|
!*** ./node_modules/core-js/internals/path.js ***!
|
|
\************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
module.exports = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/redefine.js":
|
|
/*!****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/redefine.js ***!
|
|
\****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var shared = __webpack_require__(/*! ../internals/shared */ "./node_modules/core-js/internals/shared.js");
|
|
var hide = __webpack_require__(/*! ../internals/hide */ "./node_modules/core-js/internals/hide.js");
|
|
var has = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var setGlobal = __webpack_require__(/*! ../internals/set-global */ "./node_modules/core-js/internals/set-global.js");
|
|
var nativeFunctionToString = __webpack_require__(/*! ../internals/function-to-string */ "./node_modules/core-js/internals/function-to-string.js");
|
|
var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "./node_modules/core-js/internals/internal-state.js");
|
|
|
|
var getInternalState = InternalStateModule.get;
|
|
var enforceInternalState = InternalStateModule.enforce;
|
|
var TEMPLATE = String(nativeFunctionToString).split('toString');
|
|
|
|
shared('inspectSource', function (it) {
|
|
return nativeFunctionToString.call(it);
|
|
});
|
|
|
|
(module.exports = function (O, key, value, options) {
|
|
var unsafe = options ? !!options.unsafe : false;
|
|
var simple = options ? !!options.enumerable : false;
|
|
var noTargetGet = options ? !!options.noTargetGet : false;
|
|
if (typeof value == 'function') {
|
|
if (typeof key == 'string' && !has(value, 'name')) hide(value, 'name', key);
|
|
enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');
|
|
}
|
|
if (O === global) {
|
|
if (simple) O[key] = value;
|
|
else setGlobal(key, value);
|
|
return;
|
|
} else if (!unsafe) {
|
|
delete O[key];
|
|
} else if (!noTargetGet && O[key]) {
|
|
simple = true;
|
|
}
|
|
if (simple) O[key] = value;
|
|
else hide(O, key, value);
|
|
// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
|
|
})(Function.prototype, 'toString', function toString() {
|
|
return typeof this == 'function' && getInternalState(this).source || nativeFunctionToString.call(this);
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/require-object-coercible.js":
|
|
/*!********************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/require-object-coercible.js ***!
|
|
\********************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
// `RequireObjectCoercible` abstract operation
|
|
// https://tc39.github.io/ecma262/#sec-requireobjectcoercible
|
|
module.exports = function (it) {
|
|
if (it == undefined) throw TypeError("Can't call method on " + it);
|
|
return it;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/set-global.js":
|
|
/*!******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/set-global.js ***!
|
|
\******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var hide = __webpack_require__(/*! ../internals/hide */ "./node_modules/core-js/internals/hide.js");
|
|
|
|
module.exports = function (key, value) {
|
|
try {
|
|
hide(global, key, value);
|
|
} catch (error) {
|
|
global[key] = value;
|
|
} return value;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/set-to-string-tag.js":
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/set-to-string-tag.js ***!
|
|
\*************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var defineProperty = __webpack_require__(/*! ../internals/object-define-property */ "./node_modules/core-js/internals/object-define-property.js").f;
|
|
var has = __webpack_require__(/*! ../internals/has */ "./node_modules/core-js/internals/has.js");
|
|
var wellKnownSymbol = __webpack_require__(/*! ../internals/well-known-symbol */ "./node_modules/core-js/internals/well-known-symbol.js");
|
|
|
|
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
|
|
|
|
module.exports = function (it, TAG, STATIC) {
|
|
if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
|
|
defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/shared-key.js":
|
|
/*!******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/shared-key.js ***!
|
|
\******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var shared = __webpack_require__(/*! ../internals/shared */ "./node_modules/core-js/internals/shared.js");
|
|
var uid = __webpack_require__(/*! ../internals/uid */ "./node_modules/core-js/internals/uid.js");
|
|
|
|
var keys = shared('keys');
|
|
|
|
module.exports = function (key) {
|
|
return keys[key] || (keys[key] = uid(key));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/shared.js":
|
|
/*!**************************************************!*\
|
|
!*** ./node_modules/core-js/internals/shared.js ***!
|
|
\**************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var setGlobal = __webpack_require__(/*! ../internals/set-global */ "./node_modules/core-js/internals/set-global.js");
|
|
var IS_PURE = __webpack_require__(/*! ../internals/is-pure */ "./node_modules/core-js/internals/is-pure.js");
|
|
|
|
var SHARED = '__core-js_shared__';
|
|
var store = global[SHARED] || setGlobal(SHARED, {});
|
|
|
|
(module.exports = function (key, value) {
|
|
return store[key] || (store[key] = value !== undefined ? value : {});
|
|
})('versions', []).push({
|
|
version: '3.1.3',
|
|
mode: IS_PURE ? 'pure' : 'global',
|
|
copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/string-at.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/string-at.js ***!
|
|
\*****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var toInteger = __webpack_require__(/*! ../internals/to-integer */ "./node_modules/core-js/internals/to-integer.js");
|
|
var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "./node_modules/core-js/internals/require-object-coercible.js");
|
|
|
|
// CONVERT_TO_STRING: true -> String#at
|
|
// CONVERT_TO_STRING: false -> String#codePointAt
|
|
module.exports = function (that, pos, CONVERT_TO_STRING) {
|
|
var S = String(requireObjectCoercible(that));
|
|
var position = toInteger(pos);
|
|
var size = S.length;
|
|
var first, second;
|
|
if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;
|
|
first = S.charCodeAt(position);
|
|
return first < 0xD800 || first > 0xDBFF || position + 1 === size
|
|
|| (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF
|
|
? CONVERT_TO_STRING ? S.charAt(position) : first
|
|
: CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/to-absolute-index.js":
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/to-absolute-index.js ***!
|
|
\*************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var toInteger = __webpack_require__(/*! ../internals/to-integer */ "./node_modules/core-js/internals/to-integer.js");
|
|
|
|
var max = Math.max;
|
|
var min = Math.min;
|
|
|
|
// Helper for a popular repeating case of the spec:
|
|
// Let integer be ? ToInteger(index).
|
|
// If integer < 0, let result be max((length + integer), 0); else let result be min(length, length).
|
|
module.exports = function (index, length) {
|
|
var integer = toInteger(index);
|
|
return integer < 0 ? max(integer + length, 0) : min(integer, length);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/to-indexed-object.js":
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/to-indexed-object.js ***!
|
|
\*************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
// toObject with fallback for non-array-like ES3 strings
|
|
var IndexedObject = __webpack_require__(/*! ../internals/indexed-object */ "./node_modules/core-js/internals/indexed-object.js");
|
|
var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "./node_modules/core-js/internals/require-object-coercible.js");
|
|
|
|
module.exports = function (it) {
|
|
return IndexedObject(requireObjectCoercible(it));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/to-integer.js":
|
|
/*!******************************************************!*\
|
|
!*** ./node_modules/core-js/internals/to-integer.js ***!
|
|
\******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
var ceil = Math.ceil;
|
|
var floor = Math.floor;
|
|
|
|
// `ToInteger` abstract operation
|
|
// https://tc39.github.io/ecma262/#sec-tointeger
|
|
module.exports = function (argument) {
|
|
return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/to-length.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/to-length.js ***!
|
|
\*****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var toInteger = __webpack_require__(/*! ../internals/to-integer */ "./node_modules/core-js/internals/to-integer.js");
|
|
|
|
var min = Math.min;
|
|
|
|
// `ToLength` abstract operation
|
|
// https://tc39.github.io/ecma262/#sec-tolength
|
|
module.exports = function (argument) {
|
|
return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/to-object.js":
|
|
/*!*****************************************************!*\
|
|
!*** ./node_modules/core-js/internals/to-object.js ***!
|
|
\*****************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var requireObjectCoercible = __webpack_require__(/*! ../internals/require-object-coercible */ "./node_modules/core-js/internals/require-object-coercible.js");
|
|
|
|
// `ToObject` abstract operation
|
|
// https://tc39.github.io/ecma262/#sec-toobject
|
|
module.exports = function (argument) {
|
|
return Object(requireObjectCoercible(argument));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/to-primitive.js":
|
|
/*!********************************************************!*\
|
|
!*** ./node_modules/core-js/internals/to-primitive.js ***!
|
|
\********************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isObject = __webpack_require__(/*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js");
|
|
|
|
// 7.1.1 ToPrimitive(input [, PreferredType])
|
|
// instead of the ES6 spec version, we didn't implement @@toPrimitive case
|
|
// and the second argument - flag - preferred type is a string
|
|
module.exports = function (it, S) {
|
|
if (!isObject(it)) return it;
|
|
var fn, val;
|
|
if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
|
|
if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
|
|
if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
|
|
throw TypeError("Can't convert object to primitive value");
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/uid.js":
|
|
/*!***********************************************!*\
|
|
!*** ./node_modules/core-js/internals/uid.js ***!
|
|
\***********************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
var id = 0;
|
|
var postfix = Math.random();
|
|
|
|
module.exports = function (key) {
|
|
return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + postfix).toString(36));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/validate-set-prototype-of-arguments.js":
|
|
/*!*******************************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/validate-set-prototype-of-arguments.js ***!
|
|
\*******************************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var isObject = __webpack_require__(/*! ../internals/is-object */ "./node_modules/core-js/internals/is-object.js");
|
|
var anObject = __webpack_require__(/*! ../internals/an-object */ "./node_modules/core-js/internals/an-object.js");
|
|
|
|
module.exports = function (O, proto) {
|
|
anObject(O);
|
|
if (!isObject(proto) && proto !== null) {
|
|
throw TypeError("Can't set " + String(proto) + ' as a prototype');
|
|
}
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/internals/well-known-symbol.js":
|
|
/*!*************************************************************!*\
|
|
!*** ./node_modules/core-js/internals/well-known-symbol.js ***!
|
|
\*************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var global = __webpack_require__(/*! ../internals/global */ "./node_modules/core-js/internals/global.js");
|
|
var shared = __webpack_require__(/*! ../internals/shared */ "./node_modules/core-js/internals/shared.js");
|
|
var uid = __webpack_require__(/*! ../internals/uid */ "./node_modules/core-js/internals/uid.js");
|
|
var NATIVE_SYMBOL = __webpack_require__(/*! ../internals/native-symbol */ "./node_modules/core-js/internals/native-symbol.js");
|
|
|
|
var Symbol = global.Symbol;
|
|
var store = shared('wks');
|
|
|
|
module.exports = function (name) {
|
|
return store[name] || (store[name] = NATIVE_SYMBOL && Symbol[name]
|
|
|| (NATIVE_SYMBOL ? Symbol : uid)('Symbol.' + name));
|
|
};
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/modules/es.array.from.js":
|
|
/*!*******************************************************!*\
|
|
!*** ./node_modules/core-js/modules/es.array.from.js ***!
|
|
\*******************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var $ = __webpack_require__(/*! ../internals/export */ "./node_modules/core-js/internals/export.js");
|
|
var from = __webpack_require__(/*! ../internals/array-from */ "./node_modules/core-js/internals/array-from.js");
|
|
var checkCorrectnessOfIteration = __webpack_require__(/*! ../internals/check-correctness-of-iteration */ "./node_modules/core-js/internals/check-correctness-of-iteration.js");
|
|
|
|
var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {
|
|
});
|
|
|
|
// `Array.from` method
|
|
// https://tc39.github.io/ecma262/#sec-array.from
|
|
$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {
|
|
from: from
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/core-js/modules/es.string.iterator.js":
|
|
/*!************************************************************!*\
|
|
!*** ./node_modules/core-js/modules/es.string.iterator.js ***!
|
|
\************************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
var codePointAt = __webpack_require__(/*! ../internals/string-at */ "./node_modules/core-js/internals/string-at.js");
|
|
var InternalStateModule = __webpack_require__(/*! ../internals/internal-state */ "./node_modules/core-js/internals/internal-state.js");
|
|
var defineIterator = __webpack_require__(/*! ../internals/define-iterator */ "./node_modules/core-js/internals/define-iterator.js");
|
|
|
|
var STRING_ITERATOR = 'String Iterator';
|
|
var setInternalState = InternalStateModule.set;
|
|
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
|
|
|
|
// `String.prototype[@@iterator]` method
|
|
// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator
|
|
defineIterator(String, 'String', function (iterated) {
|
|
setInternalState(this, {
|
|
type: STRING_ITERATOR,
|
|
string: String(iterated),
|
|
index: 0
|
|
});
|
|
// `%StringIteratorPrototype%.next` method
|
|
// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next
|
|
}, function next() {
|
|
var state = getInternalState(this);
|
|
var string = state.string;
|
|
var index = state.index;
|
|
var point;
|
|
if (index >= string.length) return { value: undefined, done: true };
|
|
point = codePointAt(string, index, true);
|
|
state.index += point.length;
|
|
return { value: point, done: false };
|
|
});
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./node_modules/webpack/buildin/global.js":
|
|
/*!***********************************!*\
|
|
!*** (webpack)/buildin/global.js ***!
|
|
\***********************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports) {
|
|
|
|
var g;
|
|
|
|
// This works in non-strict mode
|
|
g = (function() {
|
|
return this;
|
|
})();
|
|
|
|
try {
|
|
// This works if eval is allowed (see CSP)
|
|
g = g || Function("return this")() || (1, eval)("this");
|
|
} catch (e) {
|
|
// This works if the window reference is available
|
|
if (typeof window === "object") g = window;
|
|
}
|
|
|
|
// g can still be undefined, but nothing to do about it...
|
|
// We return undefined, instead of nothing here, so it's
|
|
// easier to handle this case. if(!global) { ...}
|
|
|
|
module.exports = g;
|
|
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/default-attrs.json":
|
|
/*!********************************!*\
|
|
!*** ./src/default-attrs.json ***!
|
|
\********************************/
|
|
/*! exports provided: xmlns, width, height, viewBox, fill, stroke, stroke-width, stroke-linecap, stroke-linejoin, default */
|
|
/***/ (function(module) {
|
|
|
|
module.exports = {"xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","stroke-width":2,"stroke-linecap":"round","stroke-linejoin":"round"};
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/icon.js":
|
|
/*!*********************!*\
|
|
!*** ./src/icon.js ***!
|
|
\*********************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; };
|
|
|
|
var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
|
|
|
|
var _dedupe = __webpack_require__(/*! classnames/dedupe */ "./node_modules/classnames/dedupe.js");
|
|
|
|
var _dedupe2 = _interopRequireDefault(_dedupe);
|
|
|
|
var _defaultAttrs = __webpack_require__(/*! ./default-attrs.json */ "./src/default-attrs.json");
|
|
|
|
var _defaultAttrs2 = _interopRequireDefault(_defaultAttrs);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
|
|
|
|
var Icon = function () {
|
|
function Icon(name, contents) {
|
|
var tags = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
|
|
|
|
_classCallCheck(this, Icon);
|
|
|
|
this.name = name;
|
|
this.contents = contents;
|
|
this.tags = tags;
|
|
this.attrs = _extends({}, _defaultAttrs2.default, { class: 'feather feather-' + name });
|
|
}
|
|
|
|
/**
|
|
* Create an SVG string.
|
|
* @param {Object} attrs
|
|
* @returns {string}
|
|
*/
|
|
|
|
|
|
_createClass(Icon, [{
|
|
key: 'toSvg',
|
|
value: function toSvg() {
|
|
var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
var combinedAttrs = _extends({}, this.attrs, attrs, { class: (0, _dedupe2.default)(this.attrs.class, attrs.class) });
|
|
|
|
return '<svg ' + attrsToString(combinedAttrs) + '>' + this.contents + '</svg>';
|
|
}
|
|
|
|
/**
|
|
* Return string representation of an `Icon`.
|
|
*
|
|
* Added for backward compatibility. If old code expects `feather.icons.<name>`
|
|
* to be a string, `toString()` will get implicitly called.
|
|
*
|
|
* @returns {string}
|
|
*/
|
|
|
|
}, {
|
|
key: 'toString',
|
|
value: function toString() {
|
|
return this.contents;
|
|
}
|
|
}]);
|
|
|
|
return Icon;
|
|
}();
|
|
|
|
/**
|
|
* Convert attributes object to string of HTML attributes.
|
|
* @param {Object} attrs
|
|
* @returns {string}
|
|
*/
|
|
|
|
|
|
function attrsToString(attrs) {
|
|
return Object.keys(attrs).map(function (key) {
|
|
return key + '="' + attrs[key] + '"';
|
|
}).join(' ');
|
|
}
|
|
|
|
exports.default = Icon;
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/icons.js":
|
|
/*!**********************!*\
|
|
!*** ./src/icons.js ***!
|
|
\**********************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _icon = __webpack_require__(/*! ./icon */ "./src/icon.js");
|
|
|
|
var _icon2 = _interopRequireDefault(_icon);
|
|
|
|
var _icons = __webpack_require__(/*! ../dist/icons.json */ "./dist/icons.json");
|
|
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
|
|
var _tags = __webpack_require__(/*! ./tags.json */ "./src/tags.json");
|
|
|
|
var _tags2 = _interopRequireDefault(_tags);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
exports.default = Object.keys(_icons2.default).map(function (key) {
|
|
return new _icon2.default(key, _icons2.default[key], _tags2.default[key]);
|
|
}).reduce(function (object, icon) {
|
|
object[icon.name] = icon;
|
|
return object;
|
|
}, {});
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/index.js":
|
|
/*!**********************!*\
|
|
!*** ./src/index.js ***!
|
|
\**********************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
var _icons = __webpack_require__(/*! ./icons */ "./src/icons.js");
|
|
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
|
|
var _toSvg = __webpack_require__(/*! ./to-svg */ "./src/to-svg.js");
|
|
|
|
var _toSvg2 = _interopRequireDefault(_toSvg);
|
|
|
|
var _replace = __webpack_require__(/*! ./replace */ "./src/replace.js");
|
|
|
|
var _replace2 = _interopRequireDefault(_replace);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
module.exports = { icons: _icons2.default, toSvg: _toSvg2.default, replace: _replace2.default };
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/replace.js":
|
|
/*!************************!*\
|
|
!*** ./src/replace.js ***!
|
|
\************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; /* eslint-env browser */
|
|
|
|
|
|
var _dedupe = __webpack_require__(/*! classnames/dedupe */ "./node_modules/classnames/dedupe.js");
|
|
|
|
var _dedupe2 = _interopRequireDefault(_dedupe);
|
|
|
|
var _icons = __webpack_require__(/*! ./icons */ "./src/icons.js");
|
|
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/**
|
|
* Replace all HTML elements that have a `data-feather` attribute with SVG markup
|
|
* corresponding to the element's `data-feather` attribute value.
|
|
* @param {Object} attrs
|
|
*/
|
|
function replace() {
|
|
var attrs = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
|
|
|
|
if (typeof document === 'undefined') {
|
|
throw new Error('`feather.replace()` only works in a browser environment.');
|
|
}
|
|
|
|
var elementsToReplace = document.querySelectorAll('[data-feather]');
|
|
|
|
Array.from(elementsToReplace).forEach(function (element) {
|
|
return replaceElement(element, attrs);
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Replace a single HTML element with SVG markup
|
|
* corresponding to the element's `data-feather` attribute value.
|
|
* @param {HTMLElement} element
|
|
* @param {Object} attrs
|
|
*/
|
|
function replaceElement(element) {
|
|
var attrs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
var elementAttrs = getAttrs(element);
|
|
var name = elementAttrs['data-feather'];
|
|
delete elementAttrs['data-feather'];
|
|
|
|
var svgString = _icons2.default[name].toSvg(_extends({}, attrs, elementAttrs, { class: (0, _dedupe2.default)(attrs.class, elementAttrs.class) }));
|
|
var svgDocument = new DOMParser().parseFromString(svgString, 'image/svg+xml');
|
|
var svgElement = svgDocument.querySelector('svg');
|
|
|
|
element.parentNode.replaceChild(svgElement, element);
|
|
}
|
|
|
|
/**
|
|
* Get the attributes of an HTML element.
|
|
* @param {HTMLElement} element
|
|
* @returns {Object}
|
|
*/
|
|
function getAttrs(element) {
|
|
return Array.from(element.attributes).reduce(function (attrs, attr) {
|
|
attrs[attr.name] = attr.value;
|
|
return attrs;
|
|
}, {});
|
|
}
|
|
|
|
exports.default = replace;
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/tags.json":
|
|
/*!***********************!*\
|
|
!*** ./src/tags.json ***!
|
|
\***********************/
|
|
/*! exports provided: activity, airplay, alert-circle, alert-octagon, alert-triangle, at-sign, award, aperture, bell, bell-off, bluetooth, book-open, book, bookmark, briefcase, clipboard, clock, cloud-drizzle, cloud-lightning, cloud-rain, cloud-snow, cloud, codepen, codesandbox, coffee, command, compass, copy, corner-down-left, corner-down-right, corner-left-down, corner-left-up, corner-right-down, corner-right-up, corner-up-left, corner-up-right, credit-card, crop, crosshair, database, delete, disc, dollar-sign, droplet, edit, edit-2, edit-3, eye, eye-off, external-link, facebook, fast-forward, figma, film, folder-minus, folder-plus, folder, framer, frown, gift, git-branch, git-commit, git-merge, git-pull-request, github, gitlab, global, hard-drive, hash, headphones, heart, help-circle, hexagon, home, image, inbox, instagram, key, life-bouy, linkedin, lock, log-in, log-out, mail, map-pin, map, maximize, maximize-2, meh, menu, message-circle, message-square, mic-off, mic, minimize, minimize-2, monitor, moon, more-horizontal, more-vertical, mouse-pointer, move, navigation, navigation-2, octagon, package, paperclip, pause, pause-circle, pen-tool, play, play-circle, plus, plus-circle, plus-square, pocket, power, radio, rewind, rss, save, search, send, settings, shield, shield-off, shopping-bag, shopping-cart, shuffle, skip-back, skip-forward, slash, sliders, smile, speaker, star, sun, sunrise, sunset, tag, target, terminal, thumbs-down, thumbs-up, toggle-left, toggle-right, trash, trash-2, triangle, truck, twitter, umbrella, video-off, video, voicemail, volume, volume-1, volume-2, volume-x, watch, wind, x-circle, x-octagon, x-square, x, youtube, zap-off, zap, default */
|
|
/***/ (function(module) {
|
|
|
|
module.exports = {"activity":["pulse","health","action","motion"],"airplay":["stream","cast","mirroring"],"alert-circle":["warning"],"alert-octagon":["warning"],"alert-triangle":["warning"],"at-sign":["mention"],"award":["achievement","badge"],"aperture":["camera","photo"],"bell":["alarm","notification"],"bell-off":["alarm","notification","silent"],"bluetooth":["wireless"],"book-open":["read"],"book":["read","dictionary","booklet","magazine"],"bookmark":["read","clip","marker","tag"],"briefcase":["work","bag","baggage","folder"],"clipboard":["copy"],"clock":["time","watch","alarm"],"cloud-drizzle":["weather","shower"],"cloud-lightning":["weather","bolt"],"cloud-rain":["weather"],"cloud-snow":["weather","blizzard"],"cloud":["weather"],"codepen":["logo"],"codesandbox":["logo"],"coffee":["drink","cup","mug","tea","cafe","hot","beverage"],"command":["keyboard","cmd"],"compass":["navigation","safari","travel"],"copy":["clone","duplicate"],"corner-down-left":["arrow"],"corner-down-right":["arrow"],"corner-left-down":["arrow"],"corner-left-up":["arrow"],"corner-right-down":["arrow"],"corner-right-up":["arrow"],"corner-up-left":["arrow"],"corner-up-right":["arrow"],"credit-card":["purchase","payment","cc"],"crop":["photo","image"],"crosshair":["aim","target"],"database":["storage"],"delete":["remove"],"disc":["album","cd","dvd","music"],"dollar-sign":["currency","money","payment"],"droplet":["water"],"edit":["pencil","change"],"edit-2":["pencil","change"],"edit-3":["pencil","change"],"eye":["view","watch"],"eye-off":["view","watch"],"external-link":["outbound"],"facebook":["logo"],"fast-forward":["music"],"figma":["logo","design","tool"],"film":["movie","video"],"folder-minus":["directory"],"folder-plus":["directory"],"folder":["directory"],"framer":["logo","design","tool"],"frown":["emoji","face","bad","sad","emotion"],"gift":["present","box","birthday","party"],"git-branch":["code","version control"],"git-commit":["code","version control"],"git-merge":["code","version control"],"git-pull-request":["code","version control"],"github":["logo","version control"],"gitlab":["logo","version control"],"global":["world","browser","language","translate"],"hard-drive":["computer","server"],"hash":["hashtag","number","pound"],"headphones":["music","audio"],"heart":["like","love"],"help-circle":["question mark"],"hexagon":["shape","node.js","logo"],"home":["house"],"image":["picture"],"inbox":["email"],"instagram":["logo","camera"],"key":["password","login","authentication"],"life-bouy":["help","life ring","support"],"linkedin":["logo"],"lock":["security","password"],"log-in":["sign in","arrow"],"log-out":["sign out","arrow"],"mail":["email"],"map-pin":["location","navigation","travel","marker"],"map":["location","navigation","travel"],"maximize":["fullscreen"],"maximize-2":["fullscreen","arrows"],"meh":["emoji","face","neutral","emotion"],"menu":["bars","navigation","hamburger"],"message-circle":["comment","chat"],"message-square":["comment","chat"],"mic-off":["record"],"mic":["record"],"minimize":["exit fullscreen"],"minimize-2":["exit fullscreen","arrows"],"monitor":["tv"],"moon":["dark","night"],"more-horizontal":["ellipsis"],"more-vertical":["ellipsis"],"mouse-pointer":["arrow","cursor"],"move":["arrows"],"navigation":["location","travel"],"navigation-2":["location","travel"],"octagon":["stop"],"package":["box"],"paperclip":["attachment"],"pause":["music","stop"],"pause-circle":["music","stop"],"pen-tool":["vector","drawing"],"play":["music","start"],"play-circle":["music","start"],"plus":["add","new"],"plus-circle":["add","new"],"plus-square":["add","new"],"pocket":["logo","save"],"power":["on","off"],"radio":["signal"],"rewind":["music"],"rss":["feed","subscribe"],"save":["floppy disk"],"search":["find","magnifier","magnifying glass"],"send":["message","mail","paper airplane"],"settings":["cog","edit","gear","preferences"],"shield":["security"],"shield-off":["security"],"shopping-bag":["ecommerce","cart","purchase","store"],"shopping-cart":["ecommerce","cart","purchase","store"],"shuffle":["music"],"skip-back":["music"],"skip-forward":["music"],"slash":["ban","no"],"sliders":["settings","controls"],"smile":["emoji","face","happy","good","emotion"],"speaker":["music"],"star":["bookmark","favorite","like"],"sun":["brightness","weather","light"],"sunrise":["weather"],"sunset":["weather"],"tag":["label"],"target":["bullseye"],"terminal":["code","command line"],"thumbs-down":["dislike","bad"],"thumbs-up":["like","good"],"toggle-left":["on","off","switch"],"toggle-right":["on","off","switch"],"trash":["garbage","delete","remove"],"trash-2":["garbage","delete","remove"],"triangle":["delta"],"truck":["delivery","van","shipping"],"twitter":["logo"],"umbrella":["rain","weather"],"video-off":["camera","movie","film"],"video":["camera","movie","film"],"voicemail":["phone"],"volume":["music","sound","mute"],"volume-1":["music","sound"],"volume-2":["music","sound"],"volume-x":["music","sound","mute"],"watch":["clock","time"],"wind":["weather","air"],"x-circle":["cancel","close","delete","remove","times"],"x-octagon":["delete","stop","alert","warning","times"],"x-square":["cancel","close","delete","remove","times"],"x":["cancel","close","delete","remove","times"],"youtube":["logo","video","play"],"zap-off":["flash","camera","lightning"],"zap":["flash","camera","lightning"]};
|
|
|
|
/***/ }),
|
|
|
|
/***/ "./src/to-svg.js":
|
|
/*!***********************!*\
|
|
!*** ./src/to-svg.js ***!
|
|
\***********************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
|
|
var _icons = __webpack_require__(/*! ./icons */ "./src/icons.js");
|
|
|
|
var _icons2 = _interopRequireDefault(_icons);
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
|
|
|
|
/**
|
|
* Create an SVG string.
|
|
* @deprecated
|
|
* @param {string} name
|
|
* @param {Object} attrs
|
|
* @returns {string}
|
|
*/
|
|
function toSvg(name) {
|
|
var attrs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
|
|
|
|
console.warn('feather.toSvg() is deprecated. Please use feather.icons[name].toSvg() instead.');
|
|
|
|
if (!name) {
|
|
throw new Error('The required `key` (icon name) parameter is missing.');
|
|
}
|
|
|
|
if (!_icons2.default[name]) {
|
|
throw new Error('No icon matching \'' + name + '\'. See the complete list of icons at https://feathericons.com');
|
|
}
|
|
|
|
return _icons2.default[name].toSvg(attrs);
|
|
}
|
|
|
|
exports.default = toSvg;
|
|
|
|
/***/ }),
|
|
|
|
/***/ 0:
|
|
/*!**************************************************!*\
|
|
!*** multi core-js/es/array/from ./src/index.js ***!
|
|
\**************************************************/
|
|
/*! no static exports found */
|
|
/***/ (function(module, exports, __webpack_require__) {
|
|
|
|
__webpack_require__(/*! core-js/es/array/from */"./node_modules/core-js/es/array/from.js");
|
|
module.exports = __webpack_require__(/*! /home/travis/build/feathericons/feather/src/index.js */"./src/index.js");
|
|
|
|
|
|
/***/ })
|
|
|
|
/******/ });
|
|
});
|
|
|
|
});
|
|
|
|
var feather$1 = unwrapExports(feather);
|
|
|
|
var getIcon = icon => feather$1.toSvg(icon);
|
|
|
|
/* src\nav\NavItem.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$3 = "src\\nav\\NavItem.svelte";
|
|
|
|
function create_fragment$2(ctx) {
|
|
var div3, div2, div1, div0, raw_value = getIcon(ctx.icon), dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
div3 = element("div");
|
|
div2 = element("div");
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
attr(div0, "class", "icon svelte-td9xyr");
|
|
add_location(div0, file$3, 24, 12, 485);
|
|
attr(div1, "class", "inner svelte-td9xyr");
|
|
add_location(div1, file$3, 23, 8, 452);
|
|
attr(div2, "class", "nav-item svelte-td9xyr");
|
|
add_location(div2, file$3, 21, 4, 389);
|
|
attr(div3, "class", "" + ctx.navActive + " svelte-td9xyr");
|
|
add_location(div3, file$3, 20, 0, 358);
|
|
dispose = listen(div2, "click", ctx.setActive);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div3, anchor);
|
|
append(div3, div2);
|
|
append(div2, div1);
|
|
append(div1, div0);
|
|
div0.innerHTML = raw_value;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.icon) && raw_value !== (raw_value = getIcon(ctx.icon))) {
|
|
div0.innerHTML = raw_value;
|
|
}
|
|
|
|
if (changed.navActive) {
|
|
attr(div3, "class", "" + ctx.navActive + " svelte-td9xyr");
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div3);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$2($$self, $$props, $$invalidate) {
|
|
|
|
|
|
let { name = "", label = "", icon = "" } = $$props;
|
|
|
|
let navActive = "";
|
|
|
|
database.subscribe(db => {
|
|
$$invalidate('navActive', navActive = (db.activeNav === name ? "active" : ""));
|
|
});
|
|
|
|
const setActive = () =>
|
|
database.setActiveNav(name);
|
|
|
|
const writable_props = ['name', 'label', 'icon'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<NavItem> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
$$self.$set = $$props => {
|
|
if ('name' in $$props) $$invalidate('name', name = $$props.name);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
if ('icon' in $$props) $$invalidate('icon', icon = $$props.icon);
|
|
};
|
|
|
|
return { name, label, icon, navActive, setActive };
|
|
}
|
|
|
|
class NavItem extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$2, create_fragment$2, safe_not_equal, ["name", "label", "icon"]);
|
|
}
|
|
|
|
get name() {
|
|
throw new Error("<NavItem>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set name(value) {
|
|
throw new Error("<NavItem>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<NavItem>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<NavItem>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get icon() {
|
|
throw new Error("<NavItem>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set icon(value) {
|
|
throw new Error("<NavItem>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\nav\Nav.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$4 = "src\\nav\\Nav.svelte";
|
|
|
|
function create_fragment$3(ctx) {
|
|
var nav, img, t0, t1, t2, t3, t4, current;
|
|
|
|
var navitem0 = new NavItem({
|
|
props: {
|
|
name: "database",
|
|
label: "Database",
|
|
icon: "database"
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
var navitem1 = new NavItem({
|
|
props: {
|
|
name: "actions",
|
|
label: "Actions",
|
|
icon: "zap"
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
var navitem2 = new NavItem({
|
|
props: {
|
|
name: "access levels",
|
|
label: "Access Levels",
|
|
icon: "user"
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
var navitem3 = new NavItem({
|
|
props: {
|
|
name: "user interface",
|
|
label: "User Interface",
|
|
icon: "monitor"
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
var navitem4 = new NavItem({
|
|
props: {
|
|
name: "package",
|
|
label: "Package",
|
|
icon: "package"
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
nav = element("nav");
|
|
img = element("img");
|
|
t0 = space();
|
|
navitem0.$$.fragment.c();
|
|
t1 = space();
|
|
navitem1.$$.fragment.c();
|
|
t2 = space();
|
|
navitem2.$$.fragment.c();
|
|
t3 = space();
|
|
navitem3.$$.fragment.c();
|
|
t4 = space();
|
|
navitem4.$$.fragment.c();
|
|
attr(img, "src", "/_builder/assets/budibase-logo-only.png");
|
|
attr(img, "class", "logo svelte-n1ql72");
|
|
attr(img, "alt", "budibase logo");
|
|
add_location(img, file$4, 10, 4, 145);
|
|
attr(nav, "class", "nav svelte-n1ql72");
|
|
set_style(nav, "width", ctx.width);
|
|
add_location(nav, file$4, 8, 0, 92);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, nav, anchor);
|
|
append(nav, img);
|
|
append(nav, t0);
|
|
mount_component(navitem0, nav, null);
|
|
append(nav, t1);
|
|
mount_component(navitem1, nav, null);
|
|
append(nav, t2);
|
|
mount_component(navitem2, nav, null);
|
|
append(nav, t3);
|
|
mount_component(navitem3, nav, null);
|
|
append(nav, t4);
|
|
mount_component(navitem4, nav, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (!current || changed.width) {
|
|
set_style(nav, "width", ctx.width);
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(navitem0.$$.fragment, local);
|
|
|
|
transition_in(navitem1.$$.fragment, local);
|
|
|
|
transition_in(navitem2.$$.fragment, local);
|
|
|
|
transition_in(navitem3.$$.fragment, local);
|
|
|
|
transition_in(navitem4.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(navitem0.$$.fragment, local);
|
|
transition_out(navitem1.$$.fragment, local);
|
|
transition_out(navitem2.$$.fragment, local);
|
|
transition_out(navitem3.$$.fragment, local);
|
|
transition_out(navitem4.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(nav);
|
|
}
|
|
|
|
destroy_component(navitem0);
|
|
|
|
destroy_component(navitem1);
|
|
|
|
destroy_component(navitem2);
|
|
|
|
destroy_component(navitem3);
|
|
|
|
destroy_component(navitem4);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$3($$self, $$props, $$invalidate) {
|
|
let { width=50 } = $$props;
|
|
|
|
const writable_props = ['width'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Nav> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
$$self.$set = $$props => {
|
|
if ('width' in $$props) $$invalidate('width', width = $$props.width);
|
|
};
|
|
|
|
return { width };
|
|
}
|
|
|
|
class Nav extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$3, create_fragment$3, safe_not_equal, ["width"]);
|
|
}
|
|
|
|
get width() {
|
|
throw new Error("<Nav>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set width(value) {
|
|
throw new Error("<Nav>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\database\HierarchyRow.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$5 = "src\\database\\HierarchyRow.svelte";
|
|
|
|
function get_each_context$1(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.child = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (14:4) {#if node.children}
|
|
function create_if_block(ctx) {
|
|
var each_1_anchor, current;
|
|
|
|
var each_value = ctx.node.children;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$1(get_each_context$1(ctx, each_value, i));
|
|
}
|
|
|
|
const out = i => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
|
|
each_1_anchor = empty();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(target, anchor);
|
|
}
|
|
|
|
insert(target, each_1_anchor, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.node || changed.level) {
|
|
each_value = ctx.node.children;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$1(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block$1(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(each_1_anchor.parentNode, each_1_anchor);
|
|
}
|
|
}
|
|
|
|
group_outros();
|
|
for (i = each_value.length; i < each_blocks.length; i += 1) out(i);
|
|
check_outros();
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
for (var i = 0; i < each_value.length; i += 1) transition_in(each_blocks[i]);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) transition_out(each_blocks[i]);
|
|
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
if (detaching) {
|
|
detach(each_1_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (15:4) {#each node.children as child}
|
|
function create_each_block$1(ctx) {
|
|
var current;
|
|
|
|
var hierarchyrow = new HierarchyRow({
|
|
props: { node: ctx.child, level: ctx.level+1 },
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
hierarchyrow.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(hierarchyrow, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var hierarchyrow_changes = {};
|
|
if (changed.node) hierarchyrow_changes.node = ctx.child;
|
|
if (changed.level) hierarchyrow_changes.level = ctx.level+1;
|
|
hierarchyrow.$set(hierarchyrow_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(hierarchyrow.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(hierarchyrow.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(hierarchyrow, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$4(ctx) {
|
|
var div1, div0, t0_value = ctx.node.name, t0, t1, current, dispose;
|
|
|
|
var if_block = (ctx.node.children) && create_if_block(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
if (if_block) if_block.c();
|
|
attr(div0, "class", "title svelte-1rctf7f");
|
|
set_style(div0, "padding-left", "" + (20 + (ctx.level * 20)) + "px");
|
|
add_location(div0, file$5, 10, 4, 170);
|
|
attr(div1, "class", "root svelte-1rctf7f");
|
|
add_location(div1, file$5, 9, 0, 146);
|
|
dispose = listen(div0, "click", ctx.click_handler);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
append(div0, t0);
|
|
append(div1, t1);
|
|
if (if_block) if_block.m(div1, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((!current || changed.node) && t0_value !== (t0_value = ctx.node.name)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if (!current || changed.level) {
|
|
set_style(div0, "padding-left", "" + (20 + (ctx.level * 20)) + "px");
|
|
}
|
|
|
|
if (ctx.node.children) {
|
|
if (if_block) {
|
|
if_block.p(changed, ctx);
|
|
transition_in(if_block, 1);
|
|
} else {
|
|
if_block = create_if_block(ctx);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(div1, null);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
if (if_block) if_block.d();
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$4($$self, $$props, $$invalidate) {
|
|
|
|
let { level = 0, node } = $$props;
|
|
|
|
const writable_props = ['level', 'node'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<HierarchyRow> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function click_handler() {
|
|
return database.selectExistingNode(node.nodeId);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('level' in $$props) $$invalidate('level', level = $$props.level);
|
|
if ('node' in $$props) $$invalidate('node', node = $$props.node);
|
|
};
|
|
|
|
return { level, node, click_handler };
|
|
}
|
|
|
|
class HierarchyRow extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$4, create_fragment$4, safe_not_equal, ["level", "node"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.node === undefined && !('node' in props)) {
|
|
console.warn("<HierarchyRow> was created without expected prop 'node'");
|
|
}
|
|
}
|
|
|
|
get level() {
|
|
throw new Error("<HierarchyRow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set level(value) {
|
|
throw new Error("<HierarchyRow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get node() {
|
|
throw new Error("<HierarchyRow>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set node(value) {
|
|
throw new Error("<HierarchyRow>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\Textbox.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$6 = "src\\common\\Textbox.svelte";
|
|
|
|
function create_fragment$5(ctx) {
|
|
var div1, div0, t0, t1, input, dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(ctx.label);
|
|
t1 = space();
|
|
input = element("input");
|
|
attr(div0, "class", "label svelte-umifqh");
|
|
add_location(div0, file$6, 6, 4, 99);
|
|
attr(input, "class", "control uk-input svelte-umifqh");
|
|
add_location(input, file$6, 7, 4, 137);
|
|
attr(div1, "class", "container svelte-umifqh");
|
|
add_location(div1, file$6, 5, 0, 70);
|
|
dispose = listen(input, "input", ctx.input_input_handler);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
append(div0, t0);
|
|
append(div1, t1);
|
|
append(div1, input);
|
|
|
|
input.value = ctx.text;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.label) {
|
|
set_data(t0, ctx.label);
|
|
}
|
|
|
|
if (changed.text && (input.value !== ctx.text)) input.value = ctx.text;
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$5($$self, $$props, $$invalidate) {
|
|
let { text = "", label = "" } = $$props;
|
|
|
|
const writable_props = ['text', 'label'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Textbox> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function input_input_handler() {
|
|
text = this.value;
|
|
$$invalidate('text', text);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('text' in $$props) $$invalidate('text', text = $$props.text);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
};
|
|
|
|
return { text, label, input_input_handler };
|
|
}
|
|
|
|
class Textbox extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$5, create_fragment$5, safe_not_equal, ["text", "label"]);
|
|
}
|
|
|
|
get text() {
|
|
throw new Error("<Textbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set text(value) {
|
|
throw new Error("<Textbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<Textbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<Textbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\Dropdown.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$7 = "src\\common\\Dropdown.svelte";
|
|
|
|
function get_each_context_1(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.option = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
function get_each_context$2(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.option = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (27:4) {:else}
|
|
function create_else_block(ctx) {
|
|
var select, dispose;
|
|
|
|
var each_value_1 = ctx.options;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value_1.length; i += 1) {
|
|
each_blocks[i] = create_each_block_1(get_each_context_1(ctx, each_value_1, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
select = element("select");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
if (ctx.selected === void 0) add_render_callback(() => ctx.select_change_handler_1.call(select));
|
|
attr(select, "class", "control uk-select svelte-bm0783");
|
|
add_location(select, file$7, 28, 4, 641);
|
|
|
|
dispose = [
|
|
listen(select, "change", ctx.select_change_handler_1),
|
|
listen(select, "change", ctx.change_handler_1)
|
|
];
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, select, anchor);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(select, null);
|
|
}
|
|
|
|
select_option(select, ctx.selected);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.valueMember || changed.options || changed.textMember) {
|
|
each_value_1 = ctx.options;
|
|
|
|
for (var i = 0; i < each_value_1.length; i += 1) {
|
|
const child_ctx = get_each_context_1(ctx, each_value_1, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block_1(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(select, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value_1.length;
|
|
}
|
|
|
|
if (changed.selected) select_option(select, ctx.selected);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(select);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (19:4) {#if multiple}
|
|
function create_if_block$1(ctx) {
|
|
var select, dispose;
|
|
|
|
var each_value = ctx.options;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$2(get_each_context$2(ctx, each_value, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
select = element("select");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
if (ctx.selected === void 0) add_render_callback(() => ctx.select_change_handler.call(select));
|
|
attr(select, "class", "control uk-select svelte-bm0783");
|
|
select.multiple = true;
|
|
add_location(select, file$7, 20, 4, 354);
|
|
|
|
dispose = [
|
|
listen(select, "change", ctx.select_change_handler),
|
|
listen(select, "change", ctx.change_handler)
|
|
];
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, select, anchor);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(select, null);
|
|
}
|
|
|
|
select_options(select, ctx.selected);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.valueMember || changed.options || changed.textMember) {
|
|
each_value = ctx.options;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$2(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$2(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(select, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
|
|
if (changed.selected) select_options(select, ctx.selected);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(select);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (30:8) {#each options as option}
|
|
function create_each_block_1(ctx) {
|
|
var option, t_value = !ctx.textMember ? ctx.option : ctx.textMember(ctx.option), t, option_value_value;
|
|
|
|
return {
|
|
c: function create() {
|
|
option = element("option");
|
|
t = text(t_value);
|
|
option.__value = option_value_value = !ctx.valueMember ? ctx.option : ctx.valueMember(ctx.option);
|
|
option.value = option.__value;
|
|
add_location(option, file$7, 30, 8, 752);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, option, anchor);
|
|
append(option, t);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.textMember || changed.options) && t_value !== (t_value = !ctx.textMember ? ctx.option : ctx.textMember(ctx.option))) {
|
|
set_data(t, t_value);
|
|
}
|
|
|
|
if ((changed.valueMember || changed.options) && option_value_value !== (option_value_value = !ctx.valueMember ? ctx.option : ctx.valueMember(ctx.option))) {
|
|
option.__value = option_value_value;
|
|
}
|
|
|
|
option.value = option.__value;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(option);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (22:8) {#each options as option}
|
|
function create_each_block$2(ctx) {
|
|
var option, t_value = !ctx.textMember ? ctx.option : ctx.textMember(ctx.option), t, option_value_value;
|
|
|
|
return {
|
|
c: function create() {
|
|
option = element("option");
|
|
t = text(t_value);
|
|
option.__value = option_value_value = !ctx.valueMember ? ctx.option : ctx.valueMember(ctx.option);
|
|
option.value = option.__value;
|
|
add_location(option, file$7, 22, 8, 474);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, option, anchor);
|
|
append(option, t);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.textMember || changed.options) && t_value !== (t_value = !ctx.textMember ? ctx.option : ctx.textMember(ctx.option))) {
|
|
set_data(t, t_value);
|
|
}
|
|
|
|
if ((changed.valueMember || changed.options) && option_value_value !== (option_value_value = !ctx.valueMember ? ctx.option : ctx.valueMember(ctx.option))) {
|
|
option.__value = option_value_value;
|
|
}
|
|
|
|
option.value = option.__value;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(option);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$6(ctx) {
|
|
var div1, div0, t0, t1;
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.multiple) return create_if_block$1;
|
|
return create_else_block;
|
|
}
|
|
|
|
var current_block_type = select_block_type(ctx);
|
|
var if_block = current_block_type(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(ctx.label);
|
|
t1 = space();
|
|
if_block.c();
|
|
attr(div0, "class", "label svelte-bm0783");
|
|
add_location(div0, file$7, 16, 4, 288);
|
|
attr(div1, "class", "container svelte-bm0783");
|
|
add_location(div1, file$7, 15, 0, 259);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
append(div0, t0);
|
|
append(div1, t1);
|
|
if_block.m(div1, null);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.label) {
|
|
set_data(t0, ctx.label);
|
|
}
|
|
|
|
if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
|
|
if_block.p(changed, ctx);
|
|
} else {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(div1, null);
|
|
}
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
if_block.d();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$6($$self, $$props, $$invalidate) {
|
|
let { selected, label, options, valueMember, textMember, multiple=false } = $$props;
|
|
|
|
const writable_props = ['selected', 'label', 'options', 'valueMember', 'textMember', 'multiple'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Dropdown> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function change_handler(event) {
|
|
bubble($$self, event);
|
|
}
|
|
|
|
function change_handler_1(event) {
|
|
bubble($$self, event);
|
|
}
|
|
|
|
function select_change_handler() {
|
|
selected = select_multiple_value(this);
|
|
$$invalidate('selected', selected);
|
|
$$invalidate('valueMember', valueMember);
|
|
$$invalidate('options', options);
|
|
}
|
|
|
|
function select_change_handler_1() {
|
|
selected = select_value(this);
|
|
$$invalidate('selected', selected);
|
|
$$invalidate('valueMember', valueMember);
|
|
$$invalidate('options', options);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('selected' in $$props) $$invalidate('selected', selected = $$props.selected);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
if ('options' in $$props) $$invalidate('options', options = $$props.options);
|
|
if ('valueMember' in $$props) $$invalidate('valueMember', valueMember = $$props.valueMember);
|
|
if ('textMember' in $$props) $$invalidate('textMember', textMember = $$props.textMember);
|
|
if ('multiple' in $$props) $$invalidate('multiple', multiple = $$props.multiple);
|
|
};
|
|
|
|
return {
|
|
selected,
|
|
label,
|
|
options,
|
|
valueMember,
|
|
textMember,
|
|
multiple,
|
|
change_handler,
|
|
change_handler_1,
|
|
select_change_handler,
|
|
select_change_handler_1
|
|
};
|
|
}
|
|
|
|
class Dropdown extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$6, create_fragment$6, safe_not_equal, ["selected", "label", "options", "valueMember", "textMember", "multiple"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.selected === undefined && !('selected' in props)) {
|
|
console.warn("<Dropdown> was created without expected prop 'selected'");
|
|
}
|
|
if (ctx.label === undefined && !('label' in props)) {
|
|
console.warn("<Dropdown> was created without expected prop 'label'");
|
|
}
|
|
if (ctx.options === undefined && !('options' in props)) {
|
|
console.warn("<Dropdown> was created without expected prop 'options'");
|
|
}
|
|
if (ctx.valueMember === undefined && !('valueMember' in props)) {
|
|
console.warn("<Dropdown> was created without expected prop 'valueMember'");
|
|
}
|
|
if (ctx.textMember === undefined && !('textMember' in props)) {
|
|
console.warn("<Dropdown> was created without expected prop 'textMember'");
|
|
}
|
|
}
|
|
|
|
get selected() {
|
|
throw new Error("<Dropdown>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set selected(value) {
|
|
throw new Error("<Dropdown>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<Dropdown>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<Dropdown>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get options() {
|
|
throw new Error("<Dropdown>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set options(value) {
|
|
throw new Error("<Dropdown>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get valueMember() {
|
|
throw new Error("<Dropdown>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set valueMember(value) {
|
|
throw new Error("<Dropdown>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get textMember() {
|
|
throw new Error("<Dropdown>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set textMember(value) {
|
|
throw new Error("<Dropdown>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get multiple() {
|
|
throw new Error("<Dropdown>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set multiple(value) {
|
|
throw new Error("<Dropdown>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\ButtonGroup.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$8 = "src\\common\\ButtonGroup.svelte";
|
|
|
|
function create_fragment$7(ctx) {
|
|
var div, current;
|
|
|
|
const default_slot_1 = ctx.$$slots.default;
|
|
const default_slot = create_slot(default_slot_1, ctx, null);
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
|
|
if (default_slot) default_slot.c();
|
|
|
|
attr(div, "class", "root svelte-d6wwkb");
|
|
attr(div, "style", ctx.style);
|
|
add_location(div, file$8, 4, 0, 45);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
if (default_slot) default_slot.l(div_nodes);
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
|
|
if (default_slot) {
|
|
default_slot.m(div, null);
|
|
}
|
|
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (default_slot && default_slot.p && changed.$$scope) {
|
|
default_slot.p(get_slot_changes(default_slot_1, ctx, changed, null), get_slot_context(default_slot_1, ctx, null));
|
|
}
|
|
|
|
if (!current || changed.style) {
|
|
attr(div, "style", ctx.style);
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
if (default_slot) default_slot.d(detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$7($$self, $$props, $$invalidate) {
|
|
let { style="" } = $$props;
|
|
|
|
const writable_props = ['style'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<ButtonGroup> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
let { $$slots = {}, $$scope } = $$props;
|
|
|
|
$$self.$set = $$props => {
|
|
if ('style' in $$props) $$invalidate('style', style = $$props.style);
|
|
if ('$$scope' in $$props) $$invalidate('$$scope', $$scope = $$props.$$scope);
|
|
};
|
|
|
|
return { style, $$slots, $$scope };
|
|
}
|
|
|
|
class ButtonGroup extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$7, create_fragment$7, safe_not_equal, ["style"]);
|
|
}
|
|
|
|
get style() {
|
|
throw new Error("<ButtonGroup>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set style(value) {
|
|
throw new Error("<ButtonGroup>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\NumberBox.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$9 = "src\\common\\NumberBox.svelte";
|
|
|
|
function create_fragment$8(ctx) {
|
|
var div1, div0, t0, t1, input, dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(ctx.label);
|
|
t1 = space();
|
|
input = element("input");
|
|
attr(div0, "class", "label svelte-umifqh");
|
|
add_location(div0, file$9, 20, 4, 333);
|
|
attr(input, "class", "control svelte-umifqh");
|
|
attr(input, "type", "text");
|
|
input.value = ctx.value;
|
|
add_location(input, file$9, 21, 4, 371);
|
|
attr(div1, "class", "container svelte-umifqh");
|
|
add_location(div1, file$9, 19, 0, 304);
|
|
dispose = listen(input, "change", ctx.inputChanged);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
append(div0, t0);
|
|
append(div1, t1);
|
|
append(div1, input);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.label) {
|
|
set_data(t0, ctx.label);
|
|
}
|
|
|
|
if (changed.value) {
|
|
input.value = ctx.value;
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$8($$self, $$props, $$invalidate) {
|
|
let { value, label } = $$props;
|
|
|
|
const inputChanged = ev => {
|
|
try {
|
|
$$invalidate('value', value = Number(ev.target.value));
|
|
} catch(_) {
|
|
$$invalidate('value', value = null);
|
|
}
|
|
};
|
|
|
|
let numberText = value === null || value === undefined
|
|
? "" : value.toString();
|
|
|
|
const writable_props = ['value', 'label'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<NumberBox> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
$$self.$set = $$props => {
|
|
if ('value' in $$props) $$invalidate('value', value = $$props.value);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
};
|
|
|
|
return { value, label, inputChanged };
|
|
}
|
|
|
|
class NumberBox extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$8, create_fragment$8, safe_not_equal, ["value", "label"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.value === undefined && !('value' in props)) {
|
|
console.warn("<NumberBox> was created without expected prop 'value'");
|
|
}
|
|
if (ctx.label === undefined && !('label' in props)) {
|
|
console.warn("<NumberBox> was created without expected prop 'label'");
|
|
}
|
|
}
|
|
|
|
get value() {
|
|
throw new Error("<NumberBox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set value(value) {
|
|
throw new Error("<NumberBox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<NumberBox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<NumberBox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\ValuesList.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$a = "src\\common\\ValuesList.svelte";
|
|
|
|
function create_fragment$9(ctx) {
|
|
var div1, div0, t0, t1, textarea, dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(ctx.label);
|
|
t1 = space();
|
|
textarea = element("textarea");
|
|
attr(div0, "class", "label svelte-85b8gk");
|
|
add_location(div0, file$a, 20, 4, 309);
|
|
attr(textarea, "class", "control svelte-85b8gk");
|
|
textarea.value = ctx.valuesText;
|
|
add_location(textarea, file$a, 21, 4, 347);
|
|
attr(div1, "class", "container svelte-85b8gk");
|
|
add_location(div1, file$a, 19, 0, 280);
|
|
dispose = listen(textarea, "change", ctx.inputChanged);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
append(div0, t0);
|
|
append(div1, t1);
|
|
append(div1, textarea);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.label) {
|
|
set_data(t0, ctx.label);
|
|
}
|
|
|
|
if (changed.valuesText) {
|
|
textarea.value = ctx.valuesText;
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$9($$self, $$props, $$invalidate) {
|
|
let { values, label } = $$props;
|
|
|
|
const inputChanged = ev => {
|
|
try {
|
|
$$invalidate('values', values = ev.target.value.split("\n"));
|
|
} catch(_) {
|
|
$$invalidate('values', values = []);
|
|
}
|
|
};
|
|
|
|
const writable_props = ['values', 'label'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<ValuesList> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
$$self.$set = $$props => {
|
|
if ('values' in $$props) $$invalidate('values', values = $$props.values);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
};
|
|
|
|
let valuesText;
|
|
|
|
$$self.$$.update = ($$dirty = { values: 1 }) => {
|
|
if ($$dirty.values) { $$invalidate('valuesText', valuesText = fp.join("\n")(values)); }
|
|
};
|
|
|
|
return { values, label, inputChanged, valuesText };
|
|
}
|
|
|
|
class ValuesList extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$9, create_fragment$9, safe_not_equal, ["values", "label"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.values === undefined && !('values' in props)) {
|
|
console.warn("<ValuesList> was created without expected prop 'values'");
|
|
}
|
|
if (ctx.label === undefined && !('label' in props)) {
|
|
console.warn("<ValuesList> was created without expected prop 'label'");
|
|
}
|
|
}
|
|
|
|
get values() {
|
|
throw new Error("<ValuesList>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set values(value) {
|
|
throw new Error("<ValuesList>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<ValuesList>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<ValuesList>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\ErrorsBox.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$b = "src\\common\\ErrorsBox.svelte";
|
|
|
|
function get_each_context$3(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.error = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (7:0) {#if hasErrors}
|
|
function create_if_block$2(ctx) {
|
|
var div;
|
|
|
|
var each_value = ctx.errors;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$3(get_each_context$3(ctx, each_value, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(div, "class", "error-container svelte-jwy920");
|
|
add_location(div, file$b, 7, 0, 101);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.errors) {
|
|
each_value = ctx.errors;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$3(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$3(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (9:4) {#each errors as error}
|
|
function create_each_block$3(ctx) {
|
|
var div, t0_value = ctx.error.field ? `${ctx.error.field}: ` : "", t0, t1_value = ctx.error.error, t1;
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = text(t1_value);
|
|
attr(div, "class", "error-row svelte-jwy920");
|
|
add_location(div, file$b, 9, 4, 165);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, t0);
|
|
append(div, t1);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.errors) && t0_value !== (t0_value = ctx.error.field ? `${ctx.error.field}: ` : "")) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if ((changed.errors) && t1_value !== (t1_value = ctx.error.error)) {
|
|
set_data(t1, t1_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$a(ctx) {
|
|
var if_block_anchor;
|
|
|
|
var if_block = (ctx.hasErrors) && create_if_block$2(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
if (if_block) if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
if (if_block) if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (ctx.hasErrors) {
|
|
if (if_block) {
|
|
if_block.p(changed, ctx);
|
|
} else {
|
|
if_block = create_if_block$2(ctx);
|
|
if_block.c();
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (if_block) if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(if_block_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$a($$self, $$props, $$invalidate) {
|
|
let { errors = [] } = $$props;
|
|
|
|
const writable_props = ['errors'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<ErrorsBox> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
$$self.$set = $$props => {
|
|
if ('errors' in $$props) $$invalidate('errors', errors = $$props.errors);
|
|
};
|
|
|
|
let hasErrors;
|
|
|
|
$$self.$$.update = ($$dirty = { errors: 1 }) => {
|
|
if ($$dirty.errors) { $$invalidate('hasErrors', hasErrors = errors.length > 0); }
|
|
};
|
|
|
|
return { errors, hasErrors };
|
|
}
|
|
|
|
class ErrorsBox extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$a, create_fragment$a, safe_not_equal, ["errors"]);
|
|
}
|
|
|
|
get errors() {
|
|
throw new Error("<ErrorsBox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set errors(value) {
|
|
throw new Error("<ErrorsBox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\Checkbox.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$c = "src\\common\\Checkbox.svelte";
|
|
|
|
function create_fragment$b(ctx) {
|
|
var input, t, dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
input = element("input");
|
|
t = text(ctx.label);
|
|
attr(input, "class", "uk-checkbox svelte-66516k");
|
|
attr(input, "type", "checkbox");
|
|
add_location(input, file$c, 7, 0, 76);
|
|
|
|
dispose = [
|
|
listen(input, "change", ctx.input_change_handler),
|
|
listen(input, "change", ctx.change_handler)
|
|
];
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, input, anchor);
|
|
|
|
input.checked = ctx.checked;
|
|
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.checked) input.checked = ctx.checked;
|
|
|
|
if (changed.label) {
|
|
set_data(t, ctx.label);
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(input);
|
|
detach(t);
|
|
}
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$b($$self, $$props, $$invalidate) {
|
|
let { checked=false, label="" } = $$props;
|
|
|
|
const writable_props = ['checked', 'label'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Checkbox> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function change_handler(event) {
|
|
bubble($$self, event);
|
|
}
|
|
|
|
function input_change_handler() {
|
|
checked = this.checked;
|
|
$$invalidate('checked', checked);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('checked' in $$props) $$invalidate('checked', checked = $$props.checked);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
};
|
|
|
|
return {
|
|
checked,
|
|
label,
|
|
change_handler,
|
|
input_change_handler
|
|
};
|
|
}
|
|
|
|
class Checkbox extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$b, create_fragment$b, safe_not_equal, ["checked", "label"]);
|
|
}
|
|
|
|
get checked() {
|
|
throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set checked(value) {
|
|
throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<Checkbox>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<Checkbox>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
var flatpickr = createCommonjsModule(function (module, exports) {
|
|
/* flatpickr v4.6.2, @license MIT */
|
|
(function (global, factory) {
|
|
module.exports = factory() ;
|
|
}(commonjsGlobal, function () {
|
|
/*! *****************************************************************************
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
Licensed 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
|
|
|
|
THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
|
|
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
|
|
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
|
|
MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
|
|
See the Apache Version 2.0 License for specific language governing permissions
|
|
and limitations under the License.
|
|
***************************************************************************** */
|
|
|
|
var __assign = function() {
|
|
__assign = Object.assign || function __assign(t) {
|
|
for (var s, i = 1, n = arguments.length; i < n; i++) {
|
|
s = arguments[i];
|
|
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
|
|
}
|
|
return t;
|
|
};
|
|
return __assign.apply(this, arguments);
|
|
};
|
|
|
|
var HOOKS = [
|
|
"onChange",
|
|
"onClose",
|
|
"onDayCreate",
|
|
"onDestroy",
|
|
"onKeyDown",
|
|
"onMonthChange",
|
|
"onOpen",
|
|
"onParseConfig",
|
|
"onReady",
|
|
"onValueUpdate",
|
|
"onYearChange",
|
|
"onPreCalendarPosition",
|
|
];
|
|
var defaults = {
|
|
_disable: [],
|
|
_enable: [],
|
|
allowInput: false,
|
|
altFormat: "F j, Y",
|
|
altInput: false,
|
|
altInputClass: "form-control input",
|
|
animate: typeof window === "object" &&
|
|
window.navigator.userAgent.indexOf("MSIE") === -1,
|
|
ariaDateFormat: "F j, Y",
|
|
clickOpens: true,
|
|
closeOnSelect: true,
|
|
conjunction: ", ",
|
|
dateFormat: "Y-m-d",
|
|
defaultHour: 12,
|
|
defaultMinute: 0,
|
|
defaultSeconds: 0,
|
|
disable: [],
|
|
disableMobile: false,
|
|
enable: [],
|
|
enableSeconds: false,
|
|
enableTime: false,
|
|
errorHandler: function (err) {
|
|
return typeof console !== "undefined" && console.warn(err);
|
|
},
|
|
getWeek: function (givenDate) {
|
|
var date = new Date(givenDate.getTime());
|
|
date.setHours(0, 0, 0, 0);
|
|
// Thursday in current week decides the year.
|
|
date.setDate(date.getDate() + 3 - ((date.getDay() + 6) % 7));
|
|
// January 4 is always in week 1.
|
|
var week1 = new Date(date.getFullYear(), 0, 4);
|
|
// Adjust to Thursday in week 1 and count number of weeks from date to week1.
|
|
return (1 +
|
|
Math.round(((date.getTime() - week1.getTime()) / 86400000 -
|
|
3 +
|
|
((week1.getDay() + 6) % 7)) /
|
|
7));
|
|
},
|
|
hourIncrement: 1,
|
|
ignoredFocusElements: [],
|
|
inline: false,
|
|
locale: "default",
|
|
minuteIncrement: 5,
|
|
mode: "single",
|
|
monthSelectorType: "dropdown",
|
|
nextArrow: "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewBox='0 0 17 17'><g></g><path d='M13.207 8.472l-7.854 7.854-0.707-0.707 7.146-7.146-7.146-7.148 0.707-0.707 7.854 7.854z' /></svg>",
|
|
noCalendar: false,
|
|
now: new Date(),
|
|
onChange: [],
|
|
onClose: [],
|
|
onDayCreate: [],
|
|
onDestroy: [],
|
|
onKeyDown: [],
|
|
onMonthChange: [],
|
|
onOpen: [],
|
|
onParseConfig: [],
|
|
onReady: [],
|
|
onValueUpdate: [],
|
|
onYearChange: [],
|
|
onPreCalendarPosition: [],
|
|
plugins: [],
|
|
position: "auto",
|
|
positionElement: undefined,
|
|
prevArrow: "<svg version='1.1' xmlns='http://www.w3.org/2000/svg' xmlns:xlink='http://www.w3.org/1999/xlink' viewBox='0 0 17 17'><g></g><path d='M5.207 8.471l7.146 7.147-0.707 0.707-7.853-7.854 7.854-7.853 0.707 0.707-7.147 7.146z' /></svg>",
|
|
shorthandCurrentMonth: false,
|
|
showMonths: 1,
|
|
static: false,
|
|
time_24hr: false,
|
|
weekNumbers: false,
|
|
wrap: false
|
|
};
|
|
|
|
var english = {
|
|
weekdays: {
|
|
shorthand: ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"],
|
|
longhand: [
|
|
"Sunday",
|
|
"Monday",
|
|
"Tuesday",
|
|
"Wednesday",
|
|
"Thursday",
|
|
"Friday",
|
|
"Saturday",
|
|
]
|
|
},
|
|
months: {
|
|
shorthand: [
|
|
"Jan",
|
|
"Feb",
|
|
"Mar",
|
|
"Apr",
|
|
"May",
|
|
"Jun",
|
|
"Jul",
|
|
"Aug",
|
|
"Sep",
|
|
"Oct",
|
|
"Nov",
|
|
"Dec",
|
|
],
|
|
longhand: [
|
|
"January",
|
|
"February",
|
|
"March",
|
|
"April",
|
|
"May",
|
|
"June",
|
|
"July",
|
|
"August",
|
|
"September",
|
|
"October",
|
|
"November",
|
|
"December",
|
|
]
|
|
},
|
|
daysInMonth: [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31],
|
|
firstDayOfWeek: 0,
|
|
ordinal: function (nth) {
|
|
var s = nth % 100;
|
|
if (s > 3 && s < 21)
|
|
return "th";
|
|
switch (s % 10) {
|
|
case 1:
|
|
return "st";
|
|
case 2:
|
|
return "nd";
|
|
case 3:
|
|
return "rd";
|
|
default:
|
|
return "th";
|
|
}
|
|
},
|
|
rangeSeparator: " to ",
|
|
weekAbbreviation: "Wk",
|
|
scrollTitle: "Scroll to increment",
|
|
toggleTitle: "Click to toggle",
|
|
amPM: ["AM", "PM"],
|
|
yearAriaLabel: "Year",
|
|
hourAriaLabel: "Hour",
|
|
minuteAriaLabel: "Minute",
|
|
time_24hr: false
|
|
};
|
|
|
|
var pad = function (number) { return ("0" + number).slice(-2); };
|
|
var int = function (bool) { return (bool === true ? 1 : 0); };
|
|
/* istanbul ignore next */
|
|
function debounce(func, wait, immediate) {
|
|
if (immediate === void 0) { immediate = false; }
|
|
var timeout;
|
|
return function () {
|
|
var context = this, args = arguments;
|
|
timeout !== null && clearTimeout(timeout);
|
|
timeout = window.setTimeout(function () {
|
|
timeout = null;
|
|
if (!immediate)
|
|
func.apply(context, args);
|
|
}, wait);
|
|
if (immediate && !timeout)
|
|
func.apply(context, args);
|
|
};
|
|
}
|
|
var arrayify = function (obj) {
|
|
return obj instanceof Array ? obj : [obj];
|
|
};
|
|
|
|
function toggleClass(elem, className, bool) {
|
|
if (bool === true)
|
|
return elem.classList.add(className);
|
|
elem.classList.remove(className);
|
|
}
|
|
function createElement(tag, className, content) {
|
|
var e = window.document.createElement(tag);
|
|
className = className || "";
|
|
content = content || "";
|
|
e.className = className;
|
|
if (content !== undefined)
|
|
e.textContent = content;
|
|
return e;
|
|
}
|
|
function clearNode(node) {
|
|
while (node.firstChild)
|
|
node.removeChild(node.firstChild);
|
|
}
|
|
function findParent(node, condition) {
|
|
if (condition(node))
|
|
return node;
|
|
else if (node.parentNode)
|
|
return findParent(node.parentNode, condition);
|
|
return undefined; // nothing found
|
|
}
|
|
function createNumberInput(inputClassName, opts) {
|
|
var wrapper = createElement("div", "numInputWrapper"), numInput = createElement("input", "numInput " + inputClassName), arrowUp = createElement("span", "arrowUp"), arrowDown = createElement("span", "arrowDown");
|
|
if (navigator.userAgent.indexOf("MSIE 9.0") === -1) {
|
|
numInput.type = "number";
|
|
}
|
|
else {
|
|
numInput.type = "text";
|
|
numInput.pattern = "\\d*";
|
|
}
|
|
if (opts !== undefined)
|
|
for (var key in opts)
|
|
numInput.setAttribute(key, opts[key]);
|
|
wrapper.appendChild(numInput);
|
|
wrapper.appendChild(arrowUp);
|
|
wrapper.appendChild(arrowDown);
|
|
return wrapper;
|
|
}
|
|
function getEventTarget(event) {
|
|
if (typeof event.composedPath === "function") {
|
|
var path = event.composedPath();
|
|
return path[0];
|
|
}
|
|
return event.target;
|
|
}
|
|
|
|
var doNothing = function () { return undefined; };
|
|
var monthToStr = function (monthNumber, shorthand, locale) { return locale.months[shorthand ? "shorthand" : "longhand"][monthNumber]; };
|
|
var revFormat = {
|
|
D: doNothing,
|
|
F: function (dateObj, monthName, locale) {
|
|
dateObj.setMonth(locale.months.longhand.indexOf(monthName));
|
|
},
|
|
G: function (dateObj, hour) {
|
|
dateObj.setHours(parseFloat(hour));
|
|
},
|
|
H: function (dateObj, hour) {
|
|
dateObj.setHours(parseFloat(hour));
|
|
},
|
|
J: function (dateObj, day) {
|
|
dateObj.setDate(parseFloat(day));
|
|
},
|
|
K: function (dateObj, amPM, locale) {
|
|
dateObj.setHours((dateObj.getHours() % 12) +
|
|
12 * int(new RegExp(locale.amPM[1], "i").test(amPM)));
|
|
},
|
|
M: function (dateObj, shortMonth, locale) {
|
|
dateObj.setMonth(locale.months.shorthand.indexOf(shortMonth));
|
|
},
|
|
S: function (dateObj, seconds) {
|
|
dateObj.setSeconds(parseFloat(seconds));
|
|
},
|
|
U: function (_, unixSeconds) { return new Date(parseFloat(unixSeconds) * 1000); },
|
|
W: function (dateObj, weekNum, locale) {
|
|
var weekNumber = parseInt(weekNum);
|
|
var date = new Date(dateObj.getFullYear(), 0, 2 + (weekNumber - 1) * 7, 0, 0, 0, 0);
|
|
date.setDate(date.getDate() - date.getDay() + locale.firstDayOfWeek);
|
|
return date;
|
|
},
|
|
Y: function (dateObj, year) {
|
|
dateObj.setFullYear(parseFloat(year));
|
|
},
|
|
Z: function (_, ISODate) { return new Date(ISODate); },
|
|
d: function (dateObj, day) {
|
|
dateObj.setDate(parseFloat(day));
|
|
},
|
|
h: function (dateObj, hour) {
|
|
dateObj.setHours(parseFloat(hour));
|
|
},
|
|
i: function (dateObj, minutes) {
|
|
dateObj.setMinutes(parseFloat(minutes));
|
|
},
|
|
j: function (dateObj, day) {
|
|
dateObj.setDate(parseFloat(day));
|
|
},
|
|
l: doNothing,
|
|
m: function (dateObj, month) {
|
|
dateObj.setMonth(parseFloat(month) - 1);
|
|
},
|
|
n: function (dateObj, month) {
|
|
dateObj.setMonth(parseFloat(month) - 1);
|
|
},
|
|
s: function (dateObj, seconds) {
|
|
dateObj.setSeconds(parseFloat(seconds));
|
|
},
|
|
u: function (_, unixMillSeconds) {
|
|
return new Date(parseFloat(unixMillSeconds));
|
|
},
|
|
w: doNothing,
|
|
y: function (dateObj, year) {
|
|
dateObj.setFullYear(2000 + parseFloat(year));
|
|
}
|
|
};
|
|
var tokenRegex = {
|
|
D: "(\\w+)",
|
|
F: "(\\w+)",
|
|
G: "(\\d\\d|\\d)",
|
|
H: "(\\d\\d|\\d)",
|
|
J: "(\\d\\d|\\d)\\w+",
|
|
K: "",
|
|
M: "(\\w+)",
|
|
S: "(\\d\\d|\\d)",
|
|
U: "(.+)",
|
|
W: "(\\d\\d|\\d)",
|
|
Y: "(\\d{4})",
|
|
Z: "(.+)",
|
|
d: "(\\d\\d|\\d)",
|
|
h: "(\\d\\d|\\d)",
|
|
i: "(\\d\\d|\\d)",
|
|
j: "(\\d\\d|\\d)",
|
|
l: "(\\w+)",
|
|
m: "(\\d\\d|\\d)",
|
|
n: "(\\d\\d|\\d)",
|
|
s: "(\\d\\d|\\d)",
|
|
u: "(.+)",
|
|
w: "(\\d\\d|\\d)",
|
|
y: "(\\d{2})"
|
|
};
|
|
var formats = {
|
|
// get the date in UTC
|
|
Z: function (date) { return date.toISOString(); },
|
|
// weekday name, short, e.g. Thu
|
|
D: function (date, locale, options) {
|
|
return locale.weekdays.shorthand[formats.w(date, locale, options)];
|
|
},
|
|
// full month name e.g. January
|
|
F: function (date, locale, options) {
|
|
return monthToStr(formats.n(date, locale, options) - 1, false, locale);
|
|
},
|
|
// padded hour 1-12
|
|
G: function (date, locale, options) {
|
|
return pad(formats.h(date, locale, options));
|
|
},
|
|
// hours with leading zero e.g. 03
|
|
H: function (date) { return pad(date.getHours()); },
|
|
// day (1-30) with ordinal suffix e.g. 1st, 2nd
|
|
J: function (date, locale) {
|
|
return locale.ordinal !== undefined
|
|
? date.getDate() + locale.ordinal(date.getDate())
|
|
: date.getDate();
|
|
},
|
|
// AM/PM
|
|
K: function (date, locale) { return locale.amPM[int(date.getHours() > 11)]; },
|
|
// shorthand month e.g. Jan, Sep, Oct, etc
|
|
M: function (date, locale) {
|
|
return monthToStr(date.getMonth(), true, locale);
|
|
},
|
|
// seconds 00-59
|
|
S: function (date) { return pad(date.getSeconds()); },
|
|
// unix timestamp
|
|
U: function (date) { return date.getTime() / 1000; },
|
|
W: function (date, _, options) {
|
|
return options.getWeek(date);
|
|
},
|
|
// full year e.g. 2016
|
|
Y: function (date) { return date.getFullYear(); },
|
|
// day in month, padded (01-30)
|
|
d: function (date) { return pad(date.getDate()); },
|
|
// hour from 1-12 (am/pm)
|
|
h: function (date) { return (date.getHours() % 12 ? date.getHours() % 12 : 12); },
|
|
// minutes, padded with leading zero e.g. 09
|
|
i: function (date) { return pad(date.getMinutes()); },
|
|
// day in month (1-30)
|
|
j: function (date) { return date.getDate(); },
|
|
// weekday name, full, e.g. Thursday
|
|
l: function (date, locale) {
|
|
return locale.weekdays.longhand[date.getDay()];
|
|
},
|
|
// padded month number (01-12)
|
|
m: function (date) { return pad(date.getMonth() + 1); },
|
|
// the month number (1-12)
|
|
n: function (date) { return date.getMonth() + 1; },
|
|
// seconds 0-59
|
|
s: function (date) { return date.getSeconds(); },
|
|
// Unix Milliseconds
|
|
u: function (date) { return date.getTime(); },
|
|
// number of the day of the week
|
|
w: function (date) { return date.getDay(); },
|
|
// last two digits of year e.g. 16 for 2016
|
|
y: function (date) { return String(date.getFullYear()).substring(2); }
|
|
};
|
|
|
|
var createDateFormatter = function (_a) {
|
|
var _b = _a.config, config = _b === void 0 ? defaults : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c;
|
|
return function (dateObj, frmt, overrideLocale) {
|
|
var locale = overrideLocale || l10n;
|
|
if (config.formatDate !== undefined) {
|
|
return config.formatDate(dateObj, frmt, locale);
|
|
}
|
|
return frmt
|
|
.split("")
|
|
.map(function (c, i, arr) {
|
|
return formats[c] && arr[i - 1] !== "\\"
|
|
? formats[c](dateObj, locale, config)
|
|
: c !== "\\"
|
|
? c
|
|
: "";
|
|
})
|
|
.join("");
|
|
};
|
|
};
|
|
var createDateParser = function (_a) {
|
|
var _b = _a.config, config = _b === void 0 ? defaults : _b, _c = _a.l10n, l10n = _c === void 0 ? english : _c;
|
|
return function (date, givenFormat, timeless, customLocale) {
|
|
if (date !== 0 && !date)
|
|
return undefined;
|
|
var locale = customLocale || l10n;
|
|
var parsedDate;
|
|
var dateOrig = date;
|
|
if (date instanceof Date)
|
|
parsedDate = new Date(date.getTime());
|
|
else if (typeof date !== "string" &&
|
|
date.toFixed !== undefined // timestamp
|
|
)
|
|
// create a copy
|
|
parsedDate = new Date(date);
|
|
else if (typeof date === "string") {
|
|
// date string
|
|
var format = givenFormat || (config || defaults).dateFormat;
|
|
var datestr = String(date).trim();
|
|
if (datestr === "today") {
|
|
parsedDate = new Date();
|
|
timeless = true;
|
|
}
|
|
else if (/Z$/.test(datestr) ||
|
|
/GMT$/.test(datestr) // datestrings w/ timezone
|
|
)
|
|
parsedDate = new Date(date);
|
|
else if (config && config.parseDate)
|
|
parsedDate = config.parseDate(date, format);
|
|
else {
|
|
parsedDate =
|
|
!config || !config.noCalendar
|
|
? new Date(new Date().getFullYear(), 0, 1, 0, 0, 0, 0)
|
|
: new Date(new Date().setHours(0, 0, 0, 0));
|
|
var matched = void 0, ops = [];
|
|
for (var i = 0, matchIndex = 0, regexStr = ""; i < format.length; i++) {
|
|
var token_1 = format[i];
|
|
var isBackSlash = token_1 === "\\";
|
|
var escaped = format[i - 1] === "\\" || isBackSlash;
|
|
if (tokenRegex[token_1] && !escaped) {
|
|
regexStr += tokenRegex[token_1];
|
|
var match = new RegExp(regexStr).exec(date);
|
|
if (match && (matched = true)) {
|
|
ops[token_1 !== "Y" ? "push" : "unshift"]({
|
|
fn: revFormat[token_1],
|
|
val: match[++matchIndex]
|
|
});
|
|
}
|
|
}
|
|
else if (!isBackSlash)
|
|
regexStr += "."; // don't really care
|
|
ops.forEach(function (_a) {
|
|
var fn = _a.fn, val = _a.val;
|
|
return (parsedDate = fn(parsedDate, val, locale) || parsedDate);
|
|
});
|
|
}
|
|
parsedDate = matched ? parsedDate : undefined;
|
|
}
|
|
}
|
|
/* istanbul ignore next */
|
|
if (!(parsedDate instanceof Date && !isNaN(parsedDate.getTime()))) {
|
|
config.errorHandler(new Error("Invalid date provided: " + dateOrig));
|
|
return undefined;
|
|
}
|
|
if (timeless === true)
|
|
parsedDate.setHours(0, 0, 0, 0);
|
|
return parsedDate;
|
|
};
|
|
};
|
|
/**
|
|
* Compute the difference in dates, measured in ms
|
|
*/
|
|
function compareDates(date1, date2, timeless) {
|
|
if (timeless === void 0) { timeless = true; }
|
|
if (timeless !== false) {
|
|
return (new Date(date1.getTime()).setHours(0, 0, 0, 0) -
|
|
new Date(date2.getTime()).setHours(0, 0, 0, 0));
|
|
}
|
|
return date1.getTime() - date2.getTime();
|
|
}
|
|
var isBetween = function (ts, ts1, ts2) {
|
|
return ts > Math.min(ts1, ts2) && ts < Math.max(ts1, ts2);
|
|
};
|
|
var duration = {
|
|
DAY: 86400000
|
|
};
|
|
|
|
if (typeof Object.assign !== "function") {
|
|
Object.assign = function (target) {
|
|
var args = [];
|
|
for (var _i = 1; _i < arguments.length; _i++) {
|
|
args[_i - 1] = arguments[_i];
|
|
}
|
|
if (!target) {
|
|
throw TypeError("Cannot convert undefined or null to object");
|
|
}
|
|
var _loop_1 = function (source) {
|
|
if (source) {
|
|
Object.keys(source).forEach(function (key) { return (target[key] = source[key]); });
|
|
}
|
|
};
|
|
for (var _a = 0, args_1 = args; _a < args_1.length; _a++) {
|
|
var source = args_1[_a];
|
|
_loop_1(source);
|
|
}
|
|
return target;
|
|
};
|
|
}
|
|
|
|
var DEBOUNCED_CHANGE_MS = 300;
|
|
function FlatpickrInstance(element, instanceConfig) {
|
|
var self = {
|
|
config: __assign({}, defaults, flatpickr.defaultConfig),
|
|
l10n: english
|
|
};
|
|
self.parseDate = createDateParser({ config: self.config, l10n: self.l10n });
|
|
self._handlers = [];
|
|
self.pluginElements = [];
|
|
self.loadedPlugins = [];
|
|
self._bind = bind;
|
|
self._setHoursFromDate = setHoursFromDate;
|
|
self._positionCalendar = positionCalendar;
|
|
self.changeMonth = changeMonth;
|
|
self.changeYear = changeYear;
|
|
self.clear = clear;
|
|
self.close = close;
|
|
self._createElement = createElement;
|
|
self.destroy = destroy;
|
|
self.isEnabled = isEnabled;
|
|
self.jumpToDate = jumpToDate;
|
|
self.open = open;
|
|
self.redraw = redraw;
|
|
self.set = set;
|
|
self.setDate = setDate;
|
|
self.toggle = toggle;
|
|
function setupHelperFunctions() {
|
|
self.utils = {
|
|
getDaysInMonth: function (month, yr) {
|
|
if (month === void 0) { month = self.currentMonth; }
|
|
if (yr === void 0) { yr = self.currentYear; }
|
|
if (month === 1 && ((yr % 4 === 0 && yr % 100 !== 0) || yr % 400 === 0))
|
|
return 29;
|
|
return self.l10n.daysInMonth[month];
|
|
}
|
|
};
|
|
}
|
|
function init() {
|
|
self.element = self.input = element;
|
|
self.isOpen = false;
|
|
parseConfig();
|
|
setupLocale();
|
|
setupInputs();
|
|
setupDates();
|
|
setupHelperFunctions();
|
|
if (!self.isMobile)
|
|
build();
|
|
bindEvents();
|
|
if (self.selectedDates.length || self.config.noCalendar) {
|
|
if (self.config.enableTime) {
|
|
setHoursFromDate(self.config.noCalendar
|
|
? self.latestSelectedDateObj || self.config.minDate
|
|
: undefined);
|
|
}
|
|
updateValue(false);
|
|
}
|
|
setCalendarWidth();
|
|
self.showTimeInput =
|
|
self.selectedDates.length > 0 || self.config.noCalendar;
|
|
var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
|
|
/* TODO: investigate this further
|
|
|
|
Currently, there is weird positioning behavior in safari causing pages
|
|
to scroll up. https://github.com/chmln/flatpickr/issues/563
|
|
|
|
However, most browsers are not Safari and positioning is expensive when used
|
|
in scale. https://github.com/chmln/flatpickr/issues/1096
|
|
*/
|
|
if (!self.isMobile && isSafari) {
|
|
positionCalendar();
|
|
}
|
|
triggerEvent("onReady");
|
|
}
|
|
function bindToInstance(fn) {
|
|
return fn.bind(self);
|
|
}
|
|
function setCalendarWidth() {
|
|
var config = self.config;
|
|
if (config.weekNumbers === false && config.showMonths === 1)
|
|
return;
|
|
else if (config.noCalendar !== true) {
|
|
window.requestAnimationFrame(function () {
|
|
if (self.calendarContainer !== undefined) {
|
|
self.calendarContainer.style.visibility = "hidden";
|
|
self.calendarContainer.style.display = "block";
|
|
}
|
|
if (self.daysContainer !== undefined) {
|
|
var daysWidth = (self.days.offsetWidth + 1) * config.showMonths;
|
|
self.daysContainer.style.width = daysWidth + "px";
|
|
self.calendarContainer.style.width =
|
|
daysWidth +
|
|
(self.weekWrapper !== undefined
|
|
? self.weekWrapper.offsetWidth
|
|
: 0) +
|
|
"px";
|
|
self.calendarContainer.style.removeProperty("visibility");
|
|
self.calendarContainer.style.removeProperty("display");
|
|
}
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* The handler for all events targeting the time inputs
|
|
*/
|
|
function updateTime(e) {
|
|
if (self.selectedDates.length === 0) {
|
|
setDefaultTime();
|
|
}
|
|
if (e !== undefined && e.type !== "blur") {
|
|
timeWrapper(e);
|
|
}
|
|
var prevValue = self._input.value;
|
|
setHoursFromInputs();
|
|
updateValue();
|
|
if (self._input.value !== prevValue) {
|
|
self._debouncedChange();
|
|
}
|
|
}
|
|
function ampm2military(hour, amPM) {
|
|
return (hour % 12) + 12 * int(amPM === self.l10n.amPM[1]);
|
|
}
|
|
function military2ampm(hour) {
|
|
switch (hour % 24) {
|
|
case 0:
|
|
case 12:
|
|
return 12;
|
|
default:
|
|
return hour % 12;
|
|
}
|
|
}
|
|
/**
|
|
* Syncs the selected date object time with user's time input
|
|
*/
|
|
function setHoursFromInputs() {
|
|
if (self.hourElement === undefined || self.minuteElement === undefined)
|
|
return;
|
|
var hours = (parseInt(self.hourElement.value.slice(-2), 10) || 0) % 24, minutes = (parseInt(self.minuteElement.value, 10) || 0) % 60, seconds = self.secondElement !== undefined
|
|
? (parseInt(self.secondElement.value, 10) || 0) % 60
|
|
: 0;
|
|
if (self.amPM !== undefined) {
|
|
hours = ampm2military(hours, self.amPM.textContent);
|
|
}
|
|
var limitMinHours = self.config.minTime !== undefined ||
|
|
(self.config.minDate &&
|
|
self.minDateHasTime &&
|
|
self.latestSelectedDateObj &&
|
|
compareDates(self.latestSelectedDateObj, self.config.minDate, true) ===
|
|
0);
|
|
var limitMaxHours = self.config.maxTime !== undefined ||
|
|
(self.config.maxDate &&
|
|
self.maxDateHasTime &&
|
|
self.latestSelectedDateObj &&
|
|
compareDates(self.latestSelectedDateObj, self.config.maxDate, true) ===
|
|
0);
|
|
if (limitMaxHours) {
|
|
var maxTime = self.config.maxTime !== undefined
|
|
? self.config.maxTime
|
|
: self.config.maxDate;
|
|
hours = Math.min(hours, maxTime.getHours());
|
|
if (hours === maxTime.getHours())
|
|
minutes = Math.min(minutes, maxTime.getMinutes());
|
|
if (minutes === maxTime.getMinutes())
|
|
seconds = Math.min(seconds, maxTime.getSeconds());
|
|
}
|
|
if (limitMinHours) {
|
|
var minTime = self.config.minTime !== undefined
|
|
? self.config.minTime
|
|
: self.config.minDate;
|
|
hours = Math.max(hours, minTime.getHours());
|
|
if (hours === minTime.getHours())
|
|
minutes = Math.max(minutes, minTime.getMinutes());
|
|
if (minutes === minTime.getMinutes())
|
|
seconds = Math.max(seconds, minTime.getSeconds());
|
|
}
|
|
setHours(hours, minutes, seconds);
|
|
}
|
|
/**
|
|
* Syncs time input values with a date
|
|
*/
|
|
function setHoursFromDate(dateObj) {
|
|
var date = dateObj || self.latestSelectedDateObj;
|
|
if (date)
|
|
setHours(date.getHours(), date.getMinutes(), date.getSeconds());
|
|
}
|
|
function setDefaultHours() {
|
|
var hours = self.config.defaultHour;
|
|
var minutes = self.config.defaultMinute;
|
|
var seconds = self.config.defaultSeconds;
|
|
if (self.config.minDate !== undefined) {
|
|
var minHr = self.config.minDate.getHours();
|
|
var minMinutes = self.config.minDate.getMinutes();
|
|
hours = Math.max(hours, minHr);
|
|
if (hours === minHr)
|
|
minutes = Math.max(minMinutes, minutes);
|
|
if (hours === minHr && minutes === minMinutes)
|
|
seconds = self.config.minDate.getSeconds();
|
|
}
|
|
if (self.config.maxDate !== undefined) {
|
|
var maxHr = self.config.maxDate.getHours();
|
|
var maxMinutes = self.config.maxDate.getMinutes();
|
|
hours = Math.min(hours, maxHr);
|
|
if (hours === maxHr)
|
|
minutes = Math.min(maxMinutes, minutes);
|
|
if (hours === maxHr && minutes === maxMinutes)
|
|
seconds = self.config.maxDate.getSeconds();
|
|
}
|
|
setHours(hours, minutes, seconds);
|
|
}
|
|
/**
|
|
* Sets the hours, minutes, and optionally seconds
|
|
* of the latest selected date object and the
|
|
* corresponding time inputs
|
|
* @param {Number} hours the hour. whether its military
|
|
* or am-pm gets inferred from config
|
|
* @param {Number} minutes the minutes
|
|
* @param {Number} seconds the seconds (optional)
|
|
*/
|
|
function setHours(hours, minutes, seconds) {
|
|
if (self.latestSelectedDateObj !== undefined) {
|
|
self.latestSelectedDateObj.setHours(hours % 24, minutes, seconds || 0, 0);
|
|
}
|
|
if (!self.hourElement || !self.minuteElement || self.isMobile)
|
|
return;
|
|
self.hourElement.value = pad(!self.config.time_24hr
|
|
? ((12 + hours) % 12) + 12 * int(hours % 12 === 0)
|
|
: hours);
|
|
self.minuteElement.value = pad(minutes);
|
|
if (self.amPM !== undefined)
|
|
self.amPM.textContent = self.l10n.amPM[int(hours >= 12)];
|
|
if (self.secondElement !== undefined)
|
|
self.secondElement.value = pad(seconds);
|
|
}
|
|
/**
|
|
* Handles the year input and incrementing events
|
|
* @param {Event} event the keyup or increment event
|
|
*/
|
|
function onYearInput(event) {
|
|
var year = parseInt(event.target.value) + (event.delta || 0);
|
|
if (year / 1000 > 1 ||
|
|
(event.key === "Enter" && !/[^\d]/.test(year.toString()))) {
|
|
changeYear(year);
|
|
}
|
|
}
|
|
/**
|
|
* Essentially addEventListener + tracking
|
|
* @param {Element} element the element to addEventListener to
|
|
* @param {String} event the event name
|
|
* @param {Function} handler the event handler
|
|
*/
|
|
function bind(element, event, handler, options) {
|
|
if (event instanceof Array)
|
|
return event.forEach(function (ev) { return bind(element, ev, handler, options); });
|
|
if (element instanceof Array)
|
|
return element.forEach(function (el) { return bind(el, event, handler, options); });
|
|
element.addEventListener(event, handler, options);
|
|
self._handlers.push({
|
|
element: element,
|
|
event: event,
|
|
handler: handler,
|
|
options: options
|
|
});
|
|
}
|
|
/**
|
|
* A mousedown handler which mimics click.
|
|
* Minimizes latency, since we don't need to wait for mouseup in most cases.
|
|
* Also, avoids handling right clicks.
|
|
*
|
|
* @param {Function} handler the event handler
|
|
*/
|
|
function onClick(handler) {
|
|
return function (evt) {
|
|
evt.which === 1 && handler(evt);
|
|
};
|
|
}
|
|
function triggerChange() {
|
|
triggerEvent("onChange");
|
|
}
|
|
/**
|
|
* Adds all the necessary event listeners
|
|
*/
|
|
function bindEvents() {
|
|
if (self.config.wrap) {
|
|
["open", "close", "toggle", "clear"].forEach(function (evt) {
|
|
Array.prototype.forEach.call(self.element.querySelectorAll("[data-" + evt + "]"), function (el) {
|
|
return bind(el, "click", self[evt]);
|
|
});
|
|
});
|
|
}
|
|
if (self.isMobile) {
|
|
setupMobile();
|
|
return;
|
|
}
|
|
var debouncedResize = debounce(onResize, 50);
|
|
self._debouncedChange = debounce(triggerChange, DEBOUNCED_CHANGE_MS);
|
|
if (self.daysContainer && !/iPhone|iPad|iPod/i.test(navigator.userAgent))
|
|
bind(self.daysContainer, "mouseover", function (e) {
|
|
if (self.config.mode === "range")
|
|
onMouseOver(e.target);
|
|
});
|
|
bind(window.document.body, "keydown", onKeyDown);
|
|
if (!self.config.inline && !self.config.static)
|
|
bind(window, "resize", debouncedResize);
|
|
if (window.ontouchstart !== undefined)
|
|
bind(window.document, "touchstart", documentClick);
|
|
else
|
|
bind(window.document, "mousedown", onClick(documentClick));
|
|
bind(window.document, "focus", documentClick, { capture: true });
|
|
if (self.config.clickOpens === true) {
|
|
bind(self._input, "focus", self.open);
|
|
bind(self._input, "mousedown", onClick(self.open));
|
|
}
|
|
if (self.daysContainer !== undefined) {
|
|
bind(self.monthNav, "mousedown", onClick(onMonthNavClick));
|
|
bind(self.monthNav, ["keyup", "increment"], onYearInput);
|
|
bind(self.daysContainer, "mousedown", onClick(selectDate));
|
|
}
|
|
if (self.timeContainer !== undefined &&
|
|
self.minuteElement !== undefined &&
|
|
self.hourElement !== undefined) {
|
|
var selText = function (e) {
|
|
return e.target.select();
|
|
};
|
|
bind(self.timeContainer, ["increment"], updateTime);
|
|
bind(self.timeContainer, "blur", updateTime, { capture: true });
|
|
bind(self.timeContainer, "mousedown", onClick(timeIncrement));
|
|
bind([self.hourElement, self.minuteElement], ["focus", "click"], selText);
|
|
if (self.secondElement !== undefined)
|
|
bind(self.secondElement, "focus", function () { return self.secondElement && self.secondElement.select(); });
|
|
if (self.amPM !== undefined) {
|
|
bind(self.amPM, "mousedown", onClick(function (e) {
|
|
updateTime(e);
|
|
triggerChange();
|
|
}));
|
|
}
|
|
}
|
|
}
|
|
/**
|
|
* Set the calendar view to a particular date.
|
|
* @param {Date} jumpDate the date to set the view to
|
|
* @param {boolean} triggerChange if change events should be triggered
|
|
*/
|
|
function jumpToDate(jumpDate, triggerChange) {
|
|
var jumpTo = jumpDate !== undefined
|
|
? self.parseDate(jumpDate)
|
|
: self.latestSelectedDateObj ||
|
|
(self.config.minDate && self.config.minDate > self.now
|
|
? self.config.minDate
|
|
: self.config.maxDate && self.config.maxDate < self.now
|
|
? self.config.maxDate
|
|
: self.now);
|
|
var oldYear = self.currentYear;
|
|
var oldMonth = self.currentMonth;
|
|
try {
|
|
if (jumpTo !== undefined) {
|
|
self.currentYear = jumpTo.getFullYear();
|
|
self.currentMonth = jumpTo.getMonth();
|
|
}
|
|
}
|
|
catch (e) {
|
|
/* istanbul ignore next */
|
|
e.message = "Invalid date supplied: " + jumpTo;
|
|
self.config.errorHandler(e);
|
|
}
|
|
if (triggerChange && self.currentYear !== oldYear) {
|
|
triggerEvent("onYearChange");
|
|
buildMonthSwitch();
|
|
}
|
|
if (triggerChange &&
|
|
(self.currentYear !== oldYear || self.currentMonth !== oldMonth)) {
|
|
triggerEvent("onMonthChange");
|
|
}
|
|
self.redraw();
|
|
}
|
|
/**
|
|
* The up/down arrow handler for time inputs
|
|
* @param {Event} e the click event
|
|
*/
|
|
function timeIncrement(e) {
|
|
if (~e.target.className.indexOf("arrow"))
|
|
incrementNumInput(e, e.target.classList.contains("arrowUp") ? 1 : -1);
|
|
}
|
|
/**
|
|
* Increments/decrements the value of input associ-
|
|
* ated with the up/down arrow by dispatching an
|
|
* "increment" event on the input.
|
|
*
|
|
* @param {Event} e the click event
|
|
* @param {Number} delta the diff (usually 1 or -1)
|
|
* @param {Element} inputElem the input element
|
|
*/
|
|
function incrementNumInput(e, delta, inputElem) {
|
|
var target = e && e.target;
|
|
var input = inputElem ||
|
|
(target && target.parentNode && target.parentNode.firstChild);
|
|
var event = createEvent("increment");
|
|
event.delta = delta;
|
|
input && input.dispatchEvent(event);
|
|
}
|
|
function build() {
|
|
var fragment = window.document.createDocumentFragment();
|
|
self.calendarContainer = createElement("div", "flatpickr-calendar");
|
|
self.calendarContainer.tabIndex = -1;
|
|
if (!self.config.noCalendar) {
|
|
fragment.appendChild(buildMonthNav());
|
|
self.innerContainer = createElement("div", "flatpickr-innerContainer");
|
|
if (self.config.weekNumbers) {
|
|
var _a = buildWeeks(), weekWrapper = _a.weekWrapper, weekNumbers = _a.weekNumbers;
|
|
self.innerContainer.appendChild(weekWrapper);
|
|
self.weekNumbers = weekNumbers;
|
|
self.weekWrapper = weekWrapper;
|
|
}
|
|
self.rContainer = createElement("div", "flatpickr-rContainer");
|
|
self.rContainer.appendChild(buildWeekdays());
|
|
if (!self.daysContainer) {
|
|
self.daysContainer = createElement("div", "flatpickr-days");
|
|
self.daysContainer.tabIndex = -1;
|
|
}
|
|
buildDays();
|
|
self.rContainer.appendChild(self.daysContainer);
|
|
self.innerContainer.appendChild(self.rContainer);
|
|
fragment.appendChild(self.innerContainer);
|
|
}
|
|
if (self.config.enableTime) {
|
|
fragment.appendChild(buildTime());
|
|
}
|
|
toggleClass(self.calendarContainer, "rangeMode", self.config.mode === "range");
|
|
toggleClass(self.calendarContainer, "animate", self.config.animate === true);
|
|
toggleClass(self.calendarContainer, "multiMonth", self.config.showMonths > 1);
|
|
self.calendarContainer.appendChild(fragment);
|
|
var customAppend = self.config.appendTo !== undefined &&
|
|
self.config.appendTo.nodeType !== undefined;
|
|
if (self.config.inline || self.config.static) {
|
|
self.calendarContainer.classList.add(self.config.inline ? "inline" : "static");
|
|
if (self.config.inline) {
|
|
if (!customAppend && self.element.parentNode)
|
|
self.element.parentNode.insertBefore(self.calendarContainer, self._input.nextSibling);
|
|
else if (self.config.appendTo !== undefined)
|
|
self.config.appendTo.appendChild(self.calendarContainer);
|
|
}
|
|
if (self.config.static) {
|
|
var wrapper = createElement("div", "flatpickr-wrapper");
|
|
if (self.element.parentNode)
|
|
self.element.parentNode.insertBefore(wrapper, self.element);
|
|
wrapper.appendChild(self.element);
|
|
if (self.altInput)
|
|
wrapper.appendChild(self.altInput);
|
|
wrapper.appendChild(self.calendarContainer);
|
|
}
|
|
}
|
|
if (!self.config.static && !self.config.inline)
|
|
(self.config.appendTo !== undefined
|
|
? self.config.appendTo
|
|
: window.document.body).appendChild(self.calendarContainer);
|
|
}
|
|
function createDay(className, date, dayNumber, i) {
|
|
var dateIsEnabled = isEnabled(date, true), dayElement = createElement("span", "flatpickr-day " + className, date.getDate().toString());
|
|
dayElement.dateObj = date;
|
|
dayElement.$i = i;
|
|
dayElement.setAttribute("aria-label", self.formatDate(date, self.config.ariaDateFormat));
|
|
if (className.indexOf("hidden") === -1 &&
|
|
compareDates(date, self.now) === 0) {
|
|
self.todayDateElem = dayElement;
|
|
dayElement.classList.add("today");
|
|
dayElement.setAttribute("aria-current", "date");
|
|
}
|
|
if (dateIsEnabled) {
|
|
dayElement.tabIndex = -1;
|
|
if (isDateSelected(date)) {
|
|
dayElement.classList.add("selected");
|
|
self.selectedDateElem = dayElement;
|
|
if (self.config.mode === "range") {
|
|
toggleClass(dayElement, "startRange", self.selectedDates[0] &&
|
|
compareDates(date, self.selectedDates[0], true) === 0);
|
|
toggleClass(dayElement, "endRange", self.selectedDates[1] &&
|
|
compareDates(date, self.selectedDates[1], true) === 0);
|
|
if (className === "nextMonthDay")
|
|
dayElement.classList.add("inRange");
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
dayElement.classList.add("flatpickr-disabled");
|
|
}
|
|
if (self.config.mode === "range") {
|
|
if (isDateInRange(date) && !isDateSelected(date))
|
|
dayElement.classList.add("inRange");
|
|
}
|
|
if (self.weekNumbers &&
|
|
self.config.showMonths === 1 &&
|
|
className !== "prevMonthDay" &&
|
|
dayNumber % 7 === 1) {
|
|
self.weekNumbers.insertAdjacentHTML("beforeend", "<span class='flatpickr-day'>" + self.config.getWeek(date) + "</span>");
|
|
}
|
|
triggerEvent("onDayCreate", dayElement);
|
|
return dayElement;
|
|
}
|
|
function focusOnDayElem(targetNode) {
|
|
targetNode.focus();
|
|
if (self.config.mode === "range")
|
|
onMouseOver(targetNode);
|
|
}
|
|
function getFirstAvailableDay(delta) {
|
|
var startMonth = delta > 0 ? 0 : self.config.showMonths - 1;
|
|
var endMonth = delta > 0 ? self.config.showMonths : -1;
|
|
for (var m = startMonth; m != endMonth; m += delta) {
|
|
var month = self.daysContainer.children[m];
|
|
var startIndex = delta > 0 ? 0 : month.children.length - 1;
|
|
var endIndex = delta > 0 ? month.children.length : -1;
|
|
for (var i = startIndex; i != endIndex; i += delta) {
|
|
var c = month.children[i];
|
|
if (c.className.indexOf("hidden") === -1 && isEnabled(c.dateObj))
|
|
return c;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
function getNextAvailableDay(current, delta) {
|
|
var givenMonth = current.className.indexOf("Month") === -1
|
|
? current.dateObj.getMonth()
|
|
: self.currentMonth;
|
|
var endMonth = delta > 0 ? self.config.showMonths : -1;
|
|
var loopDelta = delta > 0 ? 1 : -1;
|
|
for (var m = givenMonth - self.currentMonth; m != endMonth; m += loopDelta) {
|
|
var month = self.daysContainer.children[m];
|
|
var startIndex = givenMonth - self.currentMonth === m
|
|
? current.$i + delta
|
|
: delta < 0
|
|
? month.children.length - 1
|
|
: 0;
|
|
var numMonthDays = month.children.length;
|
|
for (var i = startIndex; i >= 0 && i < numMonthDays && i != (delta > 0 ? numMonthDays : -1); i += loopDelta) {
|
|
var c = month.children[i];
|
|
if (c.className.indexOf("hidden") === -1 &&
|
|
isEnabled(c.dateObj) &&
|
|
Math.abs(current.$i - i) >= Math.abs(delta))
|
|
return focusOnDayElem(c);
|
|
}
|
|
}
|
|
self.changeMonth(loopDelta);
|
|
focusOnDay(getFirstAvailableDay(loopDelta), 0);
|
|
return undefined;
|
|
}
|
|
function focusOnDay(current, offset) {
|
|
var dayFocused = isInView(document.activeElement || document.body);
|
|
var startElem = current !== undefined
|
|
? current
|
|
: dayFocused
|
|
? document.activeElement
|
|
: self.selectedDateElem !== undefined && isInView(self.selectedDateElem)
|
|
? self.selectedDateElem
|
|
: self.todayDateElem !== undefined && isInView(self.todayDateElem)
|
|
? self.todayDateElem
|
|
: getFirstAvailableDay(offset > 0 ? 1 : -1);
|
|
if (startElem === undefined)
|
|
return self._input.focus();
|
|
if (!dayFocused)
|
|
return focusOnDayElem(startElem);
|
|
getNextAvailableDay(startElem, offset);
|
|
}
|
|
function buildMonthDays(year, month) {
|
|
var firstOfMonth = (new Date(year, month, 1).getDay() - self.l10n.firstDayOfWeek + 7) % 7;
|
|
var prevMonthDays = self.utils.getDaysInMonth((month - 1 + 12) % 12);
|
|
var daysInMonth = self.utils.getDaysInMonth(month), days = window.document.createDocumentFragment(), isMultiMonth = self.config.showMonths > 1, prevMonthDayClass = isMultiMonth ? "prevMonthDay hidden" : "prevMonthDay", nextMonthDayClass = isMultiMonth ? "nextMonthDay hidden" : "nextMonthDay";
|
|
var dayNumber = prevMonthDays + 1 - firstOfMonth, dayIndex = 0;
|
|
// prepend days from the ending of previous month
|
|
for (; dayNumber <= prevMonthDays; dayNumber++, dayIndex++) {
|
|
days.appendChild(createDay(prevMonthDayClass, new Date(year, month - 1, dayNumber), dayNumber, dayIndex));
|
|
}
|
|
// Start at 1 since there is no 0th day
|
|
for (dayNumber = 1; dayNumber <= daysInMonth; dayNumber++, dayIndex++) {
|
|
days.appendChild(createDay("", new Date(year, month, dayNumber), dayNumber, dayIndex));
|
|
}
|
|
// append days from the next month
|
|
for (var dayNum = daysInMonth + 1; dayNum <= 42 - firstOfMonth &&
|
|
(self.config.showMonths === 1 || dayIndex % 7 !== 0); dayNum++, dayIndex++) {
|
|
days.appendChild(createDay(nextMonthDayClass, new Date(year, month + 1, dayNum % daysInMonth), dayNum, dayIndex));
|
|
}
|
|
//updateNavigationCurrentMonth();
|
|
var dayContainer = createElement("div", "dayContainer");
|
|
dayContainer.appendChild(days);
|
|
return dayContainer;
|
|
}
|
|
function buildDays() {
|
|
if (self.daysContainer === undefined) {
|
|
return;
|
|
}
|
|
clearNode(self.daysContainer);
|
|
// TODO: week numbers for each month
|
|
if (self.weekNumbers)
|
|
clearNode(self.weekNumbers);
|
|
var frag = document.createDocumentFragment();
|
|
for (var i = 0; i < self.config.showMonths; i++) {
|
|
var d = new Date(self.currentYear, self.currentMonth, 1);
|
|
d.setMonth(self.currentMonth + i);
|
|
frag.appendChild(buildMonthDays(d.getFullYear(), d.getMonth()));
|
|
}
|
|
self.daysContainer.appendChild(frag);
|
|
self.days = self.daysContainer.firstChild;
|
|
if (self.config.mode === "range" && self.selectedDates.length === 1) {
|
|
onMouseOver();
|
|
}
|
|
}
|
|
function buildMonthSwitch() {
|
|
if (self.config.showMonths > 1 ||
|
|
self.config.monthSelectorType !== "dropdown")
|
|
return;
|
|
var shouldBuildMonth = function (month) {
|
|
if (self.config.minDate !== undefined &&
|
|
self.currentYear === self.config.minDate.getFullYear() &&
|
|
month < self.config.minDate.getMonth()) {
|
|
return false;
|
|
}
|
|
return !(self.config.maxDate !== undefined &&
|
|
self.currentYear === self.config.maxDate.getFullYear() &&
|
|
month > self.config.maxDate.getMonth());
|
|
};
|
|
self.monthsDropdownContainer.tabIndex = -1;
|
|
self.monthsDropdownContainer.innerHTML = "";
|
|
for (var i = 0; i < 12; i++) {
|
|
if (!shouldBuildMonth(i))
|
|
continue;
|
|
var month = createElement("option", "flatpickr-monthDropdown-month");
|
|
month.value = new Date(self.currentYear, i).getMonth().toString();
|
|
month.textContent = monthToStr(i, self.config.shorthandCurrentMonth, self.l10n);
|
|
month.tabIndex = -1;
|
|
if (self.currentMonth === i) {
|
|
month.selected = true;
|
|
}
|
|
self.monthsDropdownContainer.appendChild(month);
|
|
}
|
|
}
|
|
function buildMonth() {
|
|
var container = createElement("div", "flatpickr-month");
|
|
var monthNavFragment = window.document.createDocumentFragment();
|
|
var monthElement;
|
|
if (self.config.showMonths > 1 ||
|
|
self.config.monthSelectorType === "static") {
|
|
monthElement = createElement("span", "cur-month");
|
|
}
|
|
else {
|
|
self.monthsDropdownContainer = createElement("select", "flatpickr-monthDropdown-months");
|
|
bind(self.monthsDropdownContainer, "change", function (e) {
|
|
var target = e.target;
|
|
var selectedMonth = parseInt(target.value, 10);
|
|
self.changeMonth(selectedMonth - self.currentMonth);
|
|
triggerEvent("onMonthChange");
|
|
});
|
|
buildMonthSwitch();
|
|
monthElement = self.monthsDropdownContainer;
|
|
}
|
|
var yearInput = createNumberInput("cur-year", { tabindex: "-1" });
|
|
var yearElement = yearInput.getElementsByTagName("input")[0];
|
|
yearElement.setAttribute("aria-label", self.l10n.yearAriaLabel);
|
|
if (self.config.minDate) {
|
|
yearElement.setAttribute("min", self.config.minDate.getFullYear().toString());
|
|
}
|
|
if (self.config.maxDate) {
|
|
yearElement.setAttribute("max", self.config.maxDate.getFullYear().toString());
|
|
yearElement.disabled =
|
|
!!self.config.minDate &&
|
|
self.config.minDate.getFullYear() === self.config.maxDate.getFullYear();
|
|
}
|
|
var currentMonth = createElement("div", "flatpickr-current-month");
|
|
currentMonth.appendChild(monthElement);
|
|
currentMonth.appendChild(yearInput);
|
|
monthNavFragment.appendChild(currentMonth);
|
|
container.appendChild(monthNavFragment);
|
|
return {
|
|
container: container,
|
|
yearElement: yearElement,
|
|
monthElement: monthElement
|
|
};
|
|
}
|
|
function buildMonths() {
|
|
clearNode(self.monthNav);
|
|
self.monthNav.appendChild(self.prevMonthNav);
|
|
if (self.config.showMonths) {
|
|
self.yearElements = [];
|
|
self.monthElements = [];
|
|
}
|
|
for (var m = self.config.showMonths; m--;) {
|
|
var month = buildMonth();
|
|
self.yearElements.push(month.yearElement);
|
|
self.monthElements.push(month.monthElement);
|
|
self.monthNav.appendChild(month.container);
|
|
}
|
|
self.monthNav.appendChild(self.nextMonthNav);
|
|
}
|
|
function buildMonthNav() {
|
|
self.monthNav = createElement("div", "flatpickr-months");
|
|
self.yearElements = [];
|
|
self.monthElements = [];
|
|
self.prevMonthNav = createElement("span", "flatpickr-prev-month");
|
|
self.prevMonthNav.innerHTML = self.config.prevArrow;
|
|
self.nextMonthNav = createElement("span", "flatpickr-next-month");
|
|
self.nextMonthNav.innerHTML = self.config.nextArrow;
|
|
buildMonths();
|
|
Object.defineProperty(self, "_hidePrevMonthArrow", {
|
|
get: function () { return self.__hidePrevMonthArrow; },
|
|
set: function (bool) {
|
|
if (self.__hidePrevMonthArrow !== bool) {
|
|
toggleClass(self.prevMonthNav, "flatpickr-disabled", bool);
|
|
self.__hidePrevMonthArrow = bool;
|
|
}
|
|
}
|
|
});
|
|
Object.defineProperty(self, "_hideNextMonthArrow", {
|
|
get: function () { return self.__hideNextMonthArrow; },
|
|
set: function (bool) {
|
|
if (self.__hideNextMonthArrow !== bool) {
|
|
toggleClass(self.nextMonthNav, "flatpickr-disabled", bool);
|
|
self.__hideNextMonthArrow = bool;
|
|
}
|
|
}
|
|
});
|
|
self.currentYearElement = self.yearElements[0];
|
|
updateNavigationCurrentMonth();
|
|
return self.monthNav;
|
|
}
|
|
function buildTime() {
|
|
self.calendarContainer.classList.add("hasTime");
|
|
if (self.config.noCalendar)
|
|
self.calendarContainer.classList.add("noCalendar");
|
|
self.timeContainer = createElement("div", "flatpickr-time");
|
|
self.timeContainer.tabIndex = -1;
|
|
var separator = createElement("span", "flatpickr-time-separator", ":");
|
|
var hourInput = createNumberInput("flatpickr-hour", {
|
|
"aria-label": self.l10n.hourAriaLabel
|
|
});
|
|
self.hourElement = hourInput.getElementsByTagName("input")[0];
|
|
var minuteInput = createNumberInput("flatpickr-minute", {
|
|
"aria-label": self.l10n.minuteAriaLabel
|
|
});
|
|
self.minuteElement = minuteInput.getElementsByTagName("input")[0];
|
|
self.hourElement.tabIndex = self.minuteElement.tabIndex = -1;
|
|
self.hourElement.value = pad(self.latestSelectedDateObj
|
|
? self.latestSelectedDateObj.getHours()
|
|
: self.config.time_24hr
|
|
? self.config.defaultHour
|
|
: military2ampm(self.config.defaultHour));
|
|
self.minuteElement.value = pad(self.latestSelectedDateObj
|
|
? self.latestSelectedDateObj.getMinutes()
|
|
: self.config.defaultMinute);
|
|
self.hourElement.setAttribute("step", self.config.hourIncrement.toString());
|
|
self.minuteElement.setAttribute("step", self.config.minuteIncrement.toString());
|
|
self.hourElement.setAttribute("min", self.config.time_24hr ? "0" : "1");
|
|
self.hourElement.setAttribute("max", self.config.time_24hr ? "23" : "12");
|
|
self.minuteElement.setAttribute("min", "0");
|
|
self.minuteElement.setAttribute("max", "59");
|
|
self.timeContainer.appendChild(hourInput);
|
|
self.timeContainer.appendChild(separator);
|
|
self.timeContainer.appendChild(minuteInput);
|
|
if (self.config.time_24hr)
|
|
self.timeContainer.classList.add("time24hr");
|
|
if (self.config.enableSeconds) {
|
|
self.timeContainer.classList.add("hasSeconds");
|
|
var secondInput = createNumberInput("flatpickr-second");
|
|
self.secondElement = secondInput.getElementsByTagName("input")[0];
|
|
self.secondElement.value = pad(self.latestSelectedDateObj
|
|
? self.latestSelectedDateObj.getSeconds()
|
|
: self.config.defaultSeconds);
|
|
self.secondElement.setAttribute("step", self.minuteElement.getAttribute("step"));
|
|
self.secondElement.setAttribute("min", "0");
|
|
self.secondElement.setAttribute("max", "59");
|
|
self.timeContainer.appendChild(createElement("span", "flatpickr-time-separator", ":"));
|
|
self.timeContainer.appendChild(secondInput);
|
|
}
|
|
if (!self.config.time_24hr) {
|
|
// add self.amPM if appropriate
|
|
self.amPM = createElement("span", "flatpickr-am-pm", self.l10n.amPM[int((self.latestSelectedDateObj
|
|
? self.hourElement.value
|
|
: self.config.defaultHour) > 11)]);
|
|
self.amPM.title = self.l10n.toggleTitle;
|
|
self.amPM.tabIndex = -1;
|
|
self.timeContainer.appendChild(self.amPM);
|
|
}
|
|
return self.timeContainer;
|
|
}
|
|
function buildWeekdays() {
|
|
if (!self.weekdayContainer)
|
|
self.weekdayContainer = createElement("div", "flatpickr-weekdays");
|
|
else
|
|
clearNode(self.weekdayContainer);
|
|
for (var i = self.config.showMonths; i--;) {
|
|
var container = createElement("div", "flatpickr-weekdaycontainer");
|
|
self.weekdayContainer.appendChild(container);
|
|
}
|
|
updateWeekdays();
|
|
return self.weekdayContainer;
|
|
}
|
|
function updateWeekdays() {
|
|
var firstDayOfWeek = self.l10n.firstDayOfWeek;
|
|
var weekdays = self.l10n.weekdays.shorthand.slice();
|
|
if (firstDayOfWeek > 0 && firstDayOfWeek < weekdays.length) {
|
|
weekdays = weekdays.splice(firstDayOfWeek, weekdays.length).concat(weekdays.splice(0, firstDayOfWeek));
|
|
}
|
|
for (var i = self.config.showMonths; i--;) {
|
|
self.weekdayContainer.children[i].innerHTML = "\n <span class='flatpickr-weekday'>\n " + weekdays.join("</span><span class='flatpickr-weekday'>") + "\n </span>\n ";
|
|
}
|
|
}
|
|
/* istanbul ignore next */
|
|
function buildWeeks() {
|
|
self.calendarContainer.classList.add("hasWeeks");
|
|
var weekWrapper = createElement("div", "flatpickr-weekwrapper");
|
|
weekWrapper.appendChild(createElement("span", "flatpickr-weekday", self.l10n.weekAbbreviation));
|
|
var weekNumbers = createElement("div", "flatpickr-weeks");
|
|
weekWrapper.appendChild(weekNumbers);
|
|
return {
|
|
weekWrapper: weekWrapper,
|
|
weekNumbers: weekNumbers
|
|
};
|
|
}
|
|
function changeMonth(value, isOffset) {
|
|
if (isOffset === void 0) { isOffset = true; }
|
|
var delta = isOffset ? value : value - self.currentMonth;
|
|
if ((delta < 0 && self._hidePrevMonthArrow === true) ||
|
|
(delta > 0 && self._hideNextMonthArrow === true))
|
|
return;
|
|
self.currentMonth += delta;
|
|
if (self.currentMonth < 0 || self.currentMonth > 11) {
|
|
self.currentYear += self.currentMonth > 11 ? 1 : -1;
|
|
self.currentMonth = (self.currentMonth + 12) % 12;
|
|
triggerEvent("onYearChange");
|
|
buildMonthSwitch();
|
|
}
|
|
buildDays();
|
|
triggerEvent("onMonthChange");
|
|
updateNavigationCurrentMonth();
|
|
}
|
|
function clear(triggerChangeEvent, toInitial) {
|
|
if (triggerChangeEvent === void 0) { triggerChangeEvent = true; }
|
|
if (toInitial === void 0) { toInitial = true; }
|
|
self.input.value = "";
|
|
if (self.altInput !== undefined)
|
|
self.altInput.value = "";
|
|
if (self.mobileInput !== undefined)
|
|
self.mobileInput.value = "";
|
|
self.selectedDates = [];
|
|
self.latestSelectedDateObj = undefined;
|
|
if (toInitial === true) {
|
|
self.currentYear = self._initialDate.getFullYear();
|
|
self.currentMonth = self._initialDate.getMonth();
|
|
}
|
|
self.showTimeInput = false;
|
|
if (self.config.enableTime === true) {
|
|
setDefaultHours();
|
|
}
|
|
self.redraw();
|
|
if (triggerChangeEvent)
|
|
// triggerChangeEvent is true (default) or an Event
|
|
triggerEvent("onChange");
|
|
}
|
|
function close() {
|
|
self.isOpen = false;
|
|
if (!self.isMobile) {
|
|
if (self.calendarContainer !== undefined) {
|
|
self.calendarContainer.classList.remove("open");
|
|
}
|
|
if (self._input !== undefined) {
|
|
self._input.classList.remove("active");
|
|
}
|
|
}
|
|
triggerEvent("onClose");
|
|
}
|
|
function destroy() {
|
|
if (self.config !== undefined)
|
|
triggerEvent("onDestroy");
|
|
for (var i = self._handlers.length; i--;) {
|
|
var h = self._handlers[i];
|
|
h.element.removeEventListener(h.event, h.handler, h.options);
|
|
}
|
|
self._handlers = [];
|
|
if (self.mobileInput) {
|
|
if (self.mobileInput.parentNode)
|
|
self.mobileInput.parentNode.removeChild(self.mobileInput);
|
|
self.mobileInput = undefined;
|
|
}
|
|
else if (self.calendarContainer && self.calendarContainer.parentNode) {
|
|
if (self.config.static && self.calendarContainer.parentNode) {
|
|
var wrapper = self.calendarContainer.parentNode;
|
|
wrapper.lastChild && wrapper.removeChild(wrapper.lastChild);
|
|
if (wrapper.parentNode) {
|
|
while (wrapper.firstChild)
|
|
wrapper.parentNode.insertBefore(wrapper.firstChild, wrapper);
|
|
wrapper.parentNode.removeChild(wrapper);
|
|
}
|
|
}
|
|
else
|
|
self.calendarContainer.parentNode.removeChild(self.calendarContainer);
|
|
}
|
|
if (self.altInput) {
|
|
self.input.type = "text";
|
|
if (self.altInput.parentNode)
|
|
self.altInput.parentNode.removeChild(self.altInput);
|
|
delete self.altInput;
|
|
}
|
|
if (self.input) {
|
|
self.input.type = self.input._type;
|
|
self.input.classList.remove("flatpickr-input");
|
|
self.input.removeAttribute("readonly");
|
|
self.input.value = "";
|
|
}
|
|
[
|
|
"_showTimeInput",
|
|
"latestSelectedDateObj",
|
|
"_hideNextMonthArrow",
|
|
"_hidePrevMonthArrow",
|
|
"__hideNextMonthArrow",
|
|
"__hidePrevMonthArrow",
|
|
"isMobile",
|
|
"isOpen",
|
|
"selectedDateElem",
|
|
"minDateHasTime",
|
|
"maxDateHasTime",
|
|
"days",
|
|
"daysContainer",
|
|
"_input",
|
|
"_positionElement",
|
|
"innerContainer",
|
|
"rContainer",
|
|
"monthNav",
|
|
"todayDateElem",
|
|
"calendarContainer",
|
|
"weekdayContainer",
|
|
"prevMonthNav",
|
|
"nextMonthNav",
|
|
"monthsDropdownContainer",
|
|
"currentMonthElement",
|
|
"currentYearElement",
|
|
"navigationCurrentMonth",
|
|
"selectedDateElem",
|
|
"config",
|
|
].forEach(function (k) {
|
|
try {
|
|
delete self[k];
|
|
}
|
|
catch (_) { }
|
|
});
|
|
}
|
|
function isCalendarElem(elem) {
|
|
if (self.config.appendTo && self.config.appendTo.contains(elem))
|
|
return true;
|
|
return self.calendarContainer.contains(elem);
|
|
}
|
|
function documentClick(e) {
|
|
if (self.isOpen && !self.config.inline) {
|
|
var eventTarget_1 = getEventTarget(e);
|
|
var isCalendarElement = isCalendarElem(eventTarget_1);
|
|
var isInput = eventTarget_1 === self.input ||
|
|
eventTarget_1 === self.altInput ||
|
|
self.element.contains(eventTarget_1) ||
|
|
// web components
|
|
// e.path is not present in all browsers. circumventing typechecks
|
|
(e.path &&
|
|
e.path.indexOf &&
|
|
(~e.path.indexOf(self.input) ||
|
|
~e.path.indexOf(self.altInput)));
|
|
var lostFocus = e.type === "blur"
|
|
? isInput &&
|
|
e.relatedTarget &&
|
|
!isCalendarElem(e.relatedTarget)
|
|
: !isInput &&
|
|
!isCalendarElement &&
|
|
!isCalendarElem(e.relatedTarget);
|
|
var isIgnored = !self.config.ignoredFocusElements.some(function (elem) {
|
|
return elem.contains(eventTarget_1);
|
|
});
|
|
if (lostFocus && isIgnored) {
|
|
self.close();
|
|
if (self.config.mode === "range" && self.selectedDates.length === 1) {
|
|
self.clear(false);
|
|
self.redraw();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
function changeYear(newYear) {
|
|
if (!newYear ||
|
|
(self.config.minDate && newYear < self.config.minDate.getFullYear()) ||
|
|
(self.config.maxDate && newYear > self.config.maxDate.getFullYear()))
|
|
return;
|
|
var newYearNum = newYear, isNewYear = self.currentYear !== newYearNum;
|
|
self.currentYear = newYearNum || self.currentYear;
|
|
if (self.config.maxDate &&
|
|
self.currentYear === self.config.maxDate.getFullYear()) {
|
|
self.currentMonth = Math.min(self.config.maxDate.getMonth(), self.currentMonth);
|
|
}
|
|
else if (self.config.minDate &&
|
|
self.currentYear === self.config.minDate.getFullYear()) {
|
|
self.currentMonth = Math.max(self.config.minDate.getMonth(), self.currentMonth);
|
|
}
|
|
if (isNewYear) {
|
|
self.redraw();
|
|
triggerEvent("onYearChange");
|
|
buildMonthSwitch();
|
|
}
|
|
}
|
|
function isEnabled(date, timeless) {
|
|
if (timeless === void 0) { timeless = true; }
|
|
var dateToCheck = self.parseDate(date, undefined, timeless); // timeless
|
|
if ((self.config.minDate &&
|
|
dateToCheck &&
|
|
compareDates(dateToCheck, self.config.minDate, timeless !== undefined ? timeless : !self.minDateHasTime) < 0) ||
|
|
(self.config.maxDate &&
|
|
dateToCheck &&
|
|
compareDates(dateToCheck, self.config.maxDate, timeless !== undefined ? timeless : !self.maxDateHasTime) > 0))
|
|
return false;
|
|
if (self.config.enable.length === 0 && self.config.disable.length === 0)
|
|
return true;
|
|
if (dateToCheck === undefined)
|
|
return false;
|
|
var bool = self.config.enable.length > 0, array = bool ? self.config.enable : self.config.disable;
|
|
for (var i = 0, d = void 0; i < array.length; i++) {
|
|
d = array[i];
|
|
if (typeof d === "function" &&
|
|
d(dateToCheck) // disabled by function
|
|
)
|
|
return bool;
|
|
else if (d instanceof Date &&
|
|
dateToCheck !== undefined &&
|
|
d.getTime() === dateToCheck.getTime())
|
|
// disabled by date
|
|
return bool;
|
|
else if (typeof d === "string" && dateToCheck !== undefined) {
|
|
// disabled by date string
|
|
var parsed = self.parseDate(d, undefined, true);
|
|
return parsed && parsed.getTime() === dateToCheck.getTime()
|
|
? bool
|
|
: !bool;
|
|
}
|
|
else if (
|
|
// disabled by range
|
|
typeof d === "object" &&
|
|
dateToCheck !== undefined &&
|
|
d.from &&
|
|
d.to &&
|
|
dateToCheck.getTime() >= d.from.getTime() &&
|
|
dateToCheck.getTime() <= d.to.getTime())
|
|
return bool;
|
|
}
|
|
return !bool;
|
|
}
|
|
function isInView(elem) {
|
|
if (self.daysContainer !== undefined)
|
|
return (elem.className.indexOf("hidden") === -1 &&
|
|
self.daysContainer.contains(elem));
|
|
return false;
|
|
}
|
|
function onKeyDown(e) {
|
|
// e.key e.keyCode
|
|
// "Backspace" 8
|
|
// "Tab" 9
|
|
// "Enter" 13
|
|
// "Escape" (IE "Esc") 27
|
|
// "ArrowLeft" (IE "Left") 37
|
|
// "ArrowUp" (IE "Up") 38
|
|
// "ArrowRight" (IE "Right") 39
|
|
// "ArrowDown" (IE "Down") 40
|
|
// "Delete" (IE "Del") 46
|
|
var isInput = e.target === self._input;
|
|
var allowInput = self.config.allowInput;
|
|
var allowKeydown = self.isOpen && (!allowInput || !isInput);
|
|
var allowInlineKeydown = self.config.inline && isInput && !allowInput;
|
|
if (e.keyCode === 13 && isInput) {
|
|
if (allowInput) {
|
|
self.setDate(self._input.value, true, e.target === self.altInput
|
|
? self.config.altFormat
|
|
: self.config.dateFormat);
|
|
return e.target.blur();
|
|
}
|
|
else {
|
|
self.open();
|
|
}
|
|
}
|
|
else if (isCalendarElem(e.target) ||
|
|
allowKeydown ||
|
|
allowInlineKeydown) {
|
|
var isTimeObj = !!self.timeContainer &&
|
|
self.timeContainer.contains(e.target);
|
|
switch (e.keyCode) {
|
|
case 13:
|
|
if (isTimeObj) {
|
|
e.preventDefault();
|
|
updateTime();
|
|
focusAndClose();
|
|
}
|
|
else
|
|
selectDate(e);
|
|
break;
|
|
case 27: // escape
|
|
e.preventDefault();
|
|
focusAndClose();
|
|
break;
|
|
case 8:
|
|
case 46:
|
|
if (isInput && !self.config.allowInput) {
|
|
e.preventDefault();
|
|
self.clear();
|
|
}
|
|
break;
|
|
case 37:
|
|
case 39:
|
|
if (!isTimeObj && !isInput) {
|
|
e.preventDefault();
|
|
if (self.daysContainer !== undefined &&
|
|
(allowInput === false ||
|
|
(document.activeElement && isInView(document.activeElement)))) {
|
|
var delta_1 = e.keyCode === 39 ? 1 : -1;
|
|
if (!e.ctrlKey)
|
|
focusOnDay(undefined, delta_1);
|
|
else {
|
|
e.stopPropagation();
|
|
changeMonth(delta_1);
|
|
focusOnDay(getFirstAvailableDay(1), 0);
|
|
}
|
|
}
|
|
}
|
|
else if (self.hourElement)
|
|
self.hourElement.focus();
|
|
break;
|
|
case 38:
|
|
case 40:
|
|
e.preventDefault();
|
|
var delta = e.keyCode === 40 ? 1 : -1;
|
|
if ((self.daysContainer && e.target.$i !== undefined) ||
|
|
e.target === self.input) {
|
|
if (e.ctrlKey) {
|
|
e.stopPropagation();
|
|
changeYear(self.currentYear - delta);
|
|
focusOnDay(getFirstAvailableDay(1), 0);
|
|
}
|
|
else if (!isTimeObj)
|
|
focusOnDay(undefined, delta * 7);
|
|
}
|
|
else if (e.target === self.currentYearElement) {
|
|
changeYear(self.currentYear - delta);
|
|
}
|
|
else if (self.config.enableTime) {
|
|
if (!isTimeObj && self.hourElement)
|
|
self.hourElement.focus();
|
|
updateTime(e);
|
|
self._debouncedChange();
|
|
}
|
|
break;
|
|
case 9:
|
|
if (isTimeObj) {
|
|
var elems = [
|
|
self.hourElement,
|
|
self.minuteElement,
|
|
self.secondElement,
|
|
self.amPM,
|
|
]
|
|
.concat(self.pluginElements)
|
|
.filter(function (x) { return x; });
|
|
var i = elems.indexOf(e.target);
|
|
if (i !== -1) {
|
|
var target = elems[i + (e.shiftKey ? -1 : 1)];
|
|
e.preventDefault();
|
|
(target || self._input).focus();
|
|
}
|
|
}
|
|
else if (!self.config.noCalendar &&
|
|
self.daysContainer &&
|
|
self.daysContainer.contains(e.target) &&
|
|
e.shiftKey) {
|
|
e.preventDefault();
|
|
self._input.focus();
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
if (self.amPM !== undefined && e.target === self.amPM) {
|
|
switch (e.key) {
|
|
case self.l10n.amPM[0].charAt(0):
|
|
case self.l10n.amPM[0].charAt(0).toLowerCase():
|
|
self.amPM.textContent = self.l10n.amPM[0];
|
|
setHoursFromInputs();
|
|
updateValue();
|
|
break;
|
|
case self.l10n.amPM[1].charAt(0):
|
|
case self.l10n.amPM[1].charAt(0).toLowerCase():
|
|
self.amPM.textContent = self.l10n.amPM[1];
|
|
setHoursFromInputs();
|
|
updateValue();
|
|
break;
|
|
}
|
|
}
|
|
if (isInput || isCalendarElem(e.target)) {
|
|
triggerEvent("onKeyDown", e);
|
|
}
|
|
}
|
|
function onMouseOver(elem) {
|
|
if (self.selectedDates.length !== 1 ||
|
|
(elem &&
|
|
(!elem.classList.contains("flatpickr-day") ||
|
|
elem.classList.contains("flatpickr-disabled"))))
|
|
return;
|
|
var hoverDate = elem
|
|
? elem.dateObj.getTime()
|
|
: self.days.firstElementChild.dateObj.getTime(), initialDate = self.parseDate(self.selectedDates[0], undefined, true).getTime(), rangeStartDate = Math.min(hoverDate, self.selectedDates[0].getTime()), rangeEndDate = Math.max(hoverDate, self.selectedDates[0].getTime());
|
|
var containsDisabled = false;
|
|
var minRange = 0, maxRange = 0;
|
|
for (var t = rangeStartDate; t < rangeEndDate; t += duration.DAY) {
|
|
if (!isEnabled(new Date(t), true)) {
|
|
containsDisabled =
|
|
containsDisabled || (t > rangeStartDate && t < rangeEndDate);
|
|
if (t < initialDate && (!minRange || t > minRange))
|
|
minRange = t;
|
|
else if (t > initialDate && (!maxRange || t < maxRange))
|
|
maxRange = t;
|
|
}
|
|
}
|
|
for (var m = 0; m < self.config.showMonths; m++) {
|
|
var month = self.daysContainer.children[m];
|
|
var _loop_1 = function (i, l) {
|
|
var dayElem = month.children[i], date = dayElem.dateObj;
|
|
var timestamp = date.getTime();
|
|
var outOfRange = (minRange > 0 && timestamp < minRange) ||
|
|
(maxRange > 0 && timestamp > maxRange);
|
|
if (outOfRange) {
|
|
dayElem.classList.add("notAllowed");
|
|
["inRange", "startRange", "endRange"].forEach(function (c) {
|
|
dayElem.classList.remove(c);
|
|
});
|
|
return "continue";
|
|
}
|
|
else if (containsDisabled && !outOfRange)
|
|
return "continue";
|
|
["startRange", "inRange", "endRange", "notAllowed"].forEach(function (c) {
|
|
dayElem.classList.remove(c);
|
|
});
|
|
if (elem !== undefined) {
|
|
elem.classList.add(hoverDate <= self.selectedDates[0].getTime()
|
|
? "startRange"
|
|
: "endRange");
|
|
if (initialDate < hoverDate && timestamp === initialDate)
|
|
dayElem.classList.add("startRange");
|
|
else if (initialDate > hoverDate && timestamp === initialDate)
|
|
dayElem.classList.add("endRange");
|
|
if (timestamp >= minRange &&
|
|
(maxRange === 0 || timestamp <= maxRange) &&
|
|
isBetween(timestamp, initialDate, hoverDate))
|
|
dayElem.classList.add("inRange");
|
|
}
|
|
};
|
|
for (var i = 0, l = month.children.length; i < l; i++) {
|
|
_loop_1(i, l);
|
|
}
|
|
}
|
|
}
|
|
function onResize() {
|
|
if (self.isOpen && !self.config.static && !self.config.inline)
|
|
positionCalendar();
|
|
}
|
|
function setDefaultTime() {
|
|
self.setDate(self.config.minDate !== undefined
|
|
? new Date(self.config.minDate.getTime())
|
|
: new Date(), true);
|
|
setDefaultHours();
|
|
updateValue();
|
|
}
|
|
function open(e, positionElement) {
|
|
if (positionElement === void 0) { positionElement = self._positionElement; }
|
|
if (self.isMobile === true) {
|
|
if (e) {
|
|
e.preventDefault();
|
|
e.target && e.target.blur();
|
|
}
|
|
if (self.mobileInput !== undefined) {
|
|
self.mobileInput.focus();
|
|
self.mobileInput.click();
|
|
}
|
|
triggerEvent("onOpen");
|
|
return;
|
|
}
|
|
if (self._input.disabled || self.config.inline)
|
|
return;
|
|
var wasOpen = self.isOpen;
|
|
self.isOpen = true;
|
|
if (!wasOpen) {
|
|
self.calendarContainer.classList.add("open");
|
|
self._input.classList.add("active");
|
|
triggerEvent("onOpen");
|
|
positionCalendar(positionElement);
|
|
}
|
|
if (self.config.enableTime === true && self.config.noCalendar === true) {
|
|
if (self.selectedDates.length === 0) {
|
|
setDefaultTime();
|
|
}
|
|
if (self.config.allowInput === false &&
|
|
(e === undefined ||
|
|
!self.timeContainer.contains(e.relatedTarget))) {
|
|
setTimeout(function () { return self.hourElement.select(); }, 50);
|
|
}
|
|
}
|
|
}
|
|
function minMaxDateSetter(type) {
|
|
return function (date) {
|
|
var dateObj = (self.config["_" + type + "Date"] = self.parseDate(date, self.config.dateFormat));
|
|
var inverseDateObj = self.config["_" + (type === "min" ? "max" : "min") + "Date"];
|
|
if (dateObj !== undefined) {
|
|
self[type === "min" ? "minDateHasTime" : "maxDateHasTime"] =
|
|
dateObj.getHours() > 0 ||
|
|
dateObj.getMinutes() > 0 ||
|
|
dateObj.getSeconds() > 0;
|
|
}
|
|
if (self.selectedDates) {
|
|
self.selectedDates = self.selectedDates.filter(function (d) { return isEnabled(d); });
|
|
if (!self.selectedDates.length && type === "min")
|
|
setHoursFromDate(dateObj);
|
|
updateValue();
|
|
}
|
|
if (self.daysContainer) {
|
|
redraw();
|
|
if (dateObj !== undefined)
|
|
self.currentYearElement[type] = dateObj.getFullYear().toString();
|
|
else
|
|
self.currentYearElement.removeAttribute(type);
|
|
self.currentYearElement.disabled =
|
|
!!inverseDateObj &&
|
|
dateObj !== undefined &&
|
|
inverseDateObj.getFullYear() === dateObj.getFullYear();
|
|
}
|
|
};
|
|
}
|
|
function parseConfig() {
|
|
var boolOpts = [
|
|
"wrap",
|
|
"weekNumbers",
|
|
"allowInput",
|
|
"clickOpens",
|
|
"time_24hr",
|
|
"enableTime",
|
|
"noCalendar",
|
|
"altInput",
|
|
"shorthandCurrentMonth",
|
|
"inline",
|
|
"static",
|
|
"enableSeconds",
|
|
"disableMobile",
|
|
];
|
|
var userConfig = __assign({}, instanceConfig, JSON.parse(JSON.stringify(element.dataset || {})));
|
|
var formats = {};
|
|
self.config.parseDate = userConfig.parseDate;
|
|
self.config.formatDate = userConfig.formatDate;
|
|
Object.defineProperty(self.config, "enable", {
|
|
get: function () { return self.config._enable; },
|
|
set: function (dates) {
|
|
self.config._enable = parseDateRules(dates);
|
|
}
|
|
});
|
|
Object.defineProperty(self.config, "disable", {
|
|
get: function () { return self.config._disable; },
|
|
set: function (dates) {
|
|
self.config._disable = parseDateRules(dates);
|
|
}
|
|
});
|
|
var timeMode = userConfig.mode === "time";
|
|
if (!userConfig.dateFormat && (userConfig.enableTime || timeMode)) {
|
|
var defaultDateFormat = flatpickr.defaultConfig.dateFormat || defaults.dateFormat;
|
|
formats.dateFormat =
|
|
userConfig.noCalendar || timeMode
|
|
? "H:i" + (userConfig.enableSeconds ? ":S" : "")
|
|
: defaultDateFormat + " H:i" + (userConfig.enableSeconds ? ":S" : "");
|
|
}
|
|
if (userConfig.altInput &&
|
|
(userConfig.enableTime || timeMode) &&
|
|
!userConfig.altFormat) {
|
|
var defaultAltFormat = flatpickr.defaultConfig.altFormat || defaults.altFormat;
|
|
formats.altFormat =
|
|
userConfig.noCalendar || timeMode
|
|
? "h:i" + (userConfig.enableSeconds ? ":S K" : " K")
|
|
: defaultAltFormat + (" h:i" + (userConfig.enableSeconds ? ":S" : "") + " K");
|
|
}
|
|
if (!userConfig.altInputClass) {
|
|
self.config.altInputClass =
|
|
self.input.className + " " + self.config.altInputClass;
|
|
}
|
|
Object.defineProperty(self.config, "minDate", {
|
|
get: function () { return self.config._minDate; },
|
|
set: minMaxDateSetter("min")
|
|
});
|
|
Object.defineProperty(self.config, "maxDate", {
|
|
get: function () { return self.config._maxDate; },
|
|
set: minMaxDateSetter("max")
|
|
});
|
|
var minMaxTimeSetter = function (type) { return function (val) {
|
|
self.config[type === "min" ? "_minTime" : "_maxTime"] = self.parseDate(val, "H:i");
|
|
}; };
|
|
Object.defineProperty(self.config, "minTime", {
|
|
get: function () { return self.config._minTime; },
|
|
set: minMaxTimeSetter("min")
|
|
});
|
|
Object.defineProperty(self.config, "maxTime", {
|
|
get: function () { return self.config._maxTime; },
|
|
set: minMaxTimeSetter("max")
|
|
});
|
|
if (userConfig.mode === "time") {
|
|
self.config.noCalendar = true;
|
|
self.config.enableTime = true;
|
|
}
|
|
Object.assign(self.config, formats, userConfig);
|
|
for (var i = 0; i < boolOpts.length; i++)
|
|
self.config[boolOpts[i]] =
|
|
self.config[boolOpts[i]] === true ||
|
|
self.config[boolOpts[i]] === "true";
|
|
HOOKS.filter(function (hook) { return self.config[hook] !== undefined; }).forEach(function (hook) {
|
|
self.config[hook] = arrayify(self.config[hook] || []).map(bindToInstance);
|
|
});
|
|
self.isMobile =
|
|
!self.config.disableMobile &&
|
|
!self.config.inline &&
|
|
self.config.mode === "single" &&
|
|
!self.config.disable.length &&
|
|
!self.config.enable.length &&
|
|
!self.config.weekNumbers &&
|
|
/Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent);
|
|
for (var i = 0; i < self.config.plugins.length; i++) {
|
|
var pluginConf = self.config.plugins[i](self) || {};
|
|
for (var key in pluginConf) {
|
|
if (HOOKS.indexOf(key) > -1) {
|
|
self.config[key] = arrayify(pluginConf[key])
|
|
.map(bindToInstance)
|
|
.concat(self.config[key]);
|
|
}
|
|
else if (typeof userConfig[key] === "undefined")
|
|
self.config[key] = pluginConf[key];
|
|
}
|
|
}
|
|
triggerEvent("onParseConfig");
|
|
}
|
|
function setupLocale() {
|
|
if (typeof self.config.locale !== "object" &&
|
|
typeof flatpickr.l10ns[self.config.locale] === "undefined")
|
|
self.config.errorHandler(new Error("flatpickr: invalid locale " + self.config.locale));
|
|
self.l10n = __assign({}, flatpickr.l10ns["default"], (typeof self.config.locale === "object"
|
|
? self.config.locale
|
|
: self.config.locale !== "default"
|
|
? flatpickr.l10ns[self.config.locale]
|
|
: undefined));
|
|
tokenRegex.K = "(" + self.l10n.amPM[0] + "|" + self.l10n.amPM[1] + "|" + self.l10n.amPM[0].toLowerCase() + "|" + self.l10n.amPM[1].toLowerCase() + ")";
|
|
var userConfig = __assign({}, instanceConfig, JSON.parse(JSON.stringify(element.dataset || {})));
|
|
if (userConfig.time_24hr === undefined &&
|
|
flatpickr.defaultConfig.time_24hr === undefined) {
|
|
self.config.time_24hr = self.l10n.time_24hr;
|
|
}
|
|
self.formatDate = createDateFormatter(self);
|
|
self.parseDate = createDateParser({ config: self.config, l10n: self.l10n });
|
|
}
|
|
function positionCalendar(customPositionElement) {
|
|
if (self.calendarContainer === undefined)
|
|
return;
|
|
triggerEvent("onPreCalendarPosition");
|
|
var positionElement = customPositionElement || self._positionElement;
|
|
var calendarHeight = Array.prototype.reduce.call(self.calendarContainer.children, (function (acc, child) { return acc + child.offsetHeight; }), 0), calendarWidth = self.calendarContainer.offsetWidth, configPos = self.config.position.split(" "), configPosVertical = configPos[0], configPosHorizontal = configPos.length > 1 ? configPos[1] : null, inputBounds = positionElement.getBoundingClientRect(), distanceFromBottom = window.innerHeight - inputBounds.bottom, showOnTop = configPosVertical === "above" ||
|
|
(configPosVertical !== "below" &&
|
|
distanceFromBottom < calendarHeight &&
|
|
inputBounds.top > calendarHeight);
|
|
var top = window.pageYOffset +
|
|
inputBounds.top +
|
|
(!showOnTop ? positionElement.offsetHeight + 2 : -calendarHeight - 2);
|
|
toggleClass(self.calendarContainer, "arrowTop", !showOnTop);
|
|
toggleClass(self.calendarContainer, "arrowBottom", showOnTop);
|
|
if (self.config.inline)
|
|
return;
|
|
var left = window.pageXOffset +
|
|
inputBounds.left -
|
|
(configPosHorizontal != null && configPosHorizontal === "center"
|
|
? (calendarWidth - inputBounds.width) / 2
|
|
: 0);
|
|
var right = window.document.body.offsetWidth - inputBounds.right;
|
|
var rightMost = left + calendarWidth > window.document.body.offsetWidth;
|
|
var centerMost = right + calendarWidth > window.document.body.offsetWidth;
|
|
toggleClass(self.calendarContainer, "rightMost", rightMost);
|
|
if (self.config.static)
|
|
return;
|
|
self.calendarContainer.style.top = top + "px";
|
|
if (!rightMost) {
|
|
self.calendarContainer.style.left = left + "px";
|
|
self.calendarContainer.style.right = "auto";
|
|
}
|
|
else if (!centerMost) {
|
|
self.calendarContainer.style.left = "auto";
|
|
self.calendarContainer.style.right = right + "px";
|
|
}
|
|
else {
|
|
var doc = document.styleSheets[0];
|
|
// some testing environments don't have css support
|
|
if (doc === undefined)
|
|
return;
|
|
var bodyWidth = window.document.body.offsetWidth;
|
|
var centerLeft = Math.max(0, bodyWidth / 2 - calendarWidth / 2);
|
|
var centerBefore = ".flatpickr-calendar.centerMost:before";
|
|
var centerAfter = ".flatpickr-calendar.centerMost:after";
|
|
var centerIndex = doc.cssRules.length;
|
|
var centerStyle = "{left:" + inputBounds.left + "px;right:auto;}";
|
|
toggleClass(self.calendarContainer, "rightMost", false);
|
|
toggleClass(self.calendarContainer, "centerMost", true);
|
|
doc.insertRule(centerBefore + "," + centerAfter + centerStyle, centerIndex);
|
|
self.calendarContainer.style.left = centerLeft + "px";
|
|
self.calendarContainer.style.right = "auto";
|
|
}
|
|
}
|
|
function redraw() {
|
|
if (self.config.noCalendar || self.isMobile)
|
|
return;
|
|
updateNavigationCurrentMonth();
|
|
buildDays();
|
|
}
|
|
function focusAndClose() {
|
|
self._input.focus();
|
|
if (window.navigator.userAgent.indexOf("MSIE") !== -1 ||
|
|
navigator.msMaxTouchPoints !== undefined) {
|
|
// hack - bugs in the way IE handles focus keeps the calendar open
|
|
setTimeout(self.close, 0);
|
|
}
|
|
else {
|
|
self.close();
|
|
}
|
|
}
|
|
function selectDate(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
var isSelectable = function (day) {
|
|
return day.classList &&
|
|
day.classList.contains("flatpickr-day") &&
|
|
!day.classList.contains("flatpickr-disabled") &&
|
|
!day.classList.contains("notAllowed");
|
|
};
|
|
var t = findParent(e.target, isSelectable);
|
|
if (t === undefined)
|
|
return;
|
|
var target = t;
|
|
var selectedDate = (self.latestSelectedDateObj = new Date(target.dateObj.getTime()));
|
|
var shouldChangeMonth = (selectedDate.getMonth() < self.currentMonth ||
|
|
selectedDate.getMonth() >
|
|
self.currentMonth + self.config.showMonths - 1) &&
|
|
self.config.mode !== "range";
|
|
self.selectedDateElem = target;
|
|
if (self.config.mode === "single")
|
|
self.selectedDates = [selectedDate];
|
|
else if (self.config.mode === "multiple") {
|
|
var selectedIndex = isDateSelected(selectedDate);
|
|
if (selectedIndex)
|
|
self.selectedDates.splice(parseInt(selectedIndex), 1);
|
|
else
|
|
self.selectedDates.push(selectedDate);
|
|
}
|
|
else if (self.config.mode === "range") {
|
|
if (self.selectedDates.length === 2) {
|
|
self.clear(false, false);
|
|
}
|
|
self.latestSelectedDateObj = selectedDate;
|
|
self.selectedDates.push(selectedDate);
|
|
// unless selecting same date twice, sort ascendingly
|
|
if (compareDates(selectedDate, self.selectedDates[0], true) !== 0)
|
|
self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); });
|
|
}
|
|
setHoursFromInputs();
|
|
if (shouldChangeMonth) {
|
|
var isNewYear = self.currentYear !== selectedDate.getFullYear();
|
|
self.currentYear = selectedDate.getFullYear();
|
|
self.currentMonth = selectedDate.getMonth();
|
|
if (isNewYear) {
|
|
triggerEvent("onYearChange");
|
|
buildMonthSwitch();
|
|
}
|
|
triggerEvent("onMonthChange");
|
|
}
|
|
updateNavigationCurrentMonth();
|
|
buildDays();
|
|
updateValue();
|
|
if (self.config.enableTime)
|
|
setTimeout(function () { return (self.showTimeInput = true); }, 50);
|
|
// maintain focus
|
|
if (!shouldChangeMonth &&
|
|
self.config.mode !== "range" &&
|
|
self.config.showMonths === 1)
|
|
focusOnDayElem(target);
|
|
else if (self.selectedDateElem !== undefined &&
|
|
self.hourElement === undefined) {
|
|
self.selectedDateElem && self.selectedDateElem.focus();
|
|
}
|
|
if (self.hourElement !== undefined)
|
|
self.hourElement !== undefined && self.hourElement.focus();
|
|
if (self.config.closeOnSelect) {
|
|
var single = self.config.mode === "single" && !self.config.enableTime;
|
|
var range = self.config.mode === "range" &&
|
|
self.selectedDates.length === 2 &&
|
|
!self.config.enableTime;
|
|
if (single || range) {
|
|
focusAndClose();
|
|
}
|
|
}
|
|
triggerChange();
|
|
}
|
|
var CALLBACKS = {
|
|
locale: [setupLocale, updateWeekdays],
|
|
showMonths: [buildMonths, setCalendarWidth, buildWeekdays],
|
|
minDate: [jumpToDate],
|
|
maxDate: [jumpToDate]
|
|
};
|
|
function set(option, value) {
|
|
if (option !== null && typeof option === "object") {
|
|
Object.assign(self.config, option);
|
|
for (var key in option) {
|
|
if (CALLBACKS[key] !== undefined)
|
|
CALLBACKS[key].forEach(function (x) { return x(); });
|
|
}
|
|
}
|
|
else {
|
|
self.config[option] = value;
|
|
if (CALLBACKS[option] !== undefined)
|
|
CALLBACKS[option].forEach(function (x) { return x(); });
|
|
else if (HOOKS.indexOf(option) > -1)
|
|
self.config[option] = arrayify(value);
|
|
}
|
|
self.redraw();
|
|
updateValue(false);
|
|
}
|
|
function setSelectedDate(inputDate, format) {
|
|
var dates = [];
|
|
if (inputDate instanceof Array)
|
|
dates = inputDate.map(function (d) { return self.parseDate(d, format); });
|
|
else if (inputDate instanceof Date || typeof inputDate === "number")
|
|
dates = [self.parseDate(inputDate, format)];
|
|
else if (typeof inputDate === "string") {
|
|
switch (self.config.mode) {
|
|
case "single":
|
|
case "time":
|
|
dates = [self.parseDate(inputDate, format)];
|
|
break;
|
|
case "multiple":
|
|
dates = inputDate
|
|
.split(self.config.conjunction)
|
|
.map(function (date) { return self.parseDate(date, format); });
|
|
break;
|
|
case "range":
|
|
dates = inputDate
|
|
.split(self.l10n.rangeSeparator)
|
|
.map(function (date) { return self.parseDate(date, format); });
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
self.config.errorHandler(new Error("Invalid date supplied: " + JSON.stringify(inputDate)));
|
|
self.selectedDates = dates.filter(function (d) { return d instanceof Date && isEnabled(d, false); });
|
|
if (self.config.mode === "range")
|
|
self.selectedDates.sort(function (a, b) { return a.getTime() - b.getTime(); });
|
|
}
|
|
function setDate(date, triggerChange, format) {
|
|
if (triggerChange === void 0) { triggerChange = false; }
|
|
if (format === void 0) { format = self.config.dateFormat; }
|
|
if ((date !== 0 && !date) || (date instanceof Array && date.length === 0))
|
|
return self.clear(triggerChange);
|
|
setSelectedDate(date, format);
|
|
self.showTimeInput = self.selectedDates.length > 0;
|
|
self.latestSelectedDateObj =
|
|
self.selectedDates[self.selectedDates.length - 1];
|
|
self.redraw();
|
|
jumpToDate();
|
|
setHoursFromDate();
|
|
if (self.selectedDates.length === 0) {
|
|
self.clear(false);
|
|
}
|
|
updateValue(triggerChange);
|
|
if (triggerChange)
|
|
triggerEvent("onChange");
|
|
}
|
|
function parseDateRules(arr) {
|
|
return arr
|
|
.slice()
|
|
.map(function (rule) {
|
|
if (typeof rule === "string" ||
|
|
typeof rule === "number" ||
|
|
rule instanceof Date) {
|
|
return self.parseDate(rule, undefined, true);
|
|
}
|
|
else if (rule &&
|
|
typeof rule === "object" &&
|
|
rule.from &&
|
|
rule.to)
|
|
return {
|
|
from: self.parseDate(rule.from, undefined),
|
|
to: self.parseDate(rule.to, undefined)
|
|
};
|
|
return rule;
|
|
})
|
|
.filter(function (x) { return x; }); // remove falsy values
|
|
}
|
|
function setupDates() {
|
|
self.selectedDates = [];
|
|
self.now = self.parseDate(self.config.now) || new Date();
|
|
// Workaround IE11 setting placeholder as the input's value
|
|
var preloadedDate = self.config.defaultDate ||
|
|
((self.input.nodeName === "INPUT" ||
|
|
self.input.nodeName === "TEXTAREA") &&
|
|
self.input.placeholder &&
|
|
self.input.value === self.input.placeholder
|
|
? null
|
|
: self.input.value);
|
|
if (preloadedDate)
|
|
setSelectedDate(preloadedDate, self.config.dateFormat);
|
|
self._initialDate =
|
|
self.selectedDates.length > 0
|
|
? self.selectedDates[0]
|
|
: self.config.minDate &&
|
|
self.config.minDate.getTime() > self.now.getTime()
|
|
? self.config.minDate
|
|
: self.config.maxDate &&
|
|
self.config.maxDate.getTime() < self.now.getTime()
|
|
? self.config.maxDate
|
|
: self.now;
|
|
self.currentYear = self._initialDate.getFullYear();
|
|
self.currentMonth = self._initialDate.getMonth();
|
|
if (self.selectedDates.length > 0)
|
|
self.latestSelectedDateObj = self.selectedDates[0];
|
|
if (self.config.minTime !== undefined)
|
|
self.config.minTime = self.parseDate(self.config.minTime, "H:i");
|
|
if (self.config.maxTime !== undefined)
|
|
self.config.maxTime = self.parseDate(self.config.maxTime, "H:i");
|
|
self.minDateHasTime =
|
|
!!self.config.minDate &&
|
|
(self.config.minDate.getHours() > 0 ||
|
|
self.config.minDate.getMinutes() > 0 ||
|
|
self.config.minDate.getSeconds() > 0);
|
|
self.maxDateHasTime =
|
|
!!self.config.maxDate &&
|
|
(self.config.maxDate.getHours() > 0 ||
|
|
self.config.maxDate.getMinutes() > 0 ||
|
|
self.config.maxDate.getSeconds() > 0);
|
|
Object.defineProperty(self, "showTimeInput", {
|
|
get: function () { return self._showTimeInput; },
|
|
set: function (bool) {
|
|
self._showTimeInput = bool;
|
|
if (self.calendarContainer)
|
|
toggleClass(self.calendarContainer, "showTimeInput", bool);
|
|
self.isOpen && positionCalendar();
|
|
}
|
|
});
|
|
}
|
|
function setupInputs() {
|
|
self.input = self.config.wrap
|
|
? element.querySelector("[data-input]")
|
|
: element;
|
|
/* istanbul ignore next */
|
|
if (!self.input) {
|
|
self.config.errorHandler(new Error("Invalid input element specified"));
|
|
return;
|
|
}
|
|
// hack: store previous type to restore it after destroy()
|
|
self.input._type = self.input.type;
|
|
self.input.type = "text";
|
|
self.input.classList.add("flatpickr-input");
|
|
self._input = self.input;
|
|
if (self.config.altInput) {
|
|
// replicate self.element
|
|
self.altInput = createElement(self.input.nodeName, self.config.altInputClass);
|
|
self._input = self.altInput;
|
|
self.altInput.placeholder = self.input.placeholder;
|
|
self.altInput.disabled = self.input.disabled;
|
|
self.altInput.required = self.input.required;
|
|
self.altInput.tabIndex = self.input.tabIndex;
|
|
self.altInput.type = "text";
|
|
self.input.setAttribute("type", "hidden");
|
|
if (!self.config.static && self.input.parentNode)
|
|
self.input.parentNode.insertBefore(self.altInput, self.input.nextSibling);
|
|
}
|
|
if (!self.config.allowInput)
|
|
self._input.setAttribute("readonly", "readonly");
|
|
self._positionElement = self.config.positionElement || self._input;
|
|
}
|
|
function setupMobile() {
|
|
var inputType = self.config.enableTime
|
|
? self.config.noCalendar
|
|
? "time"
|
|
: "datetime-local"
|
|
: "date";
|
|
self.mobileInput = createElement("input", self.input.className + " flatpickr-mobile");
|
|
self.mobileInput.step = self.input.getAttribute("step") || "any";
|
|
self.mobileInput.tabIndex = 1;
|
|
self.mobileInput.type = inputType;
|
|
self.mobileInput.disabled = self.input.disabled;
|
|
self.mobileInput.required = self.input.required;
|
|
self.mobileInput.placeholder = self.input.placeholder;
|
|
self.mobileFormatStr =
|
|
inputType === "datetime-local"
|
|
? "Y-m-d\\TH:i:S"
|
|
: inputType === "date"
|
|
? "Y-m-d"
|
|
: "H:i:S";
|
|
if (self.selectedDates.length > 0) {
|
|
self.mobileInput.defaultValue = self.mobileInput.value = self.formatDate(self.selectedDates[0], self.mobileFormatStr);
|
|
}
|
|
if (self.config.minDate)
|
|
self.mobileInput.min = self.formatDate(self.config.minDate, "Y-m-d");
|
|
if (self.config.maxDate)
|
|
self.mobileInput.max = self.formatDate(self.config.maxDate, "Y-m-d");
|
|
self.input.type = "hidden";
|
|
if (self.altInput !== undefined)
|
|
self.altInput.type = "hidden";
|
|
try {
|
|
if (self.input.parentNode)
|
|
self.input.parentNode.insertBefore(self.mobileInput, self.input.nextSibling);
|
|
}
|
|
catch (_a) { }
|
|
bind(self.mobileInput, "change", function (e) {
|
|
self.setDate(e.target.value, false, self.mobileFormatStr);
|
|
triggerEvent("onChange");
|
|
triggerEvent("onClose");
|
|
});
|
|
}
|
|
function toggle(e) {
|
|
if (self.isOpen === true)
|
|
return self.close();
|
|
self.open(e);
|
|
}
|
|
function triggerEvent(event, data) {
|
|
// If the instance has been destroyed already, all hooks have been removed
|
|
if (self.config === undefined)
|
|
return;
|
|
var hooks = self.config[event];
|
|
if (hooks !== undefined && hooks.length > 0) {
|
|
for (var i = 0; hooks[i] && i < hooks.length; i++)
|
|
hooks[i](self.selectedDates, self.input.value, self, data);
|
|
}
|
|
if (event === "onChange") {
|
|
self.input.dispatchEvent(createEvent("change"));
|
|
// many front-end frameworks bind to the input event
|
|
self.input.dispatchEvent(createEvent("input"));
|
|
}
|
|
}
|
|
function createEvent(name) {
|
|
var e = document.createEvent("Event");
|
|
e.initEvent(name, true, true);
|
|
return e;
|
|
}
|
|
function isDateSelected(date) {
|
|
for (var i = 0; i < self.selectedDates.length; i++) {
|
|
if (compareDates(self.selectedDates[i], date) === 0)
|
|
return "" + i;
|
|
}
|
|
return false;
|
|
}
|
|
function isDateInRange(date) {
|
|
if (self.config.mode !== "range" || self.selectedDates.length < 2)
|
|
return false;
|
|
return (compareDates(date, self.selectedDates[0]) >= 0 &&
|
|
compareDates(date, self.selectedDates[1]) <= 0);
|
|
}
|
|
function updateNavigationCurrentMonth() {
|
|
if (self.config.noCalendar || self.isMobile || !self.monthNav)
|
|
return;
|
|
self.yearElements.forEach(function (yearElement, i) {
|
|
var d = new Date(self.currentYear, self.currentMonth, 1);
|
|
d.setMonth(self.currentMonth + i);
|
|
if (self.config.showMonths > 1 ||
|
|
self.config.monthSelectorType === "static") {
|
|
self.monthElements[i].textContent =
|
|
monthToStr(d.getMonth(), self.config.shorthandCurrentMonth, self.l10n) + " ";
|
|
}
|
|
else {
|
|
self.monthsDropdownContainer.value = d.getMonth().toString();
|
|
}
|
|
yearElement.value = d.getFullYear().toString();
|
|
});
|
|
self._hidePrevMonthArrow =
|
|
self.config.minDate !== undefined &&
|
|
(self.currentYear === self.config.minDate.getFullYear()
|
|
? self.currentMonth <= self.config.minDate.getMonth()
|
|
: self.currentYear < self.config.minDate.getFullYear());
|
|
self._hideNextMonthArrow =
|
|
self.config.maxDate !== undefined &&
|
|
(self.currentYear === self.config.maxDate.getFullYear()
|
|
? self.currentMonth + 1 > self.config.maxDate.getMonth()
|
|
: self.currentYear > self.config.maxDate.getFullYear());
|
|
}
|
|
function getDateStr(format) {
|
|
return self.selectedDates
|
|
.map(function (dObj) { return self.formatDate(dObj, format); })
|
|
.filter(function (d, i, arr) {
|
|
return self.config.mode !== "range" ||
|
|
self.config.enableTime ||
|
|
arr.indexOf(d) === i;
|
|
})
|
|
.join(self.config.mode !== "range"
|
|
? self.config.conjunction
|
|
: self.l10n.rangeSeparator);
|
|
}
|
|
/**
|
|
* Updates the values of inputs associated with the calendar
|
|
*/
|
|
function updateValue(triggerChange) {
|
|
if (triggerChange === void 0) { triggerChange = true; }
|
|
if (self.mobileInput !== undefined && self.mobileFormatStr) {
|
|
self.mobileInput.value =
|
|
self.latestSelectedDateObj !== undefined
|
|
? self.formatDate(self.latestSelectedDateObj, self.mobileFormatStr)
|
|
: "";
|
|
}
|
|
self.input.value = getDateStr(self.config.dateFormat);
|
|
if (self.altInput !== undefined) {
|
|
self.altInput.value = getDateStr(self.config.altFormat);
|
|
}
|
|
if (triggerChange !== false)
|
|
triggerEvent("onValueUpdate");
|
|
}
|
|
function onMonthNavClick(e) {
|
|
var isPrevMonth = self.prevMonthNav.contains(e.target);
|
|
var isNextMonth = self.nextMonthNav.contains(e.target);
|
|
if (isPrevMonth || isNextMonth) {
|
|
changeMonth(isPrevMonth ? -1 : 1);
|
|
}
|
|
else if (self.yearElements.indexOf(e.target) >= 0) {
|
|
e.target.select();
|
|
}
|
|
else if (e.target.classList.contains("arrowUp")) {
|
|
self.changeYear(self.currentYear + 1);
|
|
}
|
|
else if (e.target.classList.contains("arrowDown")) {
|
|
self.changeYear(self.currentYear - 1);
|
|
}
|
|
}
|
|
function timeWrapper(e) {
|
|
e.preventDefault();
|
|
var isKeyDown = e.type === "keydown", input = e.target;
|
|
if (self.amPM !== undefined && e.target === self.amPM) {
|
|
self.amPM.textContent =
|
|
self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])];
|
|
}
|
|
var min = parseFloat(input.getAttribute("min")), max = parseFloat(input.getAttribute("max")), step = parseFloat(input.getAttribute("step")), curValue = parseInt(input.value, 10), delta = e.delta ||
|
|
(isKeyDown ? (e.which === 38 ? 1 : -1) : 0);
|
|
var newValue = curValue + step * delta;
|
|
if (typeof input.value !== "undefined" && input.value.length === 2) {
|
|
var isHourElem = input === self.hourElement, isMinuteElem = input === self.minuteElement;
|
|
if (newValue < min) {
|
|
newValue =
|
|
max +
|
|
newValue +
|
|
int(!isHourElem) +
|
|
(int(isHourElem) && int(!self.amPM));
|
|
if (isMinuteElem)
|
|
incrementNumInput(undefined, -1, self.hourElement);
|
|
}
|
|
else if (newValue > max) {
|
|
newValue =
|
|
input === self.hourElement ? newValue - max - int(!self.amPM) : min;
|
|
if (isMinuteElem)
|
|
incrementNumInput(undefined, 1, self.hourElement);
|
|
}
|
|
if (self.amPM &&
|
|
isHourElem &&
|
|
(step === 1
|
|
? newValue + curValue === 23
|
|
: Math.abs(newValue - curValue) > step)) {
|
|
self.amPM.textContent =
|
|
self.l10n.amPM[int(self.amPM.textContent === self.l10n.amPM[0])];
|
|
}
|
|
input.value = pad(newValue);
|
|
}
|
|
}
|
|
init();
|
|
return self;
|
|
}
|
|
/* istanbul ignore next */
|
|
function _flatpickr(nodeList, config) {
|
|
// static list
|
|
var nodes = Array.prototype.slice
|
|
.call(nodeList)
|
|
.filter(function (x) { return x instanceof HTMLElement; });
|
|
var instances = [];
|
|
for (var i = 0; i < nodes.length; i++) {
|
|
var node = nodes[i];
|
|
try {
|
|
if (node.getAttribute("data-fp-omit") !== null)
|
|
continue;
|
|
if (node._flatpickr !== undefined) {
|
|
node._flatpickr.destroy();
|
|
node._flatpickr = undefined;
|
|
}
|
|
node._flatpickr = FlatpickrInstance(node, config || {});
|
|
instances.push(node._flatpickr);
|
|
}
|
|
catch (e) {
|
|
console.error(e);
|
|
}
|
|
}
|
|
return instances.length === 1 ? instances[0] : instances;
|
|
}
|
|
/* istanbul ignore next */
|
|
if (typeof HTMLElement !== "undefined" &&
|
|
typeof HTMLCollection !== "undefined" &&
|
|
typeof NodeList !== "undefined") {
|
|
// browser env
|
|
HTMLCollection.prototype.flatpickr = NodeList.prototype.flatpickr = function (config) {
|
|
return _flatpickr(this, config);
|
|
};
|
|
HTMLElement.prototype.flatpickr = function (config) {
|
|
return _flatpickr([this], config);
|
|
};
|
|
}
|
|
/* istanbul ignore next */
|
|
var flatpickr = function (selector, config) {
|
|
if (typeof selector === "string") {
|
|
return _flatpickr(window.document.querySelectorAll(selector), config);
|
|
}
|
|
else if (selector instanceof Node) {
|
|
return _flatpickr([selector], config);
|
|
}
|
|
else {
|
|
return _flatpickr(selector, config);
|
|
}
|
|
};
|
|
/* istanbul ignore next */
|
|
flatpickr.defaultConfig = {};
|
|
flatpickr.l10ns = {
|
|
en: __assign({}, english),
|
|
"default": __assign({}, english)
|
|
};
|
|
flatpickr.localize = function (l10n) {
|
|
flatpickr.l10ns["default"] = __assign({}, flatpickr.l10ns["default"], l10n);
|
|
};
|
|
flatpickr.setDefaults = function (config) {
|
|
flatpickr.defaultConfig = __assign({}, flatpickr.defaultConfig, config);
|
|
};
|
|
flatpickr.parseDate = createDateParser({});
|
|
flatpickr.formatDate = createDateFormatter({});
|
|
flatpickr.compareDates = compareDates;
|
|
/* istanbul ignore next */
|
|
if (typeof jQuery !== "undefined" && typeof jQuery.fn !== "undefined") {
|
|
jQuery.fn.flatpickr = function (config) {
|
|
return _flatpickr(this, config);
|
|
};
|
|
}
|
|
// eslint-disable-next-line @typescript-eslint/camelcase
|
|
Date.prototype.fp_incr = function (days) {
|
|
return new Date(this.getFullYear(), this.getMonth(), this.getDate() + (typeof days === "string" ? parseInt(days, 10) : days));
|
|
};
|
|
if (typeof window !== "undefined") {
|
|
window.flatpickr = flatpickr;
|
|
}
|
|
|
|
return flatpickr;
|
|
|
|
}));
|
|
});
|
|
|
|
/* src\common\DatePicker.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$d = "src\\common\\DatePicker.svelte";
|
|
|
|
function create_fragment$c(ctx) {
|
|
var div1, div0, t0, t1, input_1;
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(ctx.label);
|
|
t1 = space();
|
|
input_1 = element("input");
|
|
attr(div0, "class", "label svelte-1pf9x5k");
|
|
add_location(div0, file$d, 34, 4, 545);
|
|
attr(input_1, "class", "control svelte-1pf9x5k");
|
|
add_location(input_1, file$d, 35, 4, 583);
|
|
attr(div1, "class", "container svelte-1pf9x5k");
|
|
add_location(div1, file$d, 33, 1, 515);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
append(div0, t0);
|
|
append(div1, t1);
|
|
append(div1, input_1);
|
|
ctx.input_1_binding(input_1);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.label) {
|
|
set_data(t0, ctx.label);
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
ctx.input_1_binding(null);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$c($$self, $$props, $$invalidate) {
|
|
|
|
|
|
let { value, label } = $$props;
|
|
let input;
|
|
let fpInstance;
|
|
|
|
onMount(() => {
|
|
$$invalidate('fpInstance', fpInstance = flatpickr(input, {}));
|
|
|
|
fpInstance.config.onChange.push(selectedDates => {
|
|
if(selectedDates.length > 0)
|
|
$$invalidate('value', value = new Date(selectedDates[0]));
|
|
});
|
|
|
|
return fpInstance;
|
|
});
|
|
|
|
const writable_props = ['value', 'label'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<DatePicker> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function input_1_binding($$value) {
|
|
binding_callbacks[$$value ? 'unshift' : 'push'](() => {
|
|
$$invalidate('input', input = $$value);
|
|
});
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('value' in $$props) $$invalidate('value', value = $$props.value);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
};
|
|
|
|
$$self.$$.update = ($$dirty = { fpInstance: 1, value: 1 }) => {
|
|
if ($$dirty.fpInstance || $$dirty.value) { if (fpInstance) fpInstance.setDate(value); }
|
|
};
|
|
|
|
return { value, label, input, input_1_binding };
|
|
}
|
|
|
|
class DatePicker extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$c, create_fragment$c, safe_not_equal, ["value", "label"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.value === undefined && !('value' in props)) {
|
|
console.warn("<DatePicker> was created without expected prop 'value'");
|
|
}
|
|
if (ctx.label === undefined && !('label' in props)) {
|
|
console.warn("<DatePicker> was created without expected prop 'label'");
|
|
}
|
|
}
|
|
|
|
get value() {
|
|
throw new Error("<DatePicker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set value(value) {
|
|
throw new Error("<DatePicker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<DatePicker>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<DatePicker>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\database\FieldView.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$e = "src\\database\\FieldView.svelte";
|
|
|
|
// (66:4) {:else}
|
|
function create_else_block$1(ctx) {
|
|
var div, t_value = ctx.clonedField.name, t;
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
t = text(t_value);
|
|
set_style(div, "font-weight", "bold");
|
|
add_location(div, file$e, 66, 4, 2026);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, t);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.clonedField) && t_value !== (t_value = ctx.clonedField.name)) {
|
|
set_data(t, t_value);
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (64:4) {#if isNew}
|
|
function create_if_block_6(ctx) {
|
|
var updating_text, current;
|
|
|
|
function textbox_text_binding(value) {
|
|
ctx.textbox_text_binding.call(null, value);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox_props = { label: "Field Name" };
|
|
if (ctx.clonedField.name !== void 0) {
|
|
textbox_props.text = ctx.clonedField.name;
|
|
}
|
|
var textbox = new Textbox({ props: textbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox, 'text', textbox_text_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
textbox.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(textbox, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var textbox_changes = {};
|
|
if (!updating_text && changed.clonedField) {
|
|
textbox_changes.text = ctx.clonedField.name;
|
|
}
|
|
textbox.$set(textbox_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(textbox.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(textbox.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(textbox, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (101:51)
|
|
function create_if_block_5(ctx) {
|
|
var updating_value, t, updating_value_1, current;
|
|
|
|
function numberbox0_value_binding_1(value) {
|
|
ctx.numberbox0_value_binding_1.call(null, value);
|
|
updating_value = true;
|
|
add_flush_callback(() => updating_value = false);
|
|
}
|
|
|
|
let numberbox0_props = { label: "Min Length" };
|
|
if (ctx.clonedField.typeOptions.minLength !== void 0) {
|
|
numberbox0_props.value = ctx.clonedField.typeOptions.minLength;
|
|
}
|
|
var numberbox0 = new NumberBox({ props: numberbox0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(numberbox0, 'value', numberbox0_value_binding_1));
|
|
|
|
function numberbox1_value_binding_1(value_1) {
|
|
ctx.numberbox1_value_binding_1.call(null, value_1);
|
|
updating_value_1 = true;
|
|
add_flush_callback(() => updating_value_1 = false);
|
|
}
|
|
|
|
let numberbox1_props = { label: "Max Length" };
|
|
if (ctx.clonedField.typeOptions.maxLength !== void 0) {
|
|
numberbox1_props.value = ctx.clonedField.typeOptions.maxLength;
|
|
}
|
|
var numberbox1 = new NumberBox({ props: numberbox1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(numberbox1, 'value', numberbox1_value_binding_1));
|
|
|
|
return {
|
|
c: function create() {
|
|
numberbox0.$$.fragment.c();
|
|
t = space();
|
|
numberbox1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(numberbox0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(numberbox1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var numberbox0_changes = {};
|
|
if (!updating_value && changed.clonedField) {
|
|
numberbox0_changes.value = ctx.clonedField.typeOptions.minLength;
|
|
}
|
|
numberbox0.$set(numberbox0_changes);
|
|
|
|
var numberbox1_changes = {};
|
|
if (!updating_value_1 && changed.clonedField) {
|
|
numberbox1_changes.value = ctx.clonedField.typeOptions.maxLength;
|
|
}
|
|
numberbox1.$set(numberbox1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(numberbox0.$$.fragment, local);
|
|
|
|
transition_in(numberbox1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(numberbox0.$$.fragment, local);
|
|
transition_out(numberbox1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(numberbox0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(numberbox1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (85:47)
|
|
function create_if_block_4(ctx) {
|
|
var updating_selected, t0, updating_selected_1, t1, updating_text, current;
|
|
|
|
function dropdown0_selected_binding(value) {
|
|
ctx.dropdown0_selected_binding.call(null, value);
|
|
updating_selected = true;
|
|
add_flush_callback(() => updating_selected = false);
|
|
}
|
|
|
|
let dropdown0_props = {
|
|
label: "Lookup Index",
|
|
options: ctx.possibleReferenceIndexes,
|
|
valueMember: func,
|
|
textMember: func_1
|
|
};
|
|
if (ctx.clonedField.typeOptions.indexNodeKey !== void 0) {
|
|
dropdown0_props.selected = ctx.clonedField.typeOptions.indexNodeKey;
|
|
}
|
|
var dropdown0 = new Dropdown({ props: dropdown0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(dropdown0, 'selected', dropdown0_selected_binding));
|
|
|
|
function dropdown1_selected_binding(value_1) {
|
|
ctx.dropdown1_selected_binding.call(null, value_1);
|
|
updating_selected_1 = true;
|
|
add_flush_callback(() => updating_selected_1 = false);
|
|
}
|
|
|
|
let dropdown1_props = {
|
|
label: "Reverse Reference Index",
|
|
options: ctx.possibleReverseReferenceIndexes,
|
|
multiple: "true",
|
|
valueMember: func_2,
|
|
textMember: func_3
|
|
};
|
|
if (ctx.clonedField.typeOptions.reverseIndexNodeKeys !== void 0) {
|
|
dropdown1_props.selected = ctx.clonedField.typeOptions.reverseIndexNodeKeys;
|
|
}
|
|
var dropdown1 = new Dropdown({ props: dropdown1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(dropdown1, 'selected', dropdown1_selected_binding));
|
|
|
|
function textbox_text_binding_2(value_2) {
|
|
ctx.textbox_text_binding_2.call(null, value_2);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox_props = { label: "Display Value" };
|
|
if (ctx.clonedField.typeOptions.displayValue !== void 0) {
|
|
textbox_props.text = ctx.clonedField.typeOptions.displayValue;
|
|
}
|
|
var textbox = new Textbox({ props: textbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox, 'text', textbox_text_binding_2));
|
|
|
|
return {
|
|
c: function create() {
|
|
dropdown0.$$.fragment.c();
|
|
t0 = space();
|
|
dropdown1.$$.fragment.c();
|
|
t1 = space();
|
|
textbox.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(dropdown0, target, anchor);
|
|
insert(target, t0, anchor);
|
|
mount_component(dropdown1, target, anchor);
|
|
insert(target, t1, anchor);
|
|
mount_component(textbox, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var dropdown0_changes = {};
|
|
if (changed.possibleReferenceIndexes) dropdown0_changes.options = ctx.possibleReferenceIndexes;
|
|
if (!updating_selected && changed.clonedField) {
|
|
dropdown0_changes.selected = ctx.clonedField.typeOptions.indexNodeKey;
|
|
}
|
|
dropdown0.$set(dropdown0_changes);
|
|
|
|
var dropdown1_changes = {};
|
|
if (changed.possibleReverseReferenceIndexes) dropdown1_changes.options = ctx.possibleReverseReferenceIndexes;
|
|
if (!updating_selected_1 && changed.clonedField) {
|
|
dropdown1_changes.selected = ctx.clonedField.typeOptions.reverseIndexNodeKeys;
|
|
}
|
|
dropdown1.$set(dropdown1_changes);
|
|
|
|
var textbox_changes = {};
|
|
if (!updating_text && changed.clonedField) {
|
|
textbox_changes.text = ctx.clonedField.typeOptions.displayValue;
|
|
}
|
|
textbox.$set(textbox_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(dropdown0.$$.fragment, local);
|
|
|
|
transition_in(dropdown1.$$.fragment, local);
|
|
|
|
transition_in(textbox.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(dropdown0.$$.fragment, local);
|
|
transition_out(dropdown1.$$.fragment, local);
|
|
transition_out(textbox.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(dropdown0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t0);
|
|
}
|
|
|
|
destroy_component(dropdown1, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t1);
|
|
}
|
|
|
|
destroy_component(textbox, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (81:44)
|
|
function create_if_block_3(ctx) {
|
|
var updating_value, t0, updating_value_1, t1, updating_value_2, current;
|
|
|
|
function numberbox0_value_binding(value) {
|
|
ctx.numberbox0_value_binding.call(null, value);
|
|
updating_value = true;
|
|
add_flush_callback(() => updating_value = false);
|
|
}
|
|
|
|
let numberbox0_props = { label: "Min Value" };
|
|
if (ctx.clonedField.typeOptions.minValue !== void 0) {
|
|
numberbox0_props.value = ctx.clonedField.typeOptions.minValue;
|
|
}
|
|
var numberbox0 = new NumberBox({ props: numberbox0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(numberbox0, 'value', numberbox0_value_binding));
|
|
|
|
function numberbox1_value_binding(value_1) {
|
|
ctx.numberbox1_value_binding.call(null, value_1);
|
|
updating_value_1 = true;
|
|
add_flush_callback(() => updating_value_1 = false);
|
|
}
|
|
|
|
let numberbox1_props = { label: "Max Value" };
|
|
if (ctx.clonedField.typeOptions.maxValue !== void 0) {
|
|
numberbox1_props.value = ctx.clonedField.typeOptions.maxValue;
|
|
}
|
|
var numberbox1 = new NumberBox({ props: numberbox1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(numberbox1, 'value', numberbox1_value_binding));
|
|
|
|
function numberbox2_value_binding(value_2) {
|
|
ctx.numberbox2_value_binding.call(null, value_2);
|
|
updating_value_2 = true;
|
|
add_flush_callback(() => updating_value_2 = false);
|
|
}
|
|
|
|
let numberbox2_props = { label: "Decimal Places" };
|
|
if (ctx.clonedField.typeOptions.decimalPlaces !== void 0) {
|
|
numberbox2_props.value = ctx.clonedField.typeOptions.decimalPlaces;
|
|
}
|
|
var numberbox2 = new NumberBox({ props: numberbox2_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(numberbox2, 'value', numberbox2_value_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
numberbox0.$$.fragment.c();
|
|
t0 = space();
|
|
numberbox1.$$.fragment.c();
|
|
t1 = space();
|
|
numberbox2.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(numberbox0, target, anchor);
|
|
insert(target, t0, anchor);
|
|
mount_component(numberbox1, target, anchor);
|
|
insert(target, t1, anchor);
|
|
mount_component(numberbox2, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var numberbox0_changes = {};
|
|
if (!updating_value && changed.clonedField) {
|
|
numberbox0_changes.value = ctx.clonedField.typeOptions.minValue;
|
|
}
|
|
numberbox0.$set(numberbox0_changes);
|
|
|
|
var numberbox1_changes = {};
|
|
if (!updating_value_1 && changed.clonedField) {
|
|
numberbox1_changes.value = ctx.clonedField.typeOptions.maxValue;
|
|
}
|
|
numberbox1.$set(numberbox1_changes);
|
|
|
|
var numberbox2_changes = {};
|
|
if (!updating_value_2 && changed.clonedField) {
|
|
numberbox2_changes.value = ctx.clonedField.typeOptions.decimalPlaces;
|
|
}
|
|
numberbox2.$set(numberbox2_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(numberbox0.$$.fragment, local);
|
|
|
|
transition_in(numberbox1.$$.fragment, local);
|
|
|
|
transition_in(numberbox2.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(numberbox0.$$.fragment, local);
|
|
transition_out(numberbox1.$$.fragment, local);
|
|
transition_out(numberbox2.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(numberbox0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t0);
|
|
}
|
|
|
|
destroy_component(numberbox1, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t1);
|
|
}
|
|
|
|
destroy_component(numberbox2, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (78:46)
|
|
function create_if_block_2(ctx) {
|
|
var updating_value, t, updating_value_1, current;
|
|
|
|
function datepicker0_value_binding(value) {
|
|
ctx.datepicker0_value_binding.call(null, value);
|
|
updating_value = true;
|
|
add_flush_callback(() => updating_value = false);
|
|
}
|
|
|
|
let datepicker0_props = { label: "Min Value" };
|
|
if (ctx.clonedField.typeOptions.minValue !== void 0) {
|
|
datepicker0_props.value = ctx.clonedField.typeOptions.minValue;
|
|
}
|
|
var datepicker0 = new DatePicker({ props: datepicker0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(datepicker0, 'value', datepicker0_value_binding));
|
|
|
|
function datepicker1_value_binding(value_1) {
|
|
ctx.datepicker1_value_binding.call(null, value_1);
|
|
updating_value_1 = true;
|
|
add_flush_callback(() => updating_value_1 = false);
|
|
}
|
|
|
|
let datepicker1_props = { label: "Max Value" };
|
|
if (ctx.clonedField.typeOptions.maxValue !== void 0) {
|
|
datepicker1_props.value = ctx.clonedField.typeOptions.maxValue;
|
|
}
|
|
var datepicker1 = new DatePicker({ props: datepicker1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(datepicker1, 'value', datepicker1_value_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
datepicker0.$$.fragment.c();
|
|
t = space();
|
|
datepicker1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(datepicker0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(datepicker1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var datepicker0_changes = {};
|
|
if (!updating_value && changed.clonedField) {
|
|
datepicker0_changes.value = ctx.clonedField.typeOptions.minValue;
|
|
}
|
|
datepicker0.$set(datepicker0_changes);
|
|
|
|
var datepicker1_changes = {};
|
|
if (!updating_value_1 && changed.clonedField) {
|
|
datepicker1_changes.value = ctx.clonedField.typeOptions.maxValue;
|
|
}
|
|
datepicker1.$set(datepicker1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(datepicker0.$$.fragment, local);
|
|
|
|
transition_in(datepicker1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(datepicker0.$$.fragment, local);
|
|
transition_out(datepicker1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(datepicker0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(datepicker1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (76:42)
|
|
function create_if_block_1(ctx) {
|
|
var updating_checked, current;
|
|
|
|
function checkbox_checked_binding_1(value) {
|
|
ctx.checkbox_checked_binding_1.call(null, value);
|
|
updating_checked = true;
|
|
add_flush_callback(() => updating_checked = false);
|
|
}
|
|
|
|
let checkbox_props = { label: "Allow Null" };
|
|
if (ctx.clonedField.typeOptions.allowNulls !== void 0) {
|
|
checkbox_props.checked = ctx.clonedField.typeOptions.allowNulls;
|
|
}
|
|
var checkbox = new Checkbox({ props: checkbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(checkbox, 'checked', checkbox_checked_binding_1));
|
|
|
|
return {
|
|
c: function create() {
|
|
checkbox.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(checkbox, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var checkbox_changes = {};
|
|
if (!updating_checked && changed.clonedField) {
|
|
checkbox_changes.checked = ctx.clonedField.typeOptions.allowNulls;
|
|
}
|
|
checkbox.$set(checkbox_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(checkbox.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(checkbox.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(checkbox, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (72:4) {#if clonedField.type === "string"}
|
|
function create_if_block$3(ctx) {
|
|
var updating_value, t0, updating_values, t1, updating_checked, current;
|
|
|
|
function numberbox_value_binding(value) {
|
|
ctx.numberbox_value_binding.call(null, value);
|
|
updating_value = true;
|
|
add_flush_callback(() => updating_value = false);
|
|
}
|
|
|
|
let numberbox_props = { label: "Max Length" };
|
|
if (ctx.clonedField.typeOptions.maxLength !== void 0) {
|
|
numberbox_props.value = ctx.clonedField.typeOptions.maxLength;
|
|
}
|
|
var numberbox = new NumberBox({ props: numberbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(numberbox, 'value', numberbox_value_binding));
|
|
|
|
function valueslist_values_binding(value_1) {
|
|
ctx.valueslist_values_binding.call(null, value_1);
|
|
updating_values = true;
|
|
add_flush_callback(() => updating_values = false);
|
|
}
|
|
|
|
let valueslist_props = { label: "Values (options)" };
|
|
if (ctx.clonedField.typeOptions.values !== void 0) {
|
|
valueslist_props.values = ctx.clonedField.typeOptions.values;
|
|
}
|
|
var valueslist = new ValuesList({ props: valueslist_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(valueslist, 'values', valueslist_values_binding));
|
|
|
|
function checkbox_checked_binding(value_2) {
|
|
ctx.checkbox_checked_binding.call(null, value_2);
|
|
updating_checked = true;
|
|
add_flush_callback(() => updating_checked = false);
|
|
}
|
|
|
|
let checkbox_props = { label: "Declared Values Only" };
|
|
if (ctx.clonedField.typeOptions.allowDeclaredValuesOnly !== void 0) {
|
|
checkbox_props.checked = ctx.clonedField.typeOptions.allowDeclaredValuesOnly;
|
|
}
|
|
var checkbox = new Checkbox({ props: checkbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(checkbox, 'checked', checkbox_checked_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
numberbox.$$.fragment.c();
|
|
t0 = space();
|
|
valueslist.$$.fragment.c();
|
|
t1 = space();
|
|
checkbox.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(numberbox, target, anchor);
|
|
insert(target, t0, anchor);
|
|
mount_component(valueslist, target, anchor);
|
|
insert(target, t1, anchor);
|
|
mount_component(checkbox, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var numberbox_changes = {};
|
|
if (!updating_value && changed.clonedField) {
|
|
numberbox_changes.value = ctx.clonedField.typeOptions.maxLength;
|
|
}
|
|
numberbox.$set(numberbox_changes);
|
|
|
|
var valueslist_changes = {};
|
|
if (!updating_values && changed.clonedField) {
|
|
valueslist_changes.values = ctx.clonedField.typeOptions.values;
|
|
}
|
|
valueslist.$set(valueslist_changes);
|
|
|
|
var checkbox_changes = {};
|
|
if (!updating_checked && changed.clonedField) {
|
|
checkbox_changes.checked = ctx.clonedField.typeOptions.allowDeclaredValuesOnly;
|
|
}
|
|
checkbox.$set(checkbox_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(numberbox.$$.fragment, local);
|
|
|
|
transition_in(valueslist.$$.fragment, local);
|
|
|
|
transition_in(checkbox.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(numberbox.$$.fragment, local);
|
|
transition_out(valueslist.$$.fragment, local);
|
|
transition_out(checkbox.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(numberbox, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t0);
|
|
}
|
|
|
|
destroy_component(valueslist, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t1);
|
|
}
|
|
|
|
destroy_component(checkbox, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (107:8) <Button color="primary" grouped on:click={save}>
|
|
function create_default_slot_2(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Save");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (108:8) <Button color="secondary" grouped on:click={() => onFinished(false)}>
|
|
function create_default_slot_1(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Cancel");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (106:4) <ButtonGroup style="float: right;">
|
|
function create_default_slot(ctx) {
|
|
var t, current;
|
|
|
|
var button0 = new Button({
|
|
props: {
|
|
color: "primary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_2] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button0.$on("click", ctx.save);
|
|
|
|
var button1 = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_1] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button1.$on("click", ctx.click_handler);
|
|
|
|
return {
|
|
c: function create() {
|
|
button0.$$.fragment.c();
|
|
t = space();
|
|
button1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(button1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var button0_changes = {};
|
|
if (changed.$$scope) button0_changes.$$scope = { changed, ctx };
|
|
button0.$set(button0_changes);
|
|
|
|
var button1_changes = {};
|
|
if (changed.$$scope) button1_changes.$$scope = { changed, ctx };
|
|
button1.$set(button1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button0.$$.fragment, local);
|
|
|
|
transition_in(button1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button0.$$.fragment, local);
|
|
transition_out(button1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(button1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$d(ctx) {
|
|
var div, t0, updating_selected, t1, current_block_type_index, if_block0, t2, updating_text, t3, current_block_type_index_1, if_block1, t4, current;
|
|
|
|
var errorsbox = new ErrorsBox({
|
|
props: { errors: ctx.errors },
|
|
$$inline: true
|
|
});
|
|
|
|
function dropdown_selected_binding(value) {
|
|
ctx.dropdown_selected_binding.call(null, value);
|
|
updating_selected = true;
|
|
add_flush_callback(() => updating_selected = false);
|
|
}
|
|
|
|
let dropdown_props = { label: "Type", options: fp.keys(allTypes$1) };
|
|
if (ctx.clonedField.type !== void 0) {
|
|
dropdown_props.selected = ctx.clonedField.type;
|
|
}
|
|
var dropdown = new Dropdown({ props: dropdown_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(dropdown, 'selected', dropdown_selected_binding));
|
|
dropdown.$on("change", ctx.typeChanged);
|
|
|
|
var if_block_creators = [
|
|
create_if_block_6,
|
|
create_else_block$1
|
|
];
|
|
|
|
var if_blocks = [];
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.isNew) return 0;
|
|
return 1;
|
|
}
|
|
|
|
current_block_type_index = select_block_type(ctx);
|
|
if_block0 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
|
|
function textbox_text_binding_1(value_1) {
|
|
ctx.textbox_text_binding_1.call(null, value_1);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox_props = { label: "Label" };
|
|
if (ctx.clonedField.label !== void 0) {
|
|
textbox_props.text = ctx.clonedField.label;
|
|
}
|
|
var textbox = new Textbox({ props: textbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox, 'text', textbox_text_binding_1));
|
|
|
|
var if_block_creators_1 = [
|
|
create_if_block$3,
|
|
create_if_block_1,
|
|
create_if_block_2,
|
|
create_if_block_3,
|
|
create_if_block_4,
|
|
create_if_block_5
|
|
];
|
|
|
|
var if_blocks_1 = [];
|
|
|
|
function select_block_type_1(ctx) {
|
|
if (ctx.clonedField.type === "string") return 0;
|
|
if (ctx.clonedField.type === "bool") return 1;
|
|
if (ctx.clonedField.type === "datetime") return 2;
|
|
if (ctx.clonedField.type === "number") return 3;
|
|
if (ctx.clonedField.type === "reference") return 4;
|
|
if (ctx.clonedField.type.startsWith("array")) return 5;
|
|
return -1;
|
|
}
|
|
|
|
if (~(current_block_type_index_1 = select_block_type_1(ctx))) {
|
|
if_block1 = if_blocks_1[current_block_type_index_1] = if_block_creators_1[current_block_type_index_1](ctx);
|
|
}
|
|
|
|
var buttongroup = new ButtonGroup({
|
|
props: {
|
|
style: "float: right;",
|
|
$$slots: { default: [create_default_slot] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
errorsbox.$$.fragment.c();
|
|
t0 = space();
|
|
dropdown.$$.fragment.c();
|
|
t1 = space();
|
|
if_block0.c();
|
|
t2 = space();
|
|
textbox.$$.fragment.c();
|
|
t3 = space();
|
|
if (if_block1) if_block1.c();
|
|
t4 = space();
|
|
buttongroup.$$.fragment.c();
|
|
attr(div, "class", "root");
|
|
add_location(div, file$e, 57, 0, 1753);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(errorsbox, div, null);
|
|
append(div, t0);
|
|
mount_component(dropdown, div, null);
|
|
append(div, t1);
|
|
if_blocks[current_block_type_index].m(div, null);
|
|
append(div, t2);
|
|
mount_component(textbox, div, null);
|
|
append(div, t3);
|
|
if (~current_block_type_index_1) if_blocks_1[current_block_type_index_1].m(div, null);
|
|
append(div, t4);
|
|
mount_component(buttongroup, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var errorsbox_changes = {};
|
|
if (changed.errors) errorsbox_changes.errors = ctx.errors;
|
|
errorsbox.$set(errorsbox_changes);
|
|
|
|
var dropdown_changes = {};
|
|
if (changed.keys || changed.allTypes) dropdown_changes.options = fp.keys(allTypes$1);
|
|
if (!updating_selected && changed.clonedField) {
|
|
dropdown_changes.selected = ctx.clonedField.type;
|
|
}
|
|
dropdown.$set(dropdown_changes);
|
|
|
|
var previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type(ctx);
|
|
if (current_block_type_index === previous_block_index) {
|
|
if_blocks[current_block_type_index].p(changed, ctx);
|
|
} else {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
|
|
if_block0 = if_blocks[current_block_type_index];
|
|
if (!if_block0) {
|
|
if_block0 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
if_block0.c();
|
|
}
|
|
transition_in(if_block0, 1);
|
|
if_block0.m(div, t2);
|
|
}
|
|
|
|
var textbox_changes = {};
|
|
if (!updating_text && changed.clonedField) {
|
|
textbox_changes.text = ctx.clonedField.label;
|
|
}
|
|
textbox.$set(textbox_changes);
|
|
|
|
var previous_block_index_1 = current_block_type_index_1;
|
|
current_block_type_index_1 = select_block_type_1(ctx);
|
|
if (current_block_type_index_1 === previous_block_index_1) {
|
|
if (~current_block_type_index_1) if_blocks_1[current_block_type_index_1].p(changed, ctx);
|
|
} else {
|
|
if (if_block1) {
|
|
group_outros();
|
|
transition_out(if_blocks_1[previous_block_index_1], 1, 1, () => {
|
|
if_blocks_1[previous_block_index_1] = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
|
|
if (~current_block_type_index_1) {
|
|
if_block1 = if_blocks_1[current_block_type_index_1];
|
|
if (!if_block1) {
|
|
if_block1 = if_blocks_1[current_block_type_index_1] = if_block_creators_1[current_block_type_index_1](ctx);
|
|
if_block1.c();
|
|
}
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(div, t4);
|
|
} else {
|
|
if_block1 = null;
|
|
}
|
|
}
|
|
|
|
var buttongroup_changes = {};
|
|
if (changed.$$scope) buttongroup_changes.$$scope = { changed, ctx };
|
|
buttongroup.$set(buttongroup_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(errorsbox.$$.fragment, local);
|
|
|
|
transition_in(dropdown.$$.fragment, local);
|
|
|
|
transition_in(if_block0);
|
|
|
|
transition_in(textbox.$$.fragment, local);
|
|
|
|
transition_in(if_block1);
|
|
|
|
transition_in(buttongroup.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(errorsbox.$$.fragment, local);
|
|
transition_out(dropdown.$$.fragment, local);
|
|
transition_out(if_block0);
|
|
transition_out(textbox.$$.fragment, local);
|
|
transition_out(if_block1);
|
|
transition_out(buttongroup.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(errorsbox);
|
|
|
|
destroy_component(dropdown);
|
|
|
|
if_blocks[current_block_type_index].d();
|
|
|
|
destroy_component(textbox);
|
|
|
|
if (~current_block_type_index_1) if_blocks_1[current_block_type_index_1].d();
|
|
|
|
destroy_component(buttongroup);
|
|
}
|
|
};
|
|
}
|
|
|
|
function func(n) {
|
|
return n.nodeKey();
|
|
}
|
|
|
|
function func_1(n) {
|
|
return n.name;
|
|
}
|
|
|
|
function func_2(n) {
|
|
return n.nodeKey();
|
|
}
|
|
|
|
function func_3(n) {
|
|
return n.name;
|
|
}
|
|
|
|
function instance$d($$self, $$props, $$invalidate) {
|
|
|
|
|
|
let { field, allFields, onFinished = () => {} } = $$props;
|
|
let { database } = $$props;
|
|
|
|
let errors = [];
|
|
let clonedField = fp.cloneDeep(field);
|
|
|
|
const typeChanged = (ev) =>
|
|
{ const $$result = clonedField.typeOptions = getDefaultTypeOptions(ev.detail); $$invalidate('clonedField', clonedField); return $$result; };
|
|
|
|
|
|
const save = () => {
|
|
|
|
$$invalidate('errors', errors = validate.field(allFields)(clonedField));
|
|
if(errors.length > 0) return;
|
|
field.typeOptions = fp.cloneDeep(clonedField.typeOptions); $$invalidate('field', field);
|
|
onFinished(
|
|
fp.assign(field)(clonedField)
|
|
);
|
|
};
|
|
|
|
const writable_props = ['field', 'allFields', 'onFinished', 'database'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<FieldView> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function dropdown_selected_binding(value) {
|
|
clonedField.type = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function textbox_text_binding(value) {
|
|
clonedField.name = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function textbox_text_binding_1(value_1) {
|
|
clonedField.label = value_1;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function numberbox_value_binding(value) {
|
|
clonedField.typeOptions.maxLength = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function valueslist_values_binding(value_1) {
|
|
clonedField.typeOptions.values = value_1;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function checkbox_checked_binding(value_2) {
|
|
clonedField.typeOptions.allowDeclaredValuesOnly = value_2;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function checkbox_checked_binding_1(value) {
|
|
clonedField.typeOptions.allowNulls = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function datepicker0_value_binding(value) {
|
|
clonedField.typeOptions.minValue = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function datepicker1_value_binding(value_1) {
|
|
clonedField.typeOptions.maxValue = value_1;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function numberbox0_value_binding(value) {
|
|
clonedField.typeOptions.minValue = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function numberbox1_value_binding(value_1) {
|
|
clonedField.typeOptions.maxValue = value_1;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function numberbox2_value_binding(value_2) {
|
|
clonedField.typeOptions.decimalPlaces = value_2;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function dropdown0_selected_binding(value) {
|
|
clonedField.typeOptions.indexNodeKey = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function dropdown1_selected_binding(value_1) {
|
|
clonedField.typeOptions.reverseIndexNodeKeys = value_1;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function textbox_text_binding_2(value_2) {
|
|
clonedField.typeOptions.displayValue = value_2;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function numberbox0_value_binding_1(value) {
|
|
clonedField.typeOptions.minLength = value;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function numberbox1_value_binding_1(value_1) {
|
|
clonedField.typeOptions.maxLength = value_1;
|
|
$$invalidate('clonedField', clonedField);
|
|
}
|
|
|
|
function click_handler() {
|
|
return onFinished(false);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('field' in $$props) $$invalidate('field', field = $$props.field);
|
|
if ('allFields' in $$props) $$invalidate('allFields', allFields = $$props.allFields);
|
|
if ('onFinished' in $$props) $$invalidate('onFinished', onFinished = $$props.onFinished);
|
|
if ('database' in $$props) $$invalidate('database', database = $$props.database);
|
|
};
|
|
|
|
let isNew, possibleReferenceIndexes, selectedReverseRefIndex, possibleReverseReferenceIndexes;
|
|
|
|
$$self.$$.update = ($$dirty = { field: 1, database: 1, clonedField: 1, selectedReverseRefIndex: 1 }) => {
|
|
if ($$dirty.field) { $$invalidate('isNew', isNew = !!field && field.name.length === 0); }
|
|
if ($$dirty.database) { $$invalidate('possibleReferenceIndexes', possibleReferenceIndexes = getPotentialReferenceIndexes(
|
|
database.hierarchy, database.currentNode
|
|
)); }
|
|
if ($$dirty.clonedField || $$dirty.database) { $$invalidate('selectedReverseRefIndex', selectedReverseRefIndex =
|
|
!clonedField.typeOptions.indexNodeKey
|
|
? ""
|
|
: getNode$1(database.hierarchy, clonedField.typeOptions.indexNodeKey)); }
|
|
if ($$dirty.selectedReverseRefIndex || $$dirty.database) { $$invalidate('possibleReverseReferenceIndexes', possibleReverseReferenceIndexes =
|
|
!selectedReverseRefIndex
|
|
? []
|
|
: getPotentialReverseReferenceIndexes(
|
|
database.hierarchy, selectedReverseRefIndex)); }
|
|
};
|
|
|
|
return {
|
|
field,
|
|
allFields,
|
|
onFinished,
|
|
database,
|
|
errors,
|
|
clonedField,
|
|
typeChanged,
|
|
save,
|
|
isNew,
|
|
possibleReferenceIndexes,
|
|
possibleReverseReferenceIndexes,
|
|
dropdown_selected_binding,
|
|
textbox_text_binding,
|
|
textbox_text_binding_1,
|
|
numberbox_value_binding,
|
|
valueslist_values_binding,
|
|
checkbox_checked_binding,
|
|
checkbox_checked_binding_1,
|
|
datepicker0_value_binding,
|
|
datepicker1_value_binding,
|
|
numberbox0_value_binding,
|
|
numberbox1_value_binding,
|
|
numberbox2_value_binding,
|
|
dropdown0_selected_binding,
|
|
dropdown1_selected_binding,
|
|
textbox_text_binding_2,
|
|
numberbox0_value_binding_1,
|
|
numberbox1_value_binding_1,
|
|
click_handler
|
|
};
|
|
}
|
|
|
|
class FieldView extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$d, create_fragment$d, safe_not_equal, ["field", "allFields", "onFinished", "database"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.field === undefined && !('field' in props)) {
|
|
console.warn("<FieldView> was created without expected prop 'field'");
|
|
}
|
|
if (ctx.allFields === undefined && !('allFields' in props)) {
|
|
console.warn("<FieldView> was created without expected prop 'allFields'");
|
|
}
|
|
if (ctx.database === undefined && !('database' in props)) {
|
|
console.warn("<FieldView> was created without expected prop 'database'");
|
|
}
|
|
}
|
|
|
|
get field() {
|
|
throw new Error("<FieldView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set field(value) {
|
|
throw new Error("<FieldView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get allFields() {
|
|
throw new Error("<FieldView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set allFields(value) {
|
|
throw new Error("<FieldView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onFinished() {
|
|
throw new Error("<FieldView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onFinished(value) {
|
|
throw new Error("<FieldView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get database() {
|
|
throw new Error("<FieldView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set database(value) {
|
|
throw new Error("<FieldView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
var uikit = createCommonjsModule(function (module, exports) {
|
|
/*! UIkit 3.1.6 | http://www.getuikit.com | (c) 2014 - 2018 YOOtheme | MIT License */
|
|
|
|
(function (global, factory) {
|
|
module.exports = factory() ;
|
|
}(commonjsGlobal, function () {
|
|
function bind(fn, context) {
|
|
return function (a) {
|
|
var l = arguments.length;
|
|
return l ? l > 1 ? fn.apply(context, arguments) : fn.call(context, a) : fn.call(context);
|
|
};
|
|
}
|
|
|
|
var objPrototype = Object.prototype;
|
|
var hasOwnProperty = objPrototype.hasOwnProperty;
|
|
|
|
function hasOwn(obj, key) {
|
|
return hasOwnProperty.call(obj, key);
|
|
}
|
|
|
|
var hyphenateCache = {};
|
|
var hyphenateRe = /([a-z\d])([A-Z])/g;
|
|
|
|
function hyphenate(str) {
|
|
|
|
if (!(str in hyphenateCache)) {
|
|
hyphenateCache[str] = str
|
|
.replace(hyphenateRe, '$1-$2')
|
|
.toLowerCase();
|
|
}
|
|
|
|
return hyphenateCache[str];
|
|
}
|
|
|
|
var camelizeRe = /-(\w)/g;
|
|
|
|
function camelize(str) {
|
|
return str.replace(camelizeRe, toUpper);
|
|
}
|
|
|
|
function toUpper(_, c) {
|
|
return c ? c.toUpperCase() : '';
|
|
}
|
|
|
|
function ucfirst(str) {
|
|
return str.length ? toUpper(null, str.charAt(0)) + str.slice(1) : '';
|
|
}
|
|
|
|
var strPrototype = String.prototype;
|
|
var startsWithFn = strPrototype.startsWith || function (search) { return this.lastIndexOf(search, 0) === 0; };
|
|
|
|
function startsWith(str, search) {
|
|
return startsWithFn.call(str, search);
|
|
}
|
|
|
|
var endsWithFn = strPrototype.endsWith || function (search) { return this.substr(-search.length) === search; };
|
|
|
|
function endsWith(str, search) {
|
|
return endsWithFn.call(str, search);
|
|
}
|
|
|
|
var arrPrototype = Array.prototype;
|
|
|
|
var includesFn = function (search, i) { return ~this.indexOf(search, i); };
|
|
var includesStr = strPrototype.includes || includesFn;
|
|
var includesArray = arrPrototype.includes || includesFn;
|
|
|
|
function includes(obj, search) {
|
|
return obj && (isString(obj) ? includesStr : includesArray).call(obj, search);
|
|
}
|
|
|
|
var findIndexFn = arrPrototype.findIndex || function (predicate) {
|
|
var arguments$1 = arguments;
|
|
|
|
for (var i = 0; i < this.length; i++) {
|
|
if (predicate.call(arguments$1[1], this[i], i, this)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
|
|
function findIndex(array, predicate) {
|
|
return findIndexFn.call(array, predicate);
|
|
}
|
|
|
|
var isArray = Array.isArray;
|
|
|
|
function isFunction(obj) {
|
|
return typeof obj === 'function';
|
|
}
|
|
|
|
function isObject(obj) {
|
|
return obj !== null && typeof obj === 'object';
|
|
}
|
|
|
|
function isPlainObject(obj) {
|
|
return isObject(obj) && Object.getPrototypeOf(obj) === objPrototype;
|
|
}
|
|
|
|
function isWindow(obj) {
|
|
return isObject(obj) && obj === obj.window;
|
|
}
|
|
|
|
function isDocument(obj) {
|
|
return isObject(obj) && obj.nodeType === 9;
|
|
}
|
|
|
|
function isJQuery(obj) {
|
|
return isObject(obj) && !!obj.jquery;
|
|
}
|
|
|
|
function isNode(obj) {
|
|
return obj instanceof Node || isObject(obj) && obj.nodeType >= 1;
|
|
}
|
|
|
|
var toString = objPrototype.toString;
|
|
function isNodeCollection(obj) {
|
|
return toString.call(obj).match(/^\[object (NodeList|HTMLCollection)\]$/);
|
|
}
|
|
|
|
function isBoolean(value) {
|
|
return typeof value === 'boolean';
|
|
}
|
|
|
|
function isString(value) {
|
|
return typeof value === 'string';
|
|
}
|
|
|
|
function isNumber(value) {
|
|
return typeof value === 'number';
|
|
}
|
|
|
|
function isNumeric(value) {
|
|
return isNumber(value) || isString(value) && !isNaN(value - parseFloat(value));
|
|
}
|
|
|
|
function isEmpty(obj) {
|
|
return !(isArray(obj)
|
|
? obj.length
|
|
: isObject(obj)
|
|
? Object.keys(obj).length
|
|
: false
|
|
);
|
|
}
|
|
|
|
function isUndefined(value) {
|
|
return value === void 0;
|
|
}
|
|
|
|
function toBoolean(value) {
|
|
return isBoolean(value)
|
|
? value
|
|
: value === 'true' || value === '1' || value === ''
|
|
? true
|
|
: value === 'false' || value === '0'
|
|
? false
|
|
: value;
|
|
}
|
|
|
|
function toNumber(value) {
|
|
var number = Number(value);
|
|
return !isNaN(number) ? number : false;
|
|
}
|
|
|
|
function toFloat(value) {
|
|
return parseFloat(value) || 0;
|
|
}
|
|
|
|
function toNode(element) {
|
|
return isNode(element) || isWindow(element) || isDocument(element)
|
|
? element
|
|
: isNodeCollection(element) || isJQuery(element)
|
|
? element[0]
|
|
: isArray(element)
|
|
? toNode(element[0])
|
|
: null;
|
|
}
|
|
|
|
function toNodes(element) {
|
|
return isNode(element)
|
|
? [element]
|
|
: isNodeCollection(element)
|
|
? arrPrototype.slice.call(element)
|
|
: isArray(element)
|
|
? element.map(toNode).filter(Boolean)
|
|
: isJQuery(element)
|
|
? element.toArray()
|
|
: [];
|
|
}
|
|
|
|
function toList(value) {
|
|
return isArray(value)
|
|
? value
|
|
: isString(value)
|
|
? value.split(/,(?![^(]*\))/).map(function (value) { return isNumeric(value)
|
|
? toNumber(value)
|
|
: toBoolean(value.trim()); })
|
|
: [value];
|
|
}
|
|
|
|
function toMs(time) {
|
|
return !time
|
|
? 0
|
|
: endsWith(time, 'ms')
|
|
? toFloat(time)
|
|
: toFloat(time) * 1000;
|
|
}
|
|
|
|
function isEqual(value, other) {
|
|
return value === other
|
|
|| isObject(value)
|
|
&& isObject(other)
|
|
&& Object.keys(value).length === Object.keys(other).length
|
|
&& each(value, function (val, key) { return val === other[key]; });
|
|
}
|
|
|
|
function swap(value, a, b) {
|
|
return value.replace(new RegExp((a + "|" + b), 'mg'), function (match) {
|
|
return match === a ? b : a;
|
|
});
|
|
}
|
|
|
|
var assign = Object.assign || function (target) {
|
|
var args = [], len = arguments.length - 1;
|
|
while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
|
|
|
|
target = Object(target);
|
|
for (var i = 0; i < args.length; i++) {
|
|
var source = args[i];
|
|
if (source !== null) {
|
|
for (var key in source) {
|
|
if (hasOwn(source, key)) {
|
|
target[key] = source[key];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
};
|
|
|
|
function each(obj, cb) {
|
|
for (var key in obj) {
|
|
if (false === cb(obj[key], key)) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
function sortBy(array, prop) {
|
|
return array.sort(function (ref, ref$1) {
|
|
var propA = ref[prop]; if ( propA === void 0 ) propA = 0;
|
|
var propB = ref$1[prop]; if ( propB === void 0 ) propB = 0;
|
|
|
|
return propA > propB
|
|
? 1
|
|
: propB > propA
|
|
? -1
|
|
: 0;
|
|
}
|
|
);
|
|
}
|
|
|
|
function uniqueBy(array, prop) {
|
|
var seen = new Set();
|
|
return array.filter(function (ref) {
|
|
var check = ref[prop];
|
|
|
|
return seen.has(check)
|
|
? false
|
|
: seen.add(check) || true;
|
|
} // IE 11 does not return the Set object
|
|
);
|
|
}
|
|
|
|
function clamp(number, min, max) {
|
|
if ( min === void 0 ) min = 0;
|
|
if ( max === void 0 ) max = 1;
|
|
|
|
return Math.min(Math.max(toNumber(number) || 0, min), max);
|
|
}
|
|
|
|
function noop() {}
|
|
|
|
function intersectRect(r1, r2) {
|
|
return r1.left < r2.right &&
|
|
r1.right > r2.left &&
|
|
r1.top < r2.bottom &&
|
|
r1.bottom > r2.top;
|
|
}
|
|
|
|
function pointInRect(point, rect) {
|
|
return point.x <= rect.right &&
|
|
point.x >= rect.left &&
|
|
point.y <= rect.bottom &&
|
|
point.y >= rect.top;
|
|
}
|
|
|
|
var Dimensions = {
|
|
|
|
ratio: function(dimensions, prop, value) {
|
|
var obj;
|
|
|
|
|
|
var aProp = prop === 'width' ? 'height' : 'width';
|
|
|
|
return ( obj = {}, obj[aProp] = dimensions[prop] ? Math.round(value * dimensions[aProp] / dimensions[prop]) : dimensions[aProp], obj[prop] = value, obj );
|
|
},
|
|
|
|
contain: function(dimensions, maxDimensions) {
|
|
var this$1 = this;
|
|
|
|
dimensions = assign({}, dimensions);
|
|
|
|
each(dimensions, function (_, prop) { return dimensions = dimensions[prop] > maxDimensions[prop]
|
|
? this$1.ratio(dimensions, prop, maxDimensions[prop])
|
|
: dimensions; }
|
|
);
|
|
|
|
return dimensions;
|
|
},
|
|
|
|
cover: function(dimensions, maxDimensions) {
|
|
var this$1 = this;
|
|
|
|
dimensions = this.contain(dimensions, maxDimensions);
|
|
|
|
each(dimensions, function (_, prop) { return dimensions = dimensions[prop] < maxDimensions[prop]
|
|
? this$1.ratio(dimensions, prop, maxDimensions[prop])
|
|
: dimensions; }
|
|
);
|
|
|
|
return dimensions;
|
|
}
|
|
|
|
};
|
|
|
|
function attr(element, name, value) {
|
|
|
|
if (isObject(name)) {
|
|
for (var key in name) {
|
|
attr(element, key, name[key]);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (isUndefined(value)) {
|
|
element = toNode(element);
|
|
return element && element.getAttribute(name);
|
|
} else {
|
|
toNodes(element).forEach(function (element) {
|
|
|
|
if (isFunction(value)) {
|
|
value = value.call(element, attr(element, name));
|
|
}
|
|
|
|
if (value === null) {
|
|
removeAttr(element, name);
|
|
} else {
|
|
element.setAttribute(name, value);
|
|
}
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
function hasAttr(element, name) {
|
|
return toNodes(element).some(function (element) { return element.hasAttribute(name); });
|
|
}
|
|
|
|
function removeAttr(element, name) {
|
|
element = toNodes(element);
|
|
name.split(' ').forEach(function (name) { return element.forEach(function (element) { return element.hasAttribute(name) && element.removeAttribute(name); }
|
|
); }
|
|
);
|
|
}
|
|
|
|
function data(element, attribute) {
|
|
for (var i = 0, attrs = [attribute, ("data-" + attribute)]; i < attrs.length; i++) {
|
|
if (hasAttr(element, attrs[i])) {
|
|
return attr(element, attrs[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function query(selector, context) {
|
|
return toNode(selector) || find(selector, getContext(selector, context));
|
|
}
|
|
|
|
function queryAll(selector, context) {
|
|
var nodes = toNodes(selector);
|
|
return nodes.length && nodes || findAll(selector, getContext(selector, context));
|
|
}
|
|
|
|
function getContext(selector, context) {
|
|
if ( context === void 0 ) context = document;
|
|
|
|
return isContextSelector(selector) || isDocument(context)
|
|
? context
|
|
: context.ownerDocument;
|
|
}
|
|
|
|
function find(selector, context) {
|
|
return toNode(_query(selector, context, 'querySelector'));
|
|
}
|
|
|
|
function findAll(selector, context) {
|
|
return toNodes(_query(selector, context, 'querySelectorAll'));
|
|
}
|
|
|
|
function _query(selector, context, queryFn) {
|
|
if ( context === void 0 ) context = document;
|
|
|
|
|
|
if (!selector || !isString(selector)) {
|
|
return null;
|
|
}
|
|
|
|
selector = selector.replace(contextSanitizeRe, '$1 *');
|
|
|
|
var removes;
|
|
|
|
if (isContextSelector(selector)) {
|
|
|
|
removes = [];
|
|
|
|
selector = splitSelector(selector).map(function (selector, i) {
|
|
|
|
var ctx = context;
|
|
|
|
if (selector[0] === '!') {
|
|
|
|
var selectors = selector.substr(1).trim().split(' ');
|
|
ctx = closest(context.parentNode, selectors[0]);
|
|
selector = selectors.slice(1).join(' ').trim();
|
|
|
|
}
|
|
|
|
if (selector[0] === '-') {
|
|
|
|
var selectors$1 = selector.substr(1).trim().split(' ');
|
|
var prev = (ctx || context).previousElementSibling;
|
|
ctx = matches(prev, selector.substr(1)) ? prev : null;
|
|
selector = selectors$1.slice(1).join(' ');
|
|
|
|
}
|
|
|
|
if (!ctx) {
|
|
return null;
|
|
}
|
|
|
|
if (!ctx.id) {
|
|
ctx.id = "uk-" + (Date.now()) + i;
|
|
removes.push(function () { return removeAttr(ctx, 'id'); });
|
|
}
|
|
|
|
return ("#" + (escape(ctx.id)) + " " + selector);
|
|
|
|
}).filter(Boolean).join(',');
|
|
|
|
context = document;
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
return context[queryFn](selector);
|
|
|
|
} catch (e) {
|
|
|
|
return null;
|
|
|
|
} finally {
|
|
|
|
removes && removes.forEach(function (remove) { return remove(); });
|
|
|
|
}
|
|
|
|
}
|
|
|
|
var contextSelectorRe = /(^|[^\\],)\s*[!>+~-]/;
|
|
var contextSanitizeRe = /([!>+~-])(?=\s+[!>+~-]|\s*$)/g;
|
|
|
|
function isContextSelector(selector) {
|
|
return isString(selector) && selector.match(contextSelectorRe);
|
|
}
|
|
|
|
var selectorRe = /.*?[^\\](?:,|$)/g;
|
|
|
|
function splitSelector(selector) {
|
|
return selector.match(selectorRe).map(function (selector) { return selector.replace(/,$/, '').trim(); });
|
|
}
|
|
|
|
var elProto = Element.prototype;
|
|
var matchesFn = elProto.matches || elProto.webkitMatchesSelector || elProto.msMatchesSelector;
|
|
|
|
function matches(element, selector) {
|
|
return toNodes(element).some(function (element) { return matchesFn.call(element, selector); });
|
|
}
|
|
|
|
var closestFn = elProto.closest || function (selector) {
|
|
var ancestor = this;
|
|
|
|
do {
|
|
|
|
if (matches(ancestor, selector)) {
|
|
return ancestor;
|
|
}
|
|
|
|
ancestor = ancestor.parentNode;
|
|
|
|
} while (ancestor && ancestor.nodeType === 1);
|
|
};
|
|
|
|
function closest(element, selector) {
|
|
|
|
if (startsWith(selector, '>')) {
|
|
selector = selector.slice(1);
|
|
}
|
|
|
|
return isNode(element)
|
|
? element.parentNode && closestFn.call(element, selector)
|
|
: toNodes(element).map(function (element) { return closest(element, selector); }).filter(Boolean);
|
|
}
|
|
|
|
function parents(element, selector) {
|
|
var elements = [];
|
|
var parent = toNode(element).parentNode;
|
|
|
|
while (parent && parent.nodeType === 1) {
|
|
|
|
if (matches(parent, selector)) {
|
|
elements.push(parent);
|
|
}
|
|
|
|
parent = parent.parentNode;
|
|
}
|
|
|
|
return elements;
|
|
}
|
|
|
|
var escapeFn = window.CSS && CSS.escape || function (css) { return css.replace(/([^\x7f-\uFFFF\w-])/g, function (match) { return ("\\" + match); }); };
|
|
function escape(css) {
|
|
return isString(css) ? escapeFn.call(null, css) : '';
|
|
}
|
|
|
|
var voidElements = {
|
|
area: true,
|
|
base: true,
|
|
br: true,
|
|
col: true,
|
|
embed: true,
|
|
hr: true,
|
|
img: true,
|
|
input: true,
|
|
keygen: true,
|
|
link: true,
|
|
menuitem: true,
|
|
meta: true,
|
|
param: true,
|
|
source: true,
|
|
track: true,
|
|
wbr: true
|
|
};
|
|
function isVoidElement(element) {
|
|
return toNodes(element).some(function (element) { return voidElements[element.tagName.toLowerCase()]; });
|
|
}
|
|
|
|
function isVisible(element) {
|
|
return toNodes(element).some(function (element) { return element.offsetWidth || element.offsetHeight || element.getClientRects().length; });
|
|
}
|
|
|
|
var selInput = 'input,select,textarea,button';
|
|
function isInput(element) {
|
|
return toNodes(element).some(function (element) { return matches(element, selInput); });
|
|
}
|
|
|
|
function filter(element, selector) {
|
|
return toNodes(element).filter(function (element) { return matches(element, selector); });
|
|
}
|
|
|
|
function within(element, selector) {
|
|
return !isString(selector)
|
|
? element === selector || (isDocument(selector)
|
|
? selector.documentElement
|
|
: toNode(selector)).contains(toNode(element)) // IE 11 document does not implement contains
|
|
: matches(element, selector) || closest(element, selector);
|
|
}
|
|
|
|
function on() {
|
|
var args = [], len = arguments.length;
|
|
while ( len-- ) args[ len ] = arguments[ len ];
|
|
|
|
|
|
var ref = getArgs(args);
|
|
var targets = ref[0];
|
|
var type = ref[1];
|
|
var selector = ref[2];
|
|
var listener = ref[3];
|
|
var useCapture = ref[4];
|
|
|
|
targets = toEventTargets(targets);
|
|
|
|
if (selector) {
|
|
listener = delegate(targets, selector, listener);
|
|
}
|
|
|
|
if (listener.length > 1) {
|
|
listener = detail(listener);
|
|
}
|
|
|
|
type.split(' ').forEach(function (type) { return targets.forEach(function (target) { return target.addEventListener(type, listener, useCapture); }
|
|
); }
|
|
);
|
|
return function () { return off(targets, type, listener, useCapture); };
|
|
}
|
|
|
|
function off(targets, type, listener, useCapture) {
|
|
if ( useCapture === void 0 ) useCapture = false;
|
|
|
|
targets = toEventTargets(targets);
|
|
type.split(' ').forEach(function (type) { return targets.forEach(function (target) { return target.removeEventListener(type, listener, useCapture); }
|
|
); }
|
|
);
|
|
}
|
|
|
|
function once() {
|
|
var args = [], len = arguments.length;
|
|
while ( len-- ) args[ len ] = arguments[ len ];
|
|
|
|
|
|
var ref = getArgs(args);
|
|
var element = ref[0];
|
|
var type = ref[1];
|
|
var selector = ref[2];
|
|
var listener = ref[3];
|
|
var useCapture = ref[4];
|
|
var condition = ref[5];
|
|
var off = on(element, type, selector, function (e) {
|
|
var result = !condition || condition(e);
|
|
if (result) {
|
|
off();
|
|
listener(e, result);
|
|
}
|
|
}, useCapture);
|
|
|
|
return off;
|
|
}
|
|
|
|
function trigger(targets, event, detail) {
|
|
return toEventTargets(targets).reduce(function (notCanceled, target) { return notCanceled && target.dispatchEvent(createEvent(event, true, true, detail)); }
|
|
, true);
|
|
}
|
|
|
|
function createEvent(e, bubbles, cancelable, detail) {
|
|
if ( bubbles === void 0 ) bubbles = true;
|
|
if ( cancelable === void 0 ) cancelable = false;
|
|
|
|
if (isString(e)) {
|
|
var event = document.createEvent('CustomEvent'); // IE 11
|
|
event.initCustomEvent(e, bubbles, cancelable, detail);
|
|
e = event;
|
|
}
|
|
|
|
return e;
|
|
}
|
|
|
|
function getArgs(args) {
|
|
if (isFunction(args[2])) {
|
|
args.splice(2, 0, false);
|
|
}
|
|
return args;
|
|
}
|
|
|
|
function delegate(delegates, selector, listener) {
|
|
var this$1 = this;
|
|
|
|
return function (e) {
|
|
|
|
delegates.forEach(function (delegate) {
|
|
|
|
var current = selector[0] === '>'
|
|
? findAll(selector, delegate).reverse().filter(function (element) { return within(e.target, element); })[0]
|
|
: closest(e.target, selector);
|
|
|
|
if (current) {
|
|
e.delegate = delegate;
|
|
e.current = current;
|
|
|
|
listener.call(this$1, e);
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
}
|
|
|
|
function detail(listener) {
|
|
return function (e) { return isArray(e.detail) ? listener.apply(void 0, [e].concat(e.detail)) : listener(e); };
|
|
}
|
|
|
|
function isEventTarget(target) {
|
|
return target && 'addEventListener' in target;
|
|
}
|
|
|
|
function toEventTarget(target) {
|
|
return isEventTarget(target) ? target : toNode(target);
|
|
}
|
|
|
|
function toEventTargets(target) {
|
|
return isArray(target)
|
|
? target.map(toEventTarget).filter(Boolean)
|
|
: isString(target)
|
|
? findAll(target)
|
|
: isEventTarget(target)
|
|
? [target]
|
|
: toNodes(target);
|
|
}
|
|
|
|
function isTouch(e) {
|
|
return e.pointerType === 'touch' || e.touches;
|
|
}
|
|
|
|
function getEventPos(e, prop) {
|
|
if ( prop === void 0 ) prop = 'client';
|
|
|
|
var touches = e.touches;
|
|
var changedTouches = e.changedTouches;
|
|
var ref = touches && touches[0] || changedTouches && changedTouches[0] || e;
|
|
var x = ref[(prop + "X")];
|
|
var y = ref[(prop + "Y")];
|
|
|
|
return {x: x, y: y};
|
|
}
|
|
|
|
/* global setImmediate */
|
|
|
|
var Promise = 'Promise' in window ? window.Promise : PromiseFn;
|
|
|
|
var Deferred = function() {
|
|
var this$1 = this;
|
|
|
|
this.promise = new Promise(function (resolve, reject) {
|
|
this$1.reject = reject;
|
|
this$1.resolve = resolve;
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Promises/A+ polyfill v1.1.4 (https://github.com/bramstein/promis)
|
|
*/
|
|
|
|
var RESOLVED = 0;
|
|
var REJECTED = 1;
|
|
var PENDING = 2;
|
|
|
|
var async = 'setImmediate' in window ? setImmediate : setTimeout;
|
|
|
|
function PromiseFn(executor) {
|
|
|
|
this.state = PENDING;
|
|
this.value = undefined;
|
|
this.deferred = [];
|
|
|
|
var promise = this;
|
|
|
|
try {
|
|
executor(
|
|
function (x) {
|
|
promise.resolve(x);
|
|
},
|
|
function (r) {
|
|
promise.reject(r);
|
|
}
|
|
);
|
|
} catch (e) {
|
|
promise.reject(e);
|
|
}
|
|
}
|
|
|
|
PromiseFn.reject = function (r) {
|
|
return new PromiseFn(function (resolve, reject) {
|
|
reject(r);
|
|
});
|
|
};
|
|
|
|
PromiseFn.resolve = function (x) {
|
|
return new PromiseFn(function (resolve, reject) {
|
|
resolve(x);
|
|
});
|
|
};
|
|
|
|
PromiseFn.all = function all(iterable) {
|
|
return new PromiseFn(function (resolve, reject) {
|
|
var result = [];
|
|
var count = 0;
|
|
|
|
if (iterable.length === 0) {
|
|
resolve(result);
|
|
}
|
|
|
|
function resolver(i) {
|
|
return function (x) {
|
|
result[i] = x;
|
|
count += 1;
|
|
|
|
if (count === iterable.length) {
|
|
resolve(result);
|
|
}
|
|
};
|
|
}
|
|
|
|
for (var i = 0; i < iterable.length; i += 1) {
|
|
PromiseFn.resolve(iterable[i]).then(resolver(i), reject);
|
|
}
|
|
});
|
|
};
|
|
|
|
PromiseFn.race = function race(iterable) {
|
|
return new PromiseFn(function (resolve, reject) {
|
|
for (var i = 0; i < iterable.length; i += 1) {
|
|
PromiseFn.resolve(iterable[i]).then(resolve, reject);
|
|
}
|
|
});
|
|
};
|
|
|
|
var p = PromiseFn.prototype;
|
|
|
|
p.resolve = function resolve(x) {
|
|
var promise = this;
|
|
|
|
if (promise.state === PENDING) {
|
|
if (x === promise) {
|
|
throw new TypeError('Promise settled with itself.');
|
|
}
|
|
|
|
var called = false;
|
|
|
|
try {
|
|
var then = x && x.then;
|
|
|
|
if (x !== null && isObject(x) && isFunction(then)) {
|
|
then.call(
|
|
x,
|
|
function (x) {
|
|
if (!called) {
|
|
promise.resolve(x);
|
|
}
|
|
called = true;
|
|
},
|
|
function (r) {
|
|
if (!called) {
|
|
promise.reject(r);
|
|
}
|
|
called = true;
|
|
}
|
|
);
|
|
return;
|
|
}
|
|
} catch (e) {
|
|
if (!called) {
|
|
promise.reject(e);
|
|
}
|
|
return;
|
|
}
|
|
|
|
promise.state = RESOLVED;
|
|
promise.value = x;
|
|
promise.notify();
|
|
}
|
|
};
|
|
|
|
p.reject = function reject(reason) {
|
|
var promise = this;
|
|
|
|
if (promise.state === PENDING) {
|
|
if (reason === promise) {
|
|
throw new TypeError('Promise settled with itself.');
|
|
}
|
|
|
|
promise.state = REJECTED;
|
|
promise.value = reason;
|
|
promise.notify();
|
|
}
|
|
};
|
|
|
|
p.notify = function notify() {
|
|
var this$1 = this;
|
|
|
|
async(function () {
|
|
if (this$1.state !== PENDING) {
|
|
while (this$1.deferred.length) {
|
|
var ref = this$1.deferred.shift();
|
|
var onResolved = ref[0];
|
|
var onRejected = ref[1];
|
|
var resolve = ref[2];
|
|
var reject = ref[3];
|
|
|
|
try {
|
|
if (this$1.state === RESOLVED) {
|
|
if (isFunction(onResolved)) {
|
|
resolve(onResolved.call(undefined, this$1.value));
|
|
} else {
|
|
resolve(this$1.value);
|
|
}
|
|
} else if (this$1.state === REJECTED) {
|
|
if (isFunction(onRejected)) {
|
|
resolve(onRejected.call(undefined, this$1.value));
|
|
} else {
|
|
reject(this$1.value);
|
|
}
|
|
}
|
|
} catch (e) {
|
|
reject(e);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
};
|
|
|
|
p.then = function then(onResolved, onRejected) {
|
|
var this$1 = this;
|
|
|
|
return new PromiseFn(function (resolve, reject) {
|
|
this$1.deferred.push([onResolved, onRejected, resolve, reject]);
|
|
this$1.notify();
|
|
});
|
|
};
|
|
|
|
p.catch = function (onRejected) {
|
|
return this.then(undefined, onRejected);
|
|
};
|
|
|
|
function ajax(url, options) {
|
|
return new Promise(function (resolve, reject) {
|
|
|
|
var env = assign({
|
|
data: null,
|
|
method: 'GET',
|
|
headers: {},
|
|
xhr: new XMLHttpRequest(),
|
|
beforeSend: noop,
|
|
responseType: ''
|
|
}, options);
|
|
|
|
env.beforeSend(env);
|
|
|
|
var xhr = env.xhr;
|
|
|
|
for (var prop in env) {
|
|
if (prop in xhr) {
|
|
try {
|
|
|
|
xhr[prop] = env[prop];
|
|
|
|
} catch (e) {}
|
|
}
|
|
}
|
|
|
|
xhr.open(env.method.toUpperCase(), url);
|
|
|
|
for (var header in env.headers) {
|
|
xhr.setRequestHeader(header, env.headers[header]);
|
|
}
|
|
|
|
on(xhr, 'load', function () {
|
|
|
|
if (xhr.status === 0 || xhr.status >= 200 && xhr.status < 300 || xhr.status === 304) {
|
|
resolve(xhr);
|
|
} else {
|
|
reject(assign(Error(xhr.statusText), {
|
|
xhr: xhr,
|
|
status: xhr.status
|
|
}));
|
|
}
|
|
|
|
});
|
|
|
|
on(xhr, 'error', function () { return reject(assign(Error('Network Error'), {xhr: xhr})); });
|
|
on(xhr, 'timeout', function () { return reject(assign(Error('Network Timeout'), {xhr: xhr})); });
|
|
|
|
xhr.send(env.data);
|
|
});
|
|
}
|
|
|
|
function getImage(src, srcset, sizes) {
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
var img = new Image();
|
|
|
|
img.onerror = reject;
|
|
img.onload = function () { return resolve(img); };
|
|
|
|
sizes && (img.sizes = sizes);
|
|
srcset && (img.srcset = srcset);
|
|
img.src = src;
|
|
});
|
|
|
|
}
|
|
|
|
/* global DocumentTouch */
|
|
|
|
var isIE = /msie|trident/i.test(window.navigator.userAgent);
|
|
var isRtl = attr(document.documentElement, 'dir') === 'rtl';
|
|
|
|
var hasTouchEvents = 'ontouchstart' in window;
|
|
var hasPointerEvents = window.PointerEvent;
|
|
var hasTouch = hasTouchEvents
|
|
|| window.DocumentTouch && document instanceof DocumentTouch
|
|
|| navigator.maxTouchPoints; // IE >=11
|
|
|
|
var pointerDown = hasPointerEvents ? 'pointerdown' : hasTouchEvents ? 'touchstart' : 'mousedown';
|
|
var pointerMove = hasPointerEvents ? 'pointermove' : hasTouchEvents ? 'touchmove' : 'mousemove';
|
|
var pointerUp = hasPointerEvents ? 'pointerup' : hasTouchEvents ? 'touchend' : 'mouseup';
|
|
var pointerEnter = hasPointerEvents ? 'pointerenter' : hasTouchEvents ? '' : 'mouseenter';
|
|
var pointerLeave = hasPointerEvents ? 'pointerleave' : hasTouchEvents ? '' : 'mouseleave';
|
|
var pointerCancel = hasPointerEvents ? 'pointercancel' : 'touchcancel';
|
|
|
|
function ready(fn) {
|
|
|
|
if (document.readyState !== 'loading') {
|
|
fn();
|
|
return;
|
|
}
|
|
|
|
var unbind = on(document, 'DOMContentLoaded', function () {
|
|
unbind();
|
|
fn();
|
|
});
|
|
}
|
|
|
|
function index(element, ref) {
|
|
return ref
|
|
? toNodes(element).indexOf(toNode(ref))
|
|
: toNodes((element = toNode(element)) && element.parentNode.children).indexOf(element);
|
|
}
|
|
|
|
function getIndex(i, elements, current, finite) {
|
|
if ( current === void 0 ) current = 0;
|
|
if ( finite === void 0 ) finite = false;
|
|
|
|
|
|
elements = toNodes(elements);
|
|
|
|
var length = elements.length;
|
|
|
|
i = isNumeric(i)
|
|
? toNumber(i)
|
|
: i === 'next'
|
|
? current + 1
|
|
: i === 'previous'
|
|
? current - 1
|
|
: index(elements, i);
|
|
|
|
if (finite) {
|
|
return clamp(i, 0, length - 1);
|
|
}
|
|
|
|
i %= length;
|
|
|
|
return i < 0 ? i + length : i;
|
|
}
|
|
|
|
function empty(element) {
|
|
element = $(element);
|
|
element.innerHTML = '';
|
|
return element;
|
|
}
|
|
|
|
function html(parent, html) {
|
|
parent = $(parent);
|
|
return isUndefined(html)
|
|
? parent.innerHTML
|
|
: append(parent.hasChildNodes() ? empty(parent) : parent, html);
|
|
}
|
|
|
|
function prepend(parent, element) {
|
|
|
|
parent = $(parent);
|
|
|
|
if (!parent.hasChildNodes()) {
|
|
return append(parent, element);
|
|
} else {
|
|
return insertNodes(element, function (element) { return parent.insertBefore(element, parent.firstChild); });
|
|
}
|
|
}
|
|
|
|
function append(parent, element) {
|
|
parent = $(parent);
|
|
return insertNodes(element, function (element) { return parent.appendChild(element); });
|
|
}
|
|
|
|
function before(ref, element) {
|
|
ref = $(ref);
|
|
return insertNodes(element, function (element) { return ref.parentNode.insertBefore(element, ref); });
|
|
}
|
|
|
|
function after(ref, element) {
|
|
ref = $(ref);
|
|
return insertNodes(element, function (element) { return ref.nextSibling
|
|
? before(ref.nextSibling, element)
|
|
: append(ref.parentNode, element); }
|
|
);
|
|
}
|
|
|
|
function insertNodes(element, fn) {
|
|
element = isString(element) ? fragment(element) : element;
|
|
return element
|
|
? 'length' in element
|
|
? toNodes(element).map(fn)
|
|
: fn(element)
|
|
: null;
|
|
}
|
|
|
|
function remove(element) {
|
|
toNodes(element).map(function (element) { return element.parentNode && element.parentNode.removeChild(element); });
|
|
}
|
|
|
|
function wrapAll(element, structure) {
|
|
|
|
structure = toNode(before(element, structure));
|
|
|
|
while (structure.firstChild) {
|
|
structure = structure.firstChild;
|
|
}
|
|
|
|
append(structure, element);
|
|
|
|
return structure;
|
|
}
|
|
|
|
function wrapInner(element, structure) {
|
|
return toNodes(toNodes(element).map(function (element) { return element.hasChildNodes ? wrapAll(toNodes(element.childNodes), structure) : append(element, structure); }
|
|
));
|
|
}
|
|
|
|
function unwrap(element) {
|
|
toNodes(element)
|
|
.map(function (element) { return element.parentNode; })
|
|
.filter(function (value, index, self) { return self.indexOf(value) === index; })
|
|
.forEach(function (parent) {
|
|
before(parent, parent.childNodes);
|
|
remove(parent);
|
|
});
|
|
}
|
|
|
|
var fragmentRe = /^\s*<(\w+|!)[^>]*>/;
|
|
var singleTagRe = /^<(\w+)\s*\/?>(?:<\/\1>)?$/;
|
|
|
|
function fragment(html) {
|
|
|
|
var matches = singleTagRe.exec(html);
|
|
if (matches) {
|
|
return document.createElement(matches[1]);
|
|
}
|
|
|
|
var container = document.createElement('div');
|
|
if (fragmentRe.test(html)) {
|
|
container.insertAdjacentHTML('beforeend', html.trim());
|
|
} else {
|
|
container.textContent = html;
|
|
}
|
|
|
|
return container.childNodes.length > 1 ? toNodes(container.childNodes) : container.firstChild;
|
|
|
|
}
|
|
|
|
function apply(node, fn) {
|
|
|
|
if (!node || node.nodeType !== 1) {
|
|
return;
|
|
}
|
|
|
|
fn(node);
|
|
node = node.firstElementChild;
|
|
while (node) {
|
|
apply(node, fn);
|
|
node = node.nextElementSibling;
|
|
}
|
|
}
|
|
|
|
function $(selector, context) {
|
|
return !isString(selector)
|
|
? toNode(selector)
|
|
: isHtml(selector)
|
|
? toNode(fragment(selector))
|
|
: find(selector, context);
|
|
}
|
|
|
|
function $$(selector, context) {
|
|
return !isString(selector)
|
|
? toNodes(selector)
|
|
: isHtml(selector)
|
|
? toNodes(fragment(selector))
|
|
: findAll(selector, context);
|
|
}
|
|
|
|
function isHtml(str) {
|
|
return str[0] === '<' || str.match(/^\s*</);
|
|
}
|
|
|
|
function addClass(element) {
|
|
var args = [], len = arguments.length - 1;
|
|
while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
|
|
|
|
apply$1(element, args, 'add');
|
|
}
|
|
|
|
function removeClass(element) {
|
|
var args = [], len = arguments.length - 1;
|
|
while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
|
|
|
|
apply$1(element, args, 'remove');
|
|
}
|
|
|
|
function removeClasses(element, cls) {
|
|
attr(element, 'class', function (value) { return (value || '').replace(new RegExp(("\\b" + cls + "\\b"), 'g'), ''); });
|
|
}
|
|
|
|
function replaceClass(element) {
|
|
var args = [], len = arguments.length - 1;
|
|
while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
|
|
|
|
args[0] && removeClass(element, args[0]);
|
|
args[1] && addClass(element, args[1]);
|
|
}
|
|
|
|
function hasClass(element, cls) {
|
|
return cls && toNodes(element).some(function (element) { return element.classList.contains(cls.split(' ')[0]); });
|
|
}
|
|
|
|
function toggleClass(element) {
|
|
var args = [], len = arguments.length - 1;
|
|
while ( len-- > 0 ) args[ len ] = arguments[ len + 1 ];
|
|
|
|
|
|
if (!args.length) {
|
|
return;
|
|
}
|
|
|
|
args = getArgs$1(args);
|
|
|
|
var force = !isString(args[args.length - 1]) ? args.pop() : []; // in iOS 9.3 force === undefined evaluates to false
|
|
|
|
args = args.filter(Boolean);
|
|
|
|
toNodes(element).forEach(function (ref) {
|
|
var classList = ref.classList;
|
|
|
|
for (var i = 0; i < args.length; i++) {
|
|
supports.Force
|
|
? classList.toggle.apply(classList, [args[i]].concat(force))
|
|
: (classList[(!isUndefined(force) ? force : !classList.contains(args[i])) ? 'add' : 'remove'](args[i]));
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
function apply$1(element, args, fn) {
|
|
args = getArgs$1(args).filter(Boolean);
|
|
|
|
args.length && toNodes(element).forEach(function (ref) {
|
|
var classList = ref.classList;
|
|
|
|
supports.Multiple
|
|
? classList[fn].apply(classList, args)
|
|
: args.forEach(function (cls) { return classList[fn](cls); });
|
|
});
|
|
}
|
|
|
|
function getArgs$1(args) {
|
|
return args.reduce(function (args, arg) { return args.concat.call(args, isString(arg) && includes(arg, ' ') ? arg.trim().split(' ') : arg); }
|
|
, []);
|
|
}
|
|
|
|
// IE 11
|
|
var supports = {
|
|
|
|
get Multiple() {
|
|
return this.get('_multiple');
|
|
},
|
|
|
|
get Force() {
|
|
return this.get('_force');
|
|
},
|
|
|
|
get: function(key) {
|
|
|
|
if (!hasOwn(this, key)) {
|
|
var ref = document.createElement('_');
|
|
var classList = ref.classList;
|
|
classList.add('a', 'b');
|
|
classList.toggle('c', false);
|
|
this._multiple = classList.contains('b');
|
|
this._force = !classList.contains('c');
|
|
}
|
|
|
|
return this[key];
|
|
}
|
|
|
|
};
|
|
|
|
var cssNumber = {
|
|
'animation-iteration-count': true,
|
|
'column-count': true,
|
|
'fill-opacity': true,
|
|
'flex-grow': true,
|
|
'flex-shrink': true,
|
|
'font-weight': true,
|
|
'line-height': true,
|
|
'opacity': true,
|
|
'order': true,
|
|
'orphans': true,
|
|
'stroke-dasharray': true,
|
|
'stroke-dashoffset': true,
|
|
'widows': true,
|
|
'z-index': true,
|
|
'zoom': true
|
|
};
|
|
|
|
function css(element, property, value) {
|
|
|
|
return toNodes(element).map(function (element) {
|
|
|
|
if (isString(property)) {
|
|
|
|
property = propName(property);
|
|
|
|
if (isUndefined(value)) {
|
|
return getStyle(element, property);
|
|
} else if (!value && !isNumber(value)) {
|
|
element.style.removeProperty(property);
|
|
} else {
|
|
element.style[property] = isNumeric(value) && !cssNumber[property] ? (value + "px") : value;
|
|
}
|
|
|
|
} else if (isArray(property)) {
|
|
|
|
var styles = getStyles(element);
|
|
|
|
return property.reduce(function (props, property) {
|
|
props[property] = styles[propName(property)];
|
|
return props;
|
|
}, {});
|
|
|
|
} else if (isObject(property)) {
|
|
each(property, function (value, property) { return css(element, property, value); });
|
|
}
|
|
|
|
return element;
|
|
|
|
})[0];
|
|
|
|
}
|
|
|
|
function getStyles(element, pseudoElt) {
|
|
element = toNode(element);
|
|
return element.ownerDocument.defaultView.getComputedStyle(element, pseudoElt);
|
|
}
|
|
|
|
function getStyle(element, property, pseudoElt) {
|
|
return getStyles(element, pseudoElt)[property];
|
|
}
|
|
|
|
var vars = {};
|
|
|
|
function getCssVar(name) {
|
|
|
|
var docEl = document.documentElement;
|
|
|
|
if (!isIE) {
|
|
return getStyles(docEl).getPropertyValue(("--uk-" + name));
|
|
}
|
|
|
|
if (!(name in vars)) {
|
|
|
|
/* usage in css: .uk-name:before { content:"xyz" } */
|
|
|
|
var element = append(docEl, document.createElement('div'));
|
|
|
|
addClass(element, ("uk-" + name));
|
|
|
|
vars[name] = getStyle(element, 'content', ':before').replace(/^["'](.*)["']$/, '$1');
|
|
|
|
remove(element);
|
|
|
|
}
|
|
|
|
return vars[name];
|
|
|
|
}
|
|
|
|
var cssProps = {};
|
|
|
|
function propName(name) {
|
|
|
|
var ret = cssProps[name];
|
|
if (!ret) {
|
|
ret = cssProps[name] = vendorPropName(name) || name;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
var cssPrefixes = ['webkit', 'moz', 'ms'];
|
|
|
|
function vendorPropName(name) {
|
|
|
|
name = hyphenate(name);
|
|
|
|
var ref = document.documentElement;
|
|
var style = ref.style;
|
|
|
|
if (name in style) {
|
|
return name;
|
|
}
|
|
|
|
var i = cssPrefixes.length, prefixedName;
|
|
|
|
while (i--) {
|
|
prefixedName = "-" + (cssPrefixes[i]) + "-" + name;
|
|
if (prefixedName in style) {
|
|
return prefixedName;
|
|
}
|
|
}
|
|
}
|
|
|
|
function transition(element, props, duration, timing) {
|
|
if ( duration === void 0 ) duration = 400;
|
|
if ( timing === void 0 ) timing = 'linear';
|
|
|
|
|
|
return Promise.all(toNodes(element).map(function (element) { return new Promise(function (resolve, reject) {
|
|
|
|
for (var name in props) {
|
|
var value = css(element, name);
|
|
if (value === '') {
|
|
css(element, name, value);
|
|
}
|
|
}
|
|
|
|
var timer = setTimeout(function () { return trigger(element, 'transitionend'); }, duration);
|
|
|
|
once(element, 'transitionend transitioncanceled', function (ref) {
|
|
var type = ref.type;
|
|
|
|
clearTimeout(timer);
|
|
removeClass(element, 'uk-transition');
|
|
css(element, {
|
|
'transition-property': '',
|
|
'transition-duration': '',
|
|
'transition-timing-function': ''
|
|
});
|
|
type === 'transitioncanceled' ? reject() : resolve();
|
|
}, false, function (ref) {
|
|
var target = ref.target;
|
|
|
|
return element === target;
|
|
});
|
|
|
|
addClass(element, 'uk-transition');
|
|
css(element, assign({
|
|
'transition-property': Object.keys(props).map(propName).join(','),
|
|
'transition-duration': (duration + "ms"),
|
|
'transition-timing-function': timing
|
|
}, props));
|
|
|
|
}); }
|
|
));
|
|
|
|
}
|
|
|
|
var Transition = {
|
|
|
|
start: transition,
|
|
|
|
stop: function(element) {
|
|
trigger(element, 'transitionend');
|
|
return Promise.resolve();
|
|
},
|
|
|
|
cancel: function(element) {
|
|
trigger(element, 'transitioncanceled');
|
|
},
|
|
|
|
inProgress: function(element) {
|
|
return hasClass(element, 'uk-transition');
|
|
}
|
|
|
|
};
|
|
|
|
var animationPrefix = 'uk-animation-';
|
|
var clsCancelAnimation = 'uk-cancel-animation';
|
|
|
|
function animate(element, animation, duration, origin, out) {
|
|
var arguments$1 = arguments;
|
|
if ( duration === void 0 ) duration = 200;
|
|
|
|
|
|
return Promise.all(toNodes(element).map(function (element) { return new Promise(function (resolve, reject) {
|
|
|
|
if (hasClass(element, clsCancelAnimation)) {
|
|
requestAnimationFrame(function () { return Promise.resolve().then(function () { return animate.apply(void 0, arguments$1).then(resolve, reject); }
|
|
); }
|
|
);
|
|
return;
|
|
}
|
|
|
|
var cls = animation + " " + animationPrefix + (out ? 'leave' : 'enter');
|
|
|
|
if (startsWith(animation, animationPrefix)) {
|
|
|
|
if (origin) {
|
|
cls += " uk-transform-origin-" + origin;
|
|
}
|
|
|
|
if (out) {
|
|
cls += " " + animationPrefix + "reverse";
|
|
}
|
|
|
|
}
|
|
|
|
reset();
|
|
|
|
once(element, 'animationend animationcancel', function (ref) {
|
|
var type = ref.type;
|
|
|
|
|
|
var hasReset = false;
|
|
|
|
if (type === 'animationcancel') {
|
|
reject();
|
|
reset();
|
|
} else {
|
|
resolve();
|
|
Promise.resolve().then(function () {
|
|
hasReset = true;
|
|
reset();
|
|
});
|
|
}
|
|
|
|
requestAnimationFrame(function () {
|
|
if (!hasReset) {
|
|
addClass(element, clsCancelAnimation);
|
|
|
|
requestAnimationFrame(function () { return removeClass(element, clsCancelAnimation); });
|
|
}
|
|
});
|
|
|
|
}, false, function (ref) {
|
|
var target = ref.target;
|
|
|
|
return element === target;
|
|
});
|
|
|
|
css(element, 'animationDuration', (duration + "ms"));
|
|
addClass(element, cls);
|
|
|
|
function reset() {
|
|
css(element, 'animationDuration', '');
|
|
removeClasses(element, (animationPrefix + "\\S*"));
|
|
}
|
|
|
|
}); }
|
|
));
|
|
|
|
}
|
|
|
|
var inProgress = new RegExp((animationPrefix + "(enter|leave)"));
|
|
var Animation = {
|
|
|
|
in: function(element, animation, duration, origin) {
|
|
return animate(element, animation, duration, origin, false);
|
|
},
|
|
|
|
out: function(element, animation, duration, origin) {
|
|
return animate(element, animation, duration, origin, true);
|
|
},
|
|
|
|
inProgress: function(element) {
|
|
return inProgress.test(attr(element, 'class'));
|
|
},
|
|
|
|
cancel: function(element) {
|
|
trigger(element, 'animationcancel');
|
|
}
|
|
|
|
};
|
|
|
|
var dirs = {
|
|
width: ['x', 'left', 'right'],
|
|
height: ['y', 'top', 'bottom']
|
|
};
|
|
|
|
function positionAt(element, target, elAttach, targetAttach, elOffset, targetOffset, flip, boundary) {
|
|
|
|
elAttach = getPos(elAttach);
|
|
targetAttach = getPos(targetAttach);
|
|
|
|
var flipped = {element: elAttach, target: targetAttach};
|
|
|
|
if (!element || !target) {
|
|
return flipped;
|
|
}
|
|
|
|
var dim = getDimensions(element);
|
|
var targetDim = getDimensions(target);
|
|
var position = targetDim;
|
|
|
|
moveTo(position, elAttach, dim, -1);
|
|
moveTo(position, targetAttach, targetDim, 1);
|
|
|
|
elOffset = getOffsets(elOffset, dim.width, dim.height);
|
|
targetOffset = getOffsets(targetOffset, targetDim.width, targetDim.height);
|
|
|
|
elOffset['x'] += targetOffset['x'];
|
|
elOffset['y'] += targetOffset['y'];
|
|
|
|
position.left += elOffset['x'];
|
|
position.top += elOffset['y'];
|
|
|
|
if (flip) {
|
|
|
|
var boundaries = [getDimensions(getWindow(element))];
|
|
|
|
if (boundary) {
|
|
boundaries.unshift(getDimensions(boundary));
|
|
}
|
|
|
|
each(dirs, function (ref, prop) {
|
|
var dir = ref[0];
|
|
var align = ref[1];
|
|
var alignFlip = ref[2];
|
|
|
|
|
|
if (!(flip === true || includes(flip, dir))) {
|
|
return;
|
|
}
|
|
|
|
boundaries.some(function (boundary) {
|
|
|
|
var elemOffset = elAttach[dir] === align
|
|
? -dim[prop]
|
|
: elAttach[dir] === alignFlip
|
|
? dim[prop]
|
|
: 0;
|
|
|
|
var targetOffset = targetAttach[dir] === align
|
|
? targetDim[prop]
|
|
: targetAttach[dir] === alignFlip
|
|
? -targetDim[prop]
|
|
: 0;
|
|
|
|
if (position[align] < boundary[align] || position[align] + dim[prop] > boundary[alignFlip]) {
|
|
|
|
var centerOffset = dim[prop] / 2;
|
|
var centerTargetOffset = targetAttach[dir] === 'center' ? -targetDim[prop] / 2 : 0;
|
|
|
|
return elAttach[dir] === 'center' && (
|
|
apply(centerOffset, centerTargetOffset)
|
|
|| apply(-centerOffset, -centerTargetOffset)
|
|
) || apply(elemOffset, targetOffset);
|
|
|
|
}
|
|
|
|
function apply(elemOffset, targetOffset) {
|
|
|
|
var newVal = position[align] + elemOffset + targetOffset - elOffset[dir] * 2;
|
|
|
|
if (newVal >= boundary[align] && newVal + dim[prop] <= boundary[alignFlip]) {
|
|
position[align] = newVal;
|
|
|
|
['element', 'target'].forEach(function (el) {
|
|
flipped[el][dir] = !elemOffset
|
|
? flipped[el][dir]
|
|
: flipped[el][dir] === dirs[prop][1]
|
|
? dirs[prop][2]
|
|
: dirs[prop][1];
|
|
});
|
|
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
});
|
|
}
|
|
|
|
offset(element, position);
|
|
|
|
return flipped;
|
|
}
|
|
|
|
function offset(element, coordinates) {
|
|
|
|
element = toNode(element);
|
|
|
|
if (coordinates) {
|
|
|
|
var currentOffset = offset(element);
|
|
var pos = css(element, 'position');
|
|
|
|
['left', 'top'].forEach(function (prop) {
|
|
if (prop in coordinates) {
|
|
var value = css(element, prop);
|
|
css(element, prop, coordinates[prop] - currentOffset[prop]
|
|
+ toFloat(pos === 'absolute' && value === 'auto'
|
|
? position(element)[prop]
|
|
: value)
|
|
);
|
|
}
|
|
});
|
|
|
|
return;
|
|
}
|
|
|
|
return getDimensions(element);
|
|
}
|
|
|
|
function getDimensions(element) {
|
|
|
|
element = toNode(element);
|
|
|
|
var ref = getWindow(element);
|
|
var top = ref.pageYOffset;
|
|
var left = ref.pageXOffset;
|
|
|
|
if (isWindow(element)) {
|
|
|
|
var height = element.innerHeight;
|
|
var width = element.innerWidth;
|
|
|
|
return {
|
|
top: top,
|
|
left: left,
|
|
height: height,
|
|
width: width,
|
|
bottom: top + height,
|
|
right: left + width
|
|
};
|
|
}
|
|
|
|
var style, hidden;
|
|
|
|
if (!isVisible(element) && css(element, 'display') === 'none') {
|
|
|
|
style = attr(element, 'style');
|
|
hidden = attr(element, 'hidden');
|
|
|
|
attr(element, {
|
|
style: ((style || '') + ";display:block !important;"),
|
|
hidden: null
|
|
});
|
|
}
|
|
|
|
var rect = element.getBoundingClientRect();
|
|
|
|
if (!isUndefined(style)) {
|
|
attr(element, {style: style, hidden: hidden});
|
|
}
|
|
|
|
return {
|
|
height: rect.height,
|
|
width: rect.width,
|
|
top: rect.top + top,
|
|
left: rect.left + left,
|
|
bottom: rect.bottom + top,
|
|
right: rect.right + left
|
|
};
|
|
}
|
|
|
|
function position(element) {
|
|
element = toNode(element);
|
|
|
|
var parent = element.offsetParent || getDocEl(element);
|
|
var parentOffset = offset(parent);
|
|
var ref = ['top', 'left'].reduce(function (props, prop) {
|
|
var propName = ucfirst(prop);
|
|
props[prop] -= parentOffset[prop]
|
|
+ toFloat(css(element, ("margin" + propName)))
|
|
+ toFloat(css(parent, ("border" + propName + "Width")));
|
|
return props;
|
|
}, offset(element));
|
|
var top = ref.top;
|
|
var left = ref.left;
|
|
|
|
return {top: top, left: left};
|
|
}
|
|
|
|
var height = dimension('height');
|
|
var width = dimension('width');
|
|
|
|
function dimension(prop) {
|
|
var propName = ucfirst(prop);
|
|
return function (element, value) {
|
|
|
|
element = toNode(element);
|
|
|
|
if (isUndefined(value)) {
|
|
|
|
if (isWindow(element)) {
|
|
return element[("inner" + propName)];
|
|
}
|
|
|
|
if (isDocument(element)) {
|
|
var doc = element.documentElement;
|
|
return Math.max(doc[("offset" + propName)], doc[("scroll" + propName)]);
|
|
}
|
|
|
|
value = css(element, prop);
|
|
value = value === 'auto' ? element[("offset" + propName)] : toFloat(value) || 0;
|
|
|
|
return value - boxModelAdjust(prop, element);
|
|
|
|
} else {
|
|
|
|
css(element, prop, !value && value !== 0
|
|
? ''
|
|
: +value + boxModelAdjust(prop, element) + 'px'
|
|
);
|
|
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
function boxModelAdjust(prop, element, sizing) {
|
|
if ( sizing === void 0 ) sizing = 'border-box';
|
|
|
|
return css(element, 'boxSizing') === sizing
|
|
? dirs[prop].slice(1).map(ucfirst).reduce(function (value, prop) { return value
|
|
+ toFloat(css(element, ("padding" + prop)))
|
|
+ toFloat(css(element, ("border" + prop + "Width"))); }
|
|
, 0)
|
|
: 0;
|
|
}
|
|
|
|
function moveTo(position, attach, dim, factor) {
|
|
each(dirs, function (ref, prop) {
|
|
var dir = ref[0];
|
|
var align = ref[1];
|
|
var alignFlip = ref[2];
|
|
|
|
if (attach[dir] === alignFlip) {
|
|
position[align] += dim[prop] * factor;
|
|
} else if (attach[dir] === 'center') {
|
|
position[align] += dim[prop] * factor / 2;
|
|
}
|
|
});
|
|
}
|
|
|
|
function getPos(pos) {
|
|
|
|
var x = /left|center|right/;
|
|
var y = /top|center|bottom/;
|
|
|
|
pos = (pos || '').split(' ');
|
|
|
|
if (pos.length === 1) {
|
|
pos = x.test(pos[0])
|
|
? pos.concat(['center'])
|
|
: y.test(pos[0])
|
|
? ['center'].concat(pos)
|
|
: ['center', 'center'];
|
|
}
|
|
|
|
return {
|
|
x: x.test(pos[0]) ? pos[0] : 'center',
|
|
y: y.test(pos[1]) ? pos[1] : 'center'
|
|
};
|
|
}
|
|
|
|
function getOffsets(offsets, width, height) {
|
|
|
|
var ref = (offsets || '').split(' ');
|
|
var x = ref[0];
|
|
var y = ref[1];
|
|
|
|
return {
|
|
x: x ? toFloat(x) * (endsWith(x, '%') ? width / 100 : 1) : 0,
|
|
y: y ? toFloat(y) * (endsWith(y, '%') ? height / 100 : 1) : 0
|
|
};
|
|
}
|
|
|
|
function flipPosition(pos) {
|
|
switch (pos) {
|
|
case 'left':
|
|
return 'right';
|
|
case 'right':
|
|
return 'left';
|
|
case 'top':
|
|
return 'bottom';
|
|
case 'bottom':
|
|
return 'top';
|
|
default:
|
|
return pos;
|
|
}
|
|
}
|
|
|
|
function isInView(element, topOffset, leftOffset) {
|
|
if ( topOffset === void 0 ) topOffset = 0;
|
|
if ( leftOffset === void 0 ) leftOffset = 0;
|
|
|
|
|
|
if (!isVisible(element)) {
|
|
return false;
|
|
}
|
|
|
|
element = toNode(element);
|
|
|
|
var win = getWindow(element);
|
|
var client = element.getBoundingClientRect();
|
|
var bounding = {
|
|
top: -topOffset,
|
|
left: -leftOffset,
|
|
bottom: topOffset + height(win),
|
|
right: leftOffset + width(win)
|
|
};
|
|
|
|
return intersectRect(client, bounding) || pointInRect({x: client.left, y: client.top}, bounding);
|
|
|
|
}
|
|
|
|
function scrolledOver(element, heightOffset) {
|
|
if ( heightOffset === void 0 ) heightOffset = 0;
|
|
|
|
|
|
if (!isVisible(element)) {
|
|
return 0;
|
|
}
|
|
|
|
element = toNode(element);
|
|
|
|
var win = getWindow(element);
|
|
var doc = getDocument(element);
|
|
var elHeight = element.offsetHeight + heightOffset;
|
|
var ref = offsetPosition(element);
|
|
var top = ref[0];
|
|
var vp = height(win);
|
|
var vh = vp + Math.min(0, top - vp);
|
|
var diff = Math.max(0, vp - (height(doc) + heightOffset - (top + elHeight)));
|
|
|
|
return clamp(((vh + win.pageYOffset - top) / ((vh + (elHeight - (diff < vp ? diff : 0))) / 100)) / 100);
|
|
}
|
|
|
|
function scrollTop(element, top) {
|
|
element = toNode(element);
|
|
|
|
if (isWindow(element) || isDocument(element)) {
|
|
var ref = getWindow(element);
|
|
var scrollTo = ref.scrollTo;
|
|
var pageXOffset = ref.pageXOffset;
|
|
scrollTo(pageXOffset, top);
|
|
} else {
|
|
element.scrollTop = top;
|
|
}
|
|
}
|
|
|
|
function offsetPosition(element) {
|
|
var offset = [0, 0];
|
|
|
|
do {
|
|
|
|
offset[0] += element.offsetTop;
|
|
offset[1] += element.offsetLeft;
|
|
|
|
if (css(element, 'position') === 'fixed') {
|
|
var win = getWindow(element);
|
|
offset[0] += win.pageYOffset;
|
|
offset[1] += win.pageXOffset;
|
|
return offset;
|
|
}
|
|
|
|
} while ((element = element.offsetParent));
|
|
|
|
return offset;
|
|
}
|
|
|
|
function toPx(value, property, element) {
|
|
if ( property === void 0 ) property = 'width';
|
|
if ( element === void 0 ) element = window;
|
|
|
|
return isNumeric(value)
|
|
? +value
|
|
: endsWith(value, 'vh')
|
|
? percent(height(getWindow(element)), value)
|
|
: endsWith(value, 'vw')
|
|
? percent(width(getWindow(element)), value)
|
|
: endsWith(value, '%')
|
|
? percent(getDimensions(element)[property], value)
|
|
: toFloat(value);
|
|
}
|
|
|
|
function percent(base, value) {
|
|
return base * toFloat(value) / 100;
|
|
}
|
|
|
|
function getWindow(element) {
|
|
return isWindow(element) ? element : getDocument(element).defaultView;
|
|
}
|
|
|
|
function getDocument(element) {
|
|
return toNode(element).ownerDocument;
|
|
}
|
|
|
|
function getDocEl(element) {
|
|
return getDocument(element).documentElement;
|
|
}
|
|
|
|
/*
|
|
Based on:
|
|
Copyright (c) 2016 Wilson Page wilsonpage@me.com
|
|
https://github.com/wilsonpage/fastdom
|
|
*/
|
|
|
|
var fastdom = {
|
|
|
|
reads: [],
|
|
writes: [],
|
|
|
|
read: function(task) {
|
|
this.reads.push(task);
|
|
scheduleFlush();
|
|
return task;
|
|
},
|
|
|
|
write: function(task) {
|
|
this.writes.push(task);
|
|
scheduleFlush();
|
|
return task;
|
|
},
|
|
|
|
clear: function(task) {
|
|
return remove$1(this.reads, task) || remove$1(this.writes, task);
|
|
},
|
|
|
|
flush: flush
|
|
|
|
};
|
|
|
|
function flush() {
|
|
runTasks(fastdom.reads);
|
|
runTasks(fastdom.writes.splice(0, fastdom.writes.length));
|
|
|
|
fastdom.scheduled = false;
|
|
|
|
if (fastdom.reads.length || fastdom.writes.length) {
|
|
scheduleFlush(true);
|
|
}
|
|
}
|
|
|
|
function scheduleFlush(microtask) {
|
|
if ( microtask === void 0 ) microtask = false;
|
|
|
|
if (!fastdom.scheduled) {
|
|
fastdom.scheduled = true;
|
|
if (microtask) {
|
|
Promise.resolve().then(flush);
|
|
} else {
|
|
requestAnimationFrame(flush);
|
|
}
|
|
}
|
|
}
|
|
|
|
function runTasks(tasks) {
|
|
var task;
|
|
while ((task = tasks.shift())) {
|
|
task();
|
|
}
|
|
}
|
|
|
|
function remove$1(array, item) {
|
|
var index = array.indexOf(item);
|
|
return !!~index && !!array.splice(index, 1);
|
|
}
|
|
|
|
function MouseTracker() {}
|
|
|
|
MouseTracker.prototype = {
|
|
|
|
positions: [],
|
|
position: null,
|
|
|
|
init: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.positions = [];
|
|
this.position = null;
|
|
|
|
var ticking = false;
|
|
this.unbind = on(document, 'mousemove', function (e) {
|
|
|
|
if (ticking) {
|
|
return;
|
|
}
|
|
|
|
setTimeout(function () {
|
|
|
|
var time = Date.now();
|
|
var ref = this$1.positions;
|
|
var length = ref.length;
|
|
|
|
if (length && (time - this$1.positions[length - 1].time > 100)) {
|
|
this$1.positions.splice(0, length);
|
|
}
|
|
|
|
this$1.positions.push({time: time, x: e.pageX, y: e.pageY});
|
|
|
|
if (this$1.positions.length > 5) {
|
|
this$1.positions.shift();
|
|
}
|
|
|
|
ticking = false;
|
|
}, 5);
|
|
|
|
ticking = true;
|
|
});
|
|
|
|
},
|
|
|
|
cancel: function() {
|
|
if (this.unbind) {
|
|
this.unbind();
|
|
}
|
|
},
|
|
|
|
movesTo: function(target) {
|
|
|
|
if (this.positions.length < 2) {
|
|
return false;
|
|
}
|
|
|
|
var p = offset(target);
|
|
var position = this.positions[this.positions.length - 1];
|
|
var ref = this.positions;
|
|
var prevPos = ref[0];
|
|
|
|
if (p.left <= position.x && position.x <= p.right && p.top <= position.y && position.y <= p.bottom) {
|
|
return false;
|
|
}
|
|
|
|
var points = [
|
|
[{x: p.left, y: p.top}, {x: p.right, y: p.bottom}],
|
|
[{x: p.right, y: p.top}, {x: p.left, y: p.bottom}]
|
|
];
|
|
|
|
if (p.right <= position.x) ; else if (p.left >= position.x) {
|
|
points[0].reverse();
|
|
points[1].reverse();
|
|
} else if (p.bottom <= position.y) {
|
|
points[0].reverse();
|
|
} else if (p.top >= position.y) {
|
|
points[1].reverse();
|
|
}
|
|
|
|
return !!points.reduce(function (result, point) {
|
|
return result + (slope(prevPos, point[0]) < slope(position, point[0]) && slope(prevPos, point[1]) > slope(position, point[1]));
|
|
}, 0);
|
|
}
|
|
|
|
};
|
|
|
|
function slope(a, b) {
|
|
return (b.y - a.y) / (b.x - a.x);
|
|
}
|
|
|
|
var strats = {};
|
|
|
|
strats.events =
|
|
strats.created =
|
|
strats.beforeConnect =
|
|
strats.connected =
|
|
strats.beforeDisconnect =
|
|
strats.disconnected =
|
|
strats.destroy = concatStrat;
|
|
|
|
// args strategy
|
|
strats.args = function (parentVal, childVal) {
|
|
return childVal !== false && concatStrat(childVal || parentVal);
|
|
};
|
|
|
|
// update strategy
|
|
strats.update = function (parentVal, childVal) {
|
|
return sortBy(concatStrat(parentVal, isFunction(childVal) ? {read: childVal} : childVal), 'order');
|
|
};
|
|
|
|
// property strategy
|
|
strats.props = function (parentVal, childVal) {
|
|
|
|
if (isArray(childVal)) {
|
|
childVal = childVal.reduce(function (value, key) {
|
|
value[key] = String;
|
|
return value;
|
|
}, {});
|
|
}
|
|
|
|
return strats.methods(parentVal, childVal);
|
|
};
|
|
|
|
// extend strategy
|
|
strats.computed =
|
|
strats.methods = function (parentVal, childVal) {
|
|
return childVal
|
|
? parentVal
|
|
? assign({}, parentVal, childVal)
|
|
: childVal
|
|
: parentVal;
|
|
};
|
|
|
|
// data strategy
|
|
strats.data = function (parentVal, childVal, vm) {
|
|
|
|
if (!vm) {
|
|
|
|
if (!childVal) {
|
|
return parentVal;
|
|
}
|
|
|
|
if (!parentVal) {
|
|
return childVal;
|
|
}
|
|
|
|
return function (vm) {
|
|
return mergeFnData(parentVal, childVal, vm);
|
|
};
|
|
|
|
}
|
|
|
|
return mergeFnData(parentVal, childVal, vm);
|
|
};
|
|
|
|
function mergeFnData(parentVal, childVal, vm) {
|
|
return strats.computed(
|
|
isFunction(parentVal)
|
|
? parentVal.call(vm, vm)
|
|
: parentVal,
|
|
isFunction(childVal)
|
|
? childVal.call(vm, vm)
|
|
: childVal
|
|
);
|
|
}
|
|
|
|
// concat strategy
|
|
function concatStrat(parentVal, childVal) {
|
|
|
|
parentVal = parentVal && !isArray(parentVal) ? [parentVal] : parentVal;
|
|
|
|
return childVal
|
|
? parentVal
|
|
? parentVal.concat(childVal)
|
|
: isArray(childVal)
|
|
? childVal
|
|
: [childVal]
|
|
: parentVal;
|
|
}
|
|
|
|
// default strategy
|
|
function defaultStrat(parentVal, childVal) {
|
|
return isUndefined(childVal) ? parentVal : childVal;
|
|
}
|
|
|
|
function mergeOptions(parent, child, vm) {
|
|
|
|
var options = {};
|
|
|
|
if (isFunction(child)) {
|
|
child = child.options;
|
|
}
|
|
|
|
if (child.extends) {
|
|
parent = mergeOptions(parent, child.extends, vm);
|
|
}
|
|
|
|
if (child.mixins) {
|
|
for (var i = 0, l = child.mixins.length; i < l; i++) {
|
|
parent = mergeOptions(parent, child.mixins[i], vm);
|
|
}
|
|
}
|
|
|
|
for (var key in parent) {
|
|
mergeKey(key);
|
|
}
|
|
|
|
for (var key$1 in child) {
|
|
if (!hasOwn(parent, key$1)) {
|
|
mergeKey(key$1);
|
|
}
|
|
}
|
|
|
|
function mergeKey(key) {
|
|
options[key] = (strats[key] || defaultStrat)(parent[key], child[key], vm);
|
|
}
|
|
|
|
return options;
|
|
}
|
|
|
|
function parseOptions(options, args) {
|
|
var obj;
|
|
|
|
if ( args === void 0 ) args = [];
|
|
|
|
try {
|
|
|
|
return !options
|
|
? {}
|
|
: startsWith(options, '{')
|
|
? JSON.parse(options)
|
|
: args.length && !includes(options, ':')
|
|
? (( obj = {}, obj[args[0]] = options, obj ))
|
|
: options.split(';').reduce(function (options, option) {
|
|
var ref = option.split(/:(.*)/);
|
|
var key = ref[0];
|
|
var value = ref[1];
|
|
if (key && !isUndefined(value)) {
|
|
options[key.trim()] = value.trim();
|
|
}
|
|
return options;
|
|
}, {});
|
|
|
|
} catch (e) {
|
|
return {};
|
|
}
|
|
|
|
}
|
|
|
|
var id = 0;
|
|
|
|
var Player = function(el) {
|
|
this.id = ++id;
|
|
this.el = toNode(el);
|
|
};
|
|
|
|
Player.prototype.isVideo = function () {
|
|
return this.isYoutube() || this.isVimeo() || this.isHTML5();
|
|
};
|
|
|
|
Player.prototype.isHTML5 = function () {
|
|
return this.el.tagName === 'VIDEO';
|
|
};
|
|
|
|
Player.prototype.isIFrame = function () {
|
|
return this.el.tagName === 'IFRAME';
|
|
};
|
|
|
|
Player.prototype.isYoutube = function () {
|
|
return this.isIFrame() && !!this.el.src.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/);
|
|
};
|
|
|
|
Player.prototype.isVimeo = function () {
|
|
return this.isIFrame() && !!this.el.src.match(/vimeo\.com\/video\/.*/);
|
|
};
|
|
|
|
Player.prototype.enableApi = function () {
|
|
var this$1 = this;
|
|
|
|
|
|
if (this.ready) {
|
|
return this.ready;
|
|
}
|
|
|
|
var youtube = this.isYoutube();
|
|
var vimeo = this.isVimeo();
|
|
|
|
var poller;
|
|
|
|
if (youtube || vimeo) {
|
|
|
|
return this.ready = new Promise(function (resolve) {
|
|
|
|
once(this$1.el, 'load', function () {
|
|
if (youtube) {
|
|
var listener = function () { return post(this$1.el, {event: 'listening', id: this$1.id}); };
|
|
poller = setInterval(listener, 100);
|
|
listener();
|
|
}
|
|
});
|
|
|
|
listen(function (data) { return youtube && data.id === this$1.id && data.event === 'onReady' || vimeo && Number(data.player_id) === this$1.id; })
|
|
.then(function () {
|
|
resolve();
|
|
poller && clearInterval(poller);
|
|
});
|
|
|
|
attr(this$1.el, 'src', ("" + (this$1.el.src) + (includes(this$1.el.src, '?') ? '&' : '?') + (youtube ? 'enablejsapi=1' : ("api=1&player_id=" + (this$1.id)))));
|
|
|
|
});
|
|
|
|
}
|
|
|
|
return Promise.resolve();
|
|
|
|
};
|
|
|
|
Player.prototype.play = function () {
|
|
var this$1 = this;
|
|
|
|
|
|
if (!this.isVideo()) {
|
|
return;
|
|
}
|
|
|
|
if (this.isIFrame()) {
|
|
this.enableApi().then(function () { return post(this$1.el, {func: 'playVideo', method: 'play'}); });
|
|
} else if (this.isHTML5()) {
|
|
try {
|
|
var promise = this.el.play();
|
|
|
|
if (promise) {
|
|
promise.catch(noop);
|
|
}
|
|
} catch (e) {}
|
|
}
|
|
};
|
|
|
|
Player.prototype.pause = function () {
|
|
var this$1 = this;
|
|
|
|
|
|
if (!this.isVideo()) {
|
|
return;
|
|
}
|
|
|
|
if (this.isIFrame()) {
|
|
this.enableApi().then(function () { return post(this$1.el, {func: 'pauseVideo', method: 'pause'}); });
|
|
} else if (this.isHTML5()) {
|
|
this.el.pause();
|
|
}
|
|
};
|
|
|
|
Player.prototype.mute = function () {
|
|
var this$1 = this;
|
|
|
|
|
|
if (!this.isVideo()) {
|
|
return;
|
|
}
|
|
|
|
if (this.isIFrame()) {
|
|
this.enableApi().then(function () { return post(this$1.el, {func: 'mute', method: 'setVolume', value: 0}); });
|
|
} else if (this.isHTML5()) {
|
|
this.el.muted = true;
|
|
attr(this.el, 'muted', '');
|
|
}
|
|
|
|
};
|
|
|
|
function post(el, cmd) {
|
|
try {
|
|
el.contentWindow.postMessage(JSON.stringify(assign({event: 'command'}, cmd)), '*');
|
|
} catch (e) {}
|
|
}
|
|
|
|
function listen(cb) {
|
|
|
|
return new Promise(function (resolve) {
|
|
|
|
once(window, 'message', function (_, data) { return resolve(data); }, false, function (ref) {
|
|
var data = ref.data;
|
|
|
|
|
|
if (!data || !isString(data)) {
|
|
return;
|
|
}
|
|
|
|
try {
|
|
data = JSON.parse(data);
|
|
} catch (e) {
|
|
return;
|
|
}
|
|
|
|
return data && cb(data);
|
|
|
|
});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
var IntersectionObserver = 'IntersectionObserver' in window
|
|
? window.IntersectionObserver
|
|
: /*@__PURE__*/(function () {
|
|
function IntersectionObserverClass(callback, ref) {
|
|
var this$1 = this;
|
|
if ( ref === void 0 ) ref = {};
|
|
var rootMargin = ref.rootMargin; if ( rootMargin === void 0 ) rootMargin = '0 0';
|
|
|
|
|
|
this.targets = [];
|
|
|
|
var ref$1 = (rootMargin || '0 0').split(' ').map(toFloat);
|
|
var offsetTop = ref$1[0];
|
|
var offsetLeft = ref$1[1];
|
|
|
|
this.offsetTop = offsetTop;
|
|
this.offsetLeft = offsetLeft;
|
|
|
|
var pending;
|
|
this.apply = function () {
|
|
|
|
if (pending) {
|
|
return;
|
|
}
|
|
|
|
pending = requestAnimationFrame(function () { return setTimeout(function () {
|
|
var records = this$1.takeRecords();
|
|
|
|
if (records.length) {
|
|
callback(records, this$1);
|
|
}
|
|
|
|
pending = false;
|
|
}); });
|
|
|
|
};
|
|
|
|
this.off = on(window, 'scroll resize load', this.apply, {passive: true, capture: true});
|
|
|
|
}
|
|
|
|
IntersectionObserverClass.prototype.takeRecords = function () {
|
|
var this$1 = this;
|
|
|
|
return this.targets.filter(function (entry) {
|
|
|
|
var inView = isInView(entry.target, this$1.offsetTop, this$1.offsetLeft);
|
|
|
|
if (entry.isIntersecting === null || inView ^ entry.isIntersecting) {
|
|
entry.isIntersecting = inView;
|
|
return true;
|
|
}
|
|
|
|
});
|
|
};
|
|
|
|
IntersectionObserverClass.prototype.observe = function (target) {
|
|
this.targets.push({
|
|
target: target,
|
|
isIntersecting: null
|
|
});
|
|
this.apply();
|
|
};
|
|
|
|
IntersectionObserverClass.prototype.disconnect = function () {
|
|
this.targets = [];
|
|
this.off();
|
|
};
|
|
|
|
return IntersectionObserverClass;
|
|
}());
|
|
|
|
|
|
|
|
var util = /*#__PURE__*/Object.freeze({
|
|
ajax: ajax,
|
|
getImage: getImage,
|
|
transition: transition,
|
|
Transition: Transition,
|
|
animate: animate,
|
|
Animation: Animation,
|
|
attr: attr,
|
|
hasAttr: hasAttr,
|
|
removeAttr: removeAttr,
|
|
data: data,
|
|
addClass: addClass,
|
|
removeClass: removeClass,
|
|
removeClasses: removeClasses,
|
|
replaceClass: replaceClass,
|
|
hasClass: hasClass,
|
|
toggleClass: toggleClass,
|
|
positionAt: positionAt,
|
|
offset: offset,
|
|
position: position,
|
|
height: height,
|
|
width: width,
|
|
boxModelAdjust: boxModelAdjust,
|
|
flipPosition: flipPosition,
|
|
isInView: isInView,
|
|
scrolledOver: scrolledOver,
|
|
scrollTop: scrollTop,
|
|
offsetPosition: offsetPosition,
|
|
toPx: toPx,
|
|
ready: ready,
|
|
index: index,
|
|
getIndex: getIndex,
|
|
empty: empty,
|
|
html: html,
|
|
prepend: prepend,
|
|
append: append,
|
|
before: before,
|
|
after: after,
|
|
remove: remove,
|
|
wrapAll: wrapAll,
|
|
wrapInner: wrapInner,
|
|
unwrap: unwrap,
|
|
fragment: fragment,
|
|
apply: apply,
|
|
$: $,
|
|
$$: $$,
|
|
isIE: isIE,
|
|
isRtl: isRtl,
|
|
hasTouch: hasTouch,
|
|
pointerDown: pointerDown,
|
|
pointerMove: pointerMove,
|
|
pointerUp: pointerUp,
|
|
pointerEnter: pointerEnter,
|
|
pointerLeave: pointerLeave,
|
|
pointerCancel: pointerCancel,
|
|
on: on,
|
|
off: off,
|
|
once: once,
|
|
trigger: trigger,
|
|
createEvent: createEvent,
|
|
toEventTargets: toEventTargets,
|
|
isTouch: isTouch,
|
|
getEventPos: getEventPos,
|
|
fastdom: fastdom,
|
|
isVoidElement: isVoidElement,
|
|
isVisible: isVisible,
|
|
selInput: selInput,
|
|
isInput: isInput,
|
|
filter: filter,
|
|
within: within,
|
|
bind: bind,
|
|
hasOwn: hasOwn,
|
|
hyphenate: hyphenate,
|
|
camelize: camelize,
|
|
ucfirst: ucfirst,
|
|
startsWith: startsWith,
|
|
endsWith: endsWith,
|
|
includes: includes,
|
|
findIndex: findIndex,
|
|
isArray: isArray,
|
|
isFunction: isFunction,
|
|
isObject: isObject,
|
|
isPlainObject: isPlainObject,
|
|
isWindow: isWindow,
|
|
isDocument: isDocument,
|
|
isJQuery: isJQuery,
|
|
isNode: isNode,
|
|
isNodeCollection: isNodeCollection,
|
|
isBoolean: isBoolean,
|
|
isString: isString,
|
|
isNumber: isNumber,
|
|
isNumeric: isNumeric,
|
|
isEmpty: isEmpty,
|
|
isUndefined: isUndefined,
|
|
toBoolean: toBoolean,
|
|
toNumber: toNumber,
|
|
toFloat: toFloat,
|
|
toNode: toNode,
|
|
toNodes: toNodes,
|
|
toList: toList,
|
|
toMs: toMs,
|
|
isEqual: isEqual,
|
|
swap: swap,
|
|
assign: assign,
|
|
each: each,
|
|
sortBy: sortBy,
|
|
uniqueBy: uniqueBy,
|
|
clamp: clamp,
|
|
noop: noop,
|
|
intersectRect: intersectRect,
|
|
pointInRect: pointInRect,
|
|
Dimensions: Dimensions,
|
|
MouseTracker: MouseTracker,
|
|
mergeOptions: mergeOptions,
|
|
parseOptions: parseOptions,
|
|
Player: Player,
|
|
Promise: Promise,
|
|
Deferred: Deferred,
|
|
IntersectionObserver: IntersectionObserver,
|
|
query: query,
|
|
queryAll: queryAll,
|
|
find: find,
|
|
findAll: findAll,
|
|
matches: matches,
|
|
closest: closest,
|
|
parents: parents,
|
|
escape: escape,
|
|
css: css,
|
|
getStyles: getStyles,
|
|
getStyle: getStyle,
|
|
getCssVar: getCssVar,
|
|
propName: propName
|
|
});
|
|
|
|
function componentAPI (UIkit) {
|
|
|
|
var DATA = UIkit.data;
|
|
|
|
var components = {};
|
|
|
|
UIkit.component = function (name, options) {
|
|
|
|
if (!options) {
|
|
|
|
if (isPlainObject(components[name])) {
|
|
components[name] = UIkit.extend(components[name]);
|
|
}
|
|
|
|
return components[name];
|
|
|
|
}
|
|
|
|
UIkit[name] = function (element, data) {
|
|
var i = arguments.length, argsArray = Array(i);
|
|
while ( i-- ) argsArray[i] = arguments[i];
|
|
|
|
|
|
var component = UIkit.component(name);
|
|
|
|
if (isPlainObject(element)) {
|
|
return new component({data: element});
|
|
}
|
|
|
|
if (component.options.functional) {
|
|
return new component({data: [].concat( argsArray )});
|
|
}
|
|
|
|
return element && element.nodeType ? init(element) : $$(element).map(init)[0];
|
|
|
|
function init(element) {
|
|
|
|
var instance = UIkit.getComponent(element, name);
|
|
|
|
if (instance) {
|
|
if (!data) {
|
|
return instance;
|
|
} else {
|
|
instance.$destroy();
|
|
}
|
|
}
|
|
|
|
return new component({el: element, data: data});
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var opt = isPlainObject(options) ? assign({}, options) : options.options;
|
|
|
|
opt.name = name;
|
|
|
|
if (opt.install) {
|
|
opt.install(UIkit, opt, name);
|
|
}
|
|
|
|
if (UIkit._initialized && !opt.functional) {
|
|
var id = hyphenate(name);
|
|
fastdom.read(function () { return UIkit[name](("[uk-" + id + "],[data-uk-" + id + "]")); });
|
|
}
|
|
|
|
return components[name] = isPlainObject(options) ? opt : options;
|
|
};
|
|
|
|
UIkit.getComponents = function (element) { return element && element[DATA] || {}; };
|
|
UIkit.getComponent = function (element, name) { return UIkit.getComponents(element)[name]; };
|
|
|
|
UIkit.connect = function (node) {
|
|
|
|
if (node[DATA]) {
|
|
for (var name in node[DATA]) {
|
|
node[DATA][name]._callConnected();
|
|
}
|
|
}
|
|
|
|
for (var i = 0; i < node.attributes.length; i++) {
|
|
|
|
var name$1 = getComponentName(node.attributes[i].name);
|
|
|
|
if (name$1 && name$1 in components) {
|
|
UIkit[name$1](node);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
UIkit.disconnect = function (node) {
|
|
for (var name in node[DATA]) {
|
|
node[DATA][name]._callDisconnected();
|
|
}
|
|
};
|
|
|
|
}
|
|
|
|
function getComponentName(attribute) {
|
|
return startsWith(attribute, 'uk-') || startsWith(attribute, 'data-uk-')
|
|
? camelize(attribute.replace('data-uk-', '').replace('uk-', ''))
|
|
: false;
|
|
}
|
|
|
|
function boot (UIkit) {
|
|
|
|
var connect = UIkit.connect;
|
|
var disconnect = UIkit.disconnect;
|
|
|
|
if (!('MutationObserver' in window)) {
|
|
return;
|
|
}
|
|
|
|
if (document.body) {
|
|
|
|
init();
|
|
|
|
} else {
|
|
|
|
(new MutationObserver(function () {
|
|
|
|
if (document.body) {
|
|
this.disconnect();
|
|
init();
|
|
}
|
|
|
|
})).observe(document, {childList: true, subtree: true});
|
|
|
|
}
|
|
|
|
function init() {
|
|
|
|
apply(document.body, connect);
|
|
|
|
// Safari renders prior to first animation frame
|
|
fastdom.flush();
|
|
|
|
(new MutationObserver(function (mutations) { return mutations.forEach(applyMutation); })).observe(document, {
|
|
childList: true,
|
|
subtree: true,
|
|
characterData: true,
|
|
attributes: true
|
|
});
|
|
|
|
UIkit._initialized = true;
|
|
}
|
|
|
|
function applyMutation(mutation) {
|
|
|
|
var target = mutation.target;
|
|
var type = mutation.type;
|
|
|
|
var update = type !== 'attributes'
|
|
? applyChildList(mutation)
|
|
: applyAttribute(mutation);
|
|
|
|
update && UIkit.update(target);
|
|
|
|
}
|
|
|
|
function applyAttribute(ref) {
|
|
var target = ref.target;
|
|
var attributeName = ref.attributeName;
|
|
|
|
|
|
if (attributeName === 'href') {
|
|
return true;
|
|
}
|
|
|
|
var name = getComponentName(attributeName);
|
|
|
|
if (!name || !(name in UIkit)) {
|
|
return;
|
|
}
|
|
|
|
if (hasAttr(target, attributeName)) {
|
|
UIkit[name](target);
|
|
return true;
|
|
}
|
|
|
|
var component = UIkit.getComponent(target, name);
|
|
|
|
if (component) {
|
|
component.$destroy();
|
|
return true;
|
|
}
|
|
|
|
}
|
|
|
|
function applyChildList(ref) {
|
|
var addedNodes = ref.addedNodes;
|
|
var removedNodes = ref.removedNodes;
|
|
|
|
|
|
for (var i = 0; i < addedNodes.length; i++) {
|
|
apply(addedNodes[i], connect);
|
|
}
|
|
|
|
for (var i$1 = 0; i$1 < removedNodes.length; i$1++) {
|
|
apply(removedNodes[i$1], disconnect);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
function apply(node, fn) {
|
|
|
|
if (node.nodeType !== 1 || hasAttr(node, 'uk-no-boot')) {
|
|
return;
|
|
}
|
|
|
|
fn(node);
|
|
node = node.firstElementChild;
|
|
while (node) {
|
|
var next = node.nextElementSibling;
|
|
apply(node, fn);
|
|
node = next;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function globalAPI (UIkit) {
|
|
|
|
var DATA = UIkit.data;
|
|
|
|
UIkit.use = function (plugin) {
|
|
|
|
if (plugin.installed) {
|
|
return;
|
|
}
|
|
|
|
plugin.call(null, this);
|
|
plugin.installed = true;
|
|
|
|
return this;
|
|
};
|
|
|
|
UIkit.mixin = function (mixin, component) {
|
|
component = (isString(component) ? UIkit.component(component) : component) || this;
|
|
component.options = mergeOptions(component.options, mixin);
|
|
};
|
|
|
|
UIkit.extend = function (options) {
|
|
|
|
options = options || {};
|
|
|
|
var Super = this;
|
|
var Sub = function UIkitComponent(options) {
|
|
this._init(options);
|
|
};
|
|
|
|
Sub.prototype = Object.create(Super.prototype);
|
|
Sub.prototype.constructor = Sub;
|
|
Sub.options = mergeOptions(Super.options, options);
|
|
|
|
Sub.super = Super;
|
|
Sub.extend = Super.extend;
|
|
|
|
return Sub;
|
|
};
|
|
|
|
UIkit.update = function (element, e) {
|
|
|
|
element = element ? toNode(element) : document.body;
|
|
|
|
path(element, function (element) { return update(element[DATA], e); });
|
|
apply(element, function (element) { return update(element[DATA], e); });
|
|
|
|
};
|
|
|
|
var container;
|
|
Object.defineProperty(UIkit, 'container', {
|
|
|
|
get: function() {
|
|
return container || document.body;
|
|
},
|
|
|
|
set: function(element) {
|
|
container = $(element);
|
|
}
|
|
|
|
});
|
|
|
|
function update(data, e) {
|
|
|
|
if (!data) {
|
|
return;
|
|
}
|
|
|
|
for (var name in data) {
|
|
if (data[name]._connected) {
|
|
data[name]._callUpdate(e);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function path(node, fn) {
|
|
if (node && node !== document.body && node.parentNode) {
|
|
path(node.parentNode, fn);
|
|
fn(node.parentNode);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
function hooksAPI (UIkit) {
|
|
|
|
UIkit.prototype._callHook = function (hook) {
|
|
var this$1 = this;
|
|
|
|
|
|
var handlers = this.$options[hook];
|
|
|
|
if (handlers) {
|
|
handlers.forEach(function (handler) { return handler.call(this$1); });
|
|
}
|
|
};
|
|
|
|
UIkit.prototype._callConnected = function () {
|
|
|
|
if (this._connected) {
|
|
return;
|
|
}
|
|
|
|
this._data = {};
|
|
this._computeds = {};
|
|
this._initProps();
|
|
|
|
this._callHook('beforeConnect');
|
|
this._connected = true;
|
|
|
|
this._initEvents();
|
|
this._initObserver();
|
|
|
|
this._callHook('connected');
|
|
this._callUpdate();
|
|
};
|
|
|
|
UIkit.prototype._callDisconnected = function () {
|
|
|
|
if (!this._connected) {
|
|
return;
|
|
}
|
|
|
|
this._callHook('beforeDisconnect');
|
|
|
|
if (this._observer) {
|
|
this._observer.disconnect();
|
|
this._observer = null;
|
|
}
|
|
|
|
this._unbindEvents();
|
|
this._callHook('disconnected');
|
|
|
|
this._connected = false;
|
|
|
|
};
|
|
|
|
UIkit.prototype._callUpdate = function (e) {
|
|
var this$1 = this;
|
|
if ( e === void 0 ) e = 'update';
|
|
|
|
|
|
var type = e.type || e;
|
|
|
|
if (includes(['update', 'resize'], type)) {
|
|
this._callWatches();
|
|
}
|
|
|
|
var updates = this.$options.update;
|
|
var ref = this._frames;
|
|
var reads = ref.reads;
|
|
var writes = ref.writes;
|
|
|
|
if (!updates) {
|
|
return;
|
|
}
|
|
|
|
updates.forEach(function (ref, i) {
|
|
var read = ref.read;
|
|
var write = ref.write;
|
|
var events = ref.events;
|
|
|
|
|
|
if (type !== 'update' && !includes(events, type)) {
|
|
return;
|
|
}
|
|
|
|
if (read && !includes(fastdom.reads, reads[i])) {
|
|
reads[i] = fastdom.read(function () {
|
|
|
|
var result = this$1._connected && read.call(this$1, this$1._data, type);
|
|
|
|
if (result === false && write) {
|
|
fastdom.clear(writes[i]);
|
|
} else if (isPlainObject(result)) {
|
|
assign(this$1._data, result);
|
|
}
|
|
});
|
|
}
|
|
|
|
if (write && !includes(fastdom.writes, writes[i])) {
|
|
writes[i] = fastdom.write(function () { return this$1._connected && write.call(this$1, this$1._data, type); });
|
|
}
|
|
|
|
});
|
|
|
|
};
|
|
|
|
}
|
|
|
|
function stateAPI (UIkit) {
|
|
|
|
var uid = 0;
|
|
|
|
UIkit.prototype._init = function (options) {
|
|
|
|
options = options || {};
|
|
options.data = normalizeData(options, this.constructor.options);
|
|
|
|
this.$options = mergeOptions(this.constructor.options, options, this);
|
|
this.$el = null;
|
|
this.$props = {};
|
|
|
|
this._frames = {reads: {}, writes: {}};
|
|
this._events = [];
|
|
|
|
this._uid = uid++;
|
|
this._initData();
|
|
this._initMethods();
|
|
this._initComputeds();
|
|
this._callHook('created');
|
|
|
|
if (options.el) {
|
|
this.$mount(options.el);
|
|
}
|
|
};
|
|
|
|
UIkit.prototype._initData = function () {
|
|
|
|
var ref = this.$options;
|
|
var data = ref.data; if ( data === void 0 ) data = {};
|
|
|
|
for (var key in data) {
|
|
this.$props[key] = this[key] = data[key];
|
|
}
|
|
};
|
|
|
|
UIkit.prototype._initMethods = function () {
|
|
|
|
var ref = this.$options;
|
|
var methods = ref.methods;
|
|
|
|
if (methods) {
|
|
for (var key in methods) {
|
|
this[key] = bind(methods[key], this);
|
|
}
|
|
}
|
|
};
|
|
|
|
UIkit.prototype._initComputeds = function () {
|
|
|
|
var ref = this.$options;
|
|
var computed = ref.computed;
|
|
|
|
this._computeds = {};
|
|
|
|
if (computed) {
|
|
for (var key in computed) {
|
|
registerComputed(this, key, computed[key]);
|
|
}
|
|
}
|
|
};
|
|
|
|
UIkit.prototype._callWatches = function () {
|
|
|
|
var ref = this;
|
|
var computed = ref.$options.computed;
|
|
var _computeds = ref._computeds;
|
|
|
|
for (var key in _computeds) {
|
|
|
|
var value = _computeds[key];
|
|
delete _computeds[key];
|
|
|
|
if (computed[key].watch && !isEqual(value, this[key])) {
|
|
computed[key].watch.call(this, this[key], value);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
UIkit.prototype._initProps = function (props) {
|
|
|
|
var key;
|
|
|
|
props = props || getProps(this.$options, this.$name);
|
|
|
|
for (key in props) {
|
|
if (!isUndefined(props[key])) {
|
|
this.$props[key] = props[key];
|
|
}
|
|
}
|
|
|
|
var exclude = [this.$options.computed, this.$options.methods];
|
|
for (key in this.$props) {
|
|
if (key in props && notIn(exclude, key)) {
|
|
this[key] = this.$props[key];
|
|
}
|
|
}
|
|
};
|
|
|
|
UIkit.prototype._initEvents = function () {
|
|
var this$1 = this;
|
|
|
|
|
|
var ref = this.$options;
|
|
var events = ref.events;
|
|
|
|
if (events) {
|
|
|
|
events.forEach(function (event) {
|
|
|
|
if (!hasOwn(event, 'handler')) {
|
|
for (var key in event) {
|
|
registerEvent(this$1, event[key], key);
|
|
}
|
|
} else {
|
|
registerEvent(this$1, event);
|
|
}
|
|
|
|
});
|
|
}
|
|
};
|
|
|
|
UIkit.prototype._unbindEvents = function () {
|
|
this._events.forEach(function (unbind) { return unbind(); });
|
|
this._events = [];
|
|
};
|
|
|
|
UIkit.prototype._initObserver = function () {
|
|
var this$1 = this;
|
|
|
|
|
|
var ref = this.$options;
|
|
var attrs = ref.attrs;
|
|
var props = ref.props;
|
|
var el = ref.el;
|
|
if (this._observer || !props || attrs === false) {
|
|
return;
|
|
}
|
|
|
|
attrs = isArray(attrs) ? attrs : Object.keys(props);
|
|
|
|
this._observer = new MutationObserver(function () {
|
|
|
|
var data = getProps(this$1.$options, this$1.$name);
|
|
if (attrs.some(function (key) { return !isUndefined(data[key]) && data[key] !== this$1.$props[key]; })) {
|
|
this$1.$reset();
|
|
}
|
|
|
|
});
|
|
|
|
var filter = attrs.map(function (key) { return hyphenate(key); }).concat(this.$name);
|
|
|
|
this._observer.observe(el, {
|
|
attributes: true,
|
|
attributeFilter: filter.concat(filter.map(function (key) { return ("data-" + key); }))
|
|
});
|
|
};
|
|
|
|
function getProps(opts, name) {
|
|
|
|
var data$1 = {};
|
|
var args = opts.args; if ( args === void 0 ) args = [];
|
|
var props = opts.props; if ( props === void 0 ) props = {};
|
|
var el = opts.el;
|
|
|
|
if (!props) {
|
|
return data$1;
|
|
}
|
|
|
|
for (var key in props) {
|
|
var prop = hyphenate(key);
|
|
var value = data(el, prop);
|
|
|
|
if (!isUndefined(value)) {
|
|
|
|
value = props[key] === Boolean && value === ''
|
|
? true
|
|
: coerce(props[key], value);
|
|
|
|
if (prop === 'target' && (!value || startsWith(value, '_'))) {
|
|
continue;
|
|
}
|
|
|
|
data$1[key] = value;
|
|
}
|
|
}
|
|
|
|
var options = parseOptions(data(el, name), args);
|
|
|
|
for (var key$1 in options) {
|
|
var prop$1 = camelize(key$1);
|
|
if (props[prop$1] !== undefined) {
|
|
data$1[prop$1] = coerce(props[prop$1], options[key$1]);
|
|
}
|
|
}
|
|
|
|
return data$1;
|
|
}
|
|
|
|
function registerComputed(component, key, cb) {
|
|
Object.defineProperty(component, key, {
|
|
|
|
enumerable: true,
|
|
|
|
get: function() {
|
|
|
|
var _computeds = component._computeds;
|
|
var $props = component.$props;
|
|
var $el = component.$el;
|
|
|
|
if (!hasOwn(_computeds, key)) {
|
|
_computeds[key] = (cb.get || cb).call(component, $props, $el);
|
|
}
|
|
|
|
return _computeds[key];
|
|
},
|
|
|
|
set: function(value) {
|
|
|
|
var _computeds = component._computeds;
|
|
|
|
_computeds[key] = cb.set ? cb.set.call(component, value) : value;
|
|
|
|
if (isUndefined(_computeds[key])) {
|
|
delete _computeds[key];
|
|
}
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
function registerEvent(component, event, key) {
|
|
|
|
if (!isPlainObject(event)) {
|
|
event = ({name: key, handler: event});
|
|
}
|
|
|
|
var name = event.name;
|
|
var el = event.el;
|
|
var handler = event.handler;
|
|
var capture = event.capture;
|
|
var passive = event.passive;
|
|
var delegate = event.delegate;
|
|
var filter = event.filter;
|
|
var self = event.self;
|
|
el = isFunction(el)
|
|
? el.call(component)
|
|
: el || component.$el;
|
|
|
|
if (isArray(el)) {
|
|
el.forEach(function (el) { return registerEvent(component, assign({}, event, {el: el}), key); });
|
|
return;
|
|
}
|
|
|
|
if (!el || filter && !filter.call(component)) {
|
|
return;
|
|
}
|
|
|
|
handler = detail(isString(handler) ? component[handler] : bind(handler, component));
|
|
|
|
if (self) {
|
|
handler = selfFilter(handler);
|
|
}
|
|
|
|
component._events.push(
|
|
on(
|
|
el,
|
|
name,
|
|
!delegate
|
|
? null
|
|
: isString(delegate)
|
|
? delegate
|
|
: delegate.call(component),
|
|
handler,
|
|
isBoolean(passive)
|
|
? {passive: passive, capture: capture}
|
|
: capture
|
|
)
|
|
);
|
|
|
|
}
|
|
|
|
function selfFilter(handler) {
|
|
return function selfHandler(e) {
|
|
if (e.target === e.currentTarget || e.target === e.current) {
|
|
return handler.call(null, e);
|
|
}
|
|
};
|
|
}
|
|
|
|
function notIn(options, key) {
|
|
return options.every(function (arr) { return !arr || !hasOwn(arr, key); });
|
|
}
|
|
|
|
function detail(listener) {
|
|
return function (e) { return isArray(e.detail) ? listener.apply(void 0, [e].concat(e.detail)) : listener(e); };
|
|
}
|
|
|
|
function coerce(type, value) {
|
|
|
|
if (type === Boolean) {
|
|
return toBoolean(value);
|
|
} else if (type === Number) {
|
|
return toNumber(value);
|
|
} else if (type === 'list') {
|
|
return toList(value);
|
|
}
|
|
|
|
return type ? type(value) : value;
|
|
}
|
|
|
|
function normalizeData(ref, ref$1) {
|
|
var data = ref.data;
|
|
var el = ref.el;
|
|
var args = ref$1.args;
|
|
var props = ref$1.props; if ( props === void 0 ) props = {};
|
|
|
|
data = isArray(data)
|
|
? !isEmpty(args)
|
|
? data.slice(0, args.length).reduce(function (data, value, index) {
|
|
if (isPlainObject(value)) {
|
|
assign(data, value);
|
|
} else {
|
|
data[args[index]] = value;
|
|
}
|
|
return data;
|
|
}, {})
|
|
: undefined
|
|
: data;
|
|
|
|
if (data) {
|
|
for (var key in data) {
|
|
if (isUndefined(data[key])) {
|
|
delete data[key];
|
|
} else {
|
|
data[key] = props[key] ? coerce(props[key], data[key]) : data[key];
|
|
}
|
|
}
|
|
}
|
|
|
|
return data;
|
|
}
|
|
}
|
|
|
|
function instanceAPI (UIkit) {
|
|
|
|
var DATA = UIkit.data;
|
|
|
|
UIkit.prototype.$mount = function (el) {
|
|
|
|
var ref = this.$options;
|
|
var name = ref.name;
|
|
|
|
if (!el[DATA]) {
|
|
el[DATA] = {};
|
|
}
|
|
|
|
if (el[DATA][name]) {
|
|
return;
|
|
}
|
|
|
|
el[DATA][name] = this;
|
|
|
|
this.$el = this.$options.el = this.$options.el || el;
|
|
|
|
if (within(el, document)) {
|
|
this._callConnected();
|
|
}
|
|
};
|
|
|
|
UIkit.prototype.$emit = function (e) {
|
|
this._callUpdate(e);
|
|
};
|
|
|
|
UIkit.prototype.$reset = function () {
|
|
this._callDisconnected();
|
|
this._callConnected();
|
|
};
|
|
|
|
UIkit.prototype.$destroy = function (removeEl) {
|
|
if ( removeEl === void 0 ) removeEl = false;
|
|
|
|
|
|
var ref = this.$options;
|
|
var el = ref.el;
|
|
var name = ref.name;
|
|
|
|
if (el) {
|
|
this._callDisconnected();
|
|
}
|
|
|
|
this._callHook('destroy');
|
|
|
|
if (!el || !el[DATA]) {
|
|
return;
|
|
}
|
|
|
|
delete el[DATA][name];
|
|
|
|
if (!isEmpty(el[DATA])) {
|
|
delete el[DATA];
|
|
}
|
|
|
|
if (removeEl) {
|
|
remove(this.$el);
|
|
}
|
|
};
|
|
|
|
UIkit.prototype.$create = function (component, element, data) {
|
|
return UIkit[component](element, data);
|
|
};
|
|
|
|
UIkit.prototype.$update = UIkit.update;
|
|
UIkit.prototype.$getComponent = UIkit.getComponent;
|
|
|
|
var names = {};
|
|
Object.defineProperties(UIkit.prototype, {
|
|
|
|
$container: Object.getOwnPropertyDescriptor(UIkit, 'container'),
|
|
|
|
$name: {
|
|
|
|
get: function() {
|
|
var ref = this.$options;
|
|
var name = ref.name;
|
|
|
|
if (!names[name]) {
|
|
names[name] = UIkit.prefix + hyphenate(name);
|
|
}
|
|
|
|
return names[name];
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
var UIkit = function (options) {
|
|
this._init(options);
|
|
};
|
|
|
|
UIkit.util = util;
|
|
UIkit.data = '__uikit__';
|
|
UIkit.prefix = 'uk-';
|
|
UIkit.options = {};
|
|
|
|
globalAPI(UIkit);
|
|
hooksAPI(UIkit);
|
|
stateAPI(UIkit);
|
|
componentAPI(UIkit);
|
|
instanceAPI(UIkit);
|
|
|
|
var Class = {
|
|
|
|
connected: function() {
|
|
!hasClass(this.$el, this.$name) && addClass(this.$el, this.$name);
|
|
}
|
|
|
|
};
|
|
|
|
var Togglable = {
|
|
|
|
props: {
|
|
cls: Boolean,
|
|
animation: 'list',
|
|
duration: Number,
|
|
origin: String,
|
|
transition: String,
|
|
queued: Boolean
|
|
},
|
|
|
|
data: {
|
|
cls: false,
|
|
animation: [false],
|
|
duration: 200,
|
|
origin: false,
|
|
transition: 'linear',
|
|
queued: false,
|
|
|
|
initProps: {
|
|
overflow: '',
|
|
height: '',
|
|
paddingTop: '',
|
|
paddingBottom: '',
|
|
marginTop: '',
|
|
marginBottom: ''
|
|
},
|
|
|
|
hideProps: {
|
|
overflow: 'hidden',
|
|
height: 0,
|
|
paddingTop: 0,
|
|
paddingBottom: 0,
|
|
marginTop: 0,
|
|
marginBottom: 0
|
|
}
|
|
|
|
},
|
|
|
|
computed: {
|
|
|
|
hasAnimation: function(ref) {
|
|
var animation = ref.animation;
|
|
|
|
return !!animation[0];
|
|
},
|
|
|
|
hasTransition: function(ref) {
|
|
var animation = ref.animation;
|
|
|
|
return this.hasAnimation && animation[0] === true;
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
toggleElement: function(targets, show, animate) {
|
|
var this$1 = this;
|
|
|
|
return new Promise(function (resolve) {
|
|
|
|
targets = toNodes(targets);
|
|
|
|
var all = function (targets) { return Promise.all(targets.map(function (el) { return this$1._toggleElement(el, show, animate); })); };
|
|
var toggled = targets.filter(function (el) { return this$1.isToggled(el); });
|
|
var untoggled = targets.filter(function (el) { return !includes(toggled, el); });
|
|
|
|
var p;
|
|
|
|
if (!this$1.queued || !isUndefined(animate) || !isUndefined(show) || !this$1.hasAnimation || targets.length < 2) {
|
|
|
|
p = all(untoggled.concat(toggled));
|
|
|
|
} else {
|
|
|
|
var body = document.body;
|
|
var scroll = body.scrollTop;
|
|
var el = toggled[0];
|
|
var inProgress = Animation.inProgress(el) && hasClass(el, 'uk-animation-leave')
|
|
|| Transition.inProgress(el) && el.style.height === '0px';
|
|
|
|
p = all(toggled);
|
|
|
|
if (!inProgress) {
|
|
p = p.then(function () {
|
|
var p = all(untoggled);
|
|
body.scrollTop = scroll;
|
|
return p;
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
p.then(resolve, noop);
|
|
|
|
});
|
|
},
|
|
|
|
toggleNow: function(targets, show) {
|
|
var this$1 = this;
|
|
|
|
return new Promise(function (resolve) { return Promise.all(toNodes(targets).map(function (el) { return this$1._toggleElement(el, show, false); })).then(resolve, noop); });
|
|
},
|
|
|
|
isToggled: function(el) {
|
|
var nodes = toNodes(el || this.$el);
|
|
return this.cls
|
|
? hasClass(nodes, this.cls.split(' ')[0])
|
|
: !hasAttr(nodes, 'hidden');
|
|
},
|
|
|
|
updateAria: function(el) {
|
|
if (this.cls === false) {
|
|
attr(el, 'aria-hidden', !this.isToggled(el));
|
|
}
|
|
},
|
|
|
|
_toggleElement: function(el, show, animate) {
|
|
var this$1 = this;
|
|
|
|
|
|
show = isBoolean(show)
|
|
? show
|
|
: Animation.inProgress(el)
|
|
? hasClass(el, 'uk-animation-leave')
|
|
: Transition.inProgress(el)
|
|
? el.style.height === '0px'
|
|
: !this.isToggled(el);
|
|
|
|
if (!trigger(el, ("before" + (show ? 'show' : 'hide')), [this])) {
|
|
return Promise.reject();
|
|
}
|
|
|
|
var promise = (
|
|
isFunction(animate)
|
|
? animate
|
|
: animate === false || !this.hasAnimation
|
|
? this._toggle
|
|
: this.hasTransition
|
|
? toggleHeight(this)
|
|
: toggleAnimation(this)
|
|
)(el, show);
|
|
|
|
trigger(el, show ? 'show' : 'hide', [this]);
|
|
|
|
var final = function () {
|
|
trigger(el, show ? 'shown' : 'hidden', [this$1]);
|
|
this$1.$update(el);
|
|
};
|
|
|
|
return promise ? promise.then(final) : Promise.resolve(final());
|
|
},
|
|
|
|
_toggle: function(el, toggled) {
|
|
|
|
if (!el) {
|
|
return;
|
|
}
|
|
|
|
toggled = Boolean(toggled);
|
|
|
|
var changed;
|
|
if (this.cls) {
|
|
changed = includes(this.cls, ' ') || toggled !== hasClass(el, this.cls);
|
|
changed && toggleClass(el, this.cls, includes(this.cls, ' ') ? undefined : toggled);
|
|
} else {
|
|
changed = toggled === hasAttr(el, 'hidden');
|
|
changed && attr(el, 'hidden', !toggled ? '' : null);
|
|
}
|
|
|
|
$$('[autofocus]', el).some(function (el) { return isVisible(el) ? el.focus() || true : el.blur(); });
|
|
|
|
this.updateAria(el);
|
|
changed && this.$update(el);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function toggleHeight(ref) {
|
|
var isToggled = ref.isToggled;
|
|
var duration = ref.duration;
|
|
var initProps = ref.initProps;
|
|
var hideProps = ref.hideProps;
|
|
var transition = ref.transition;
|
|
var _toggle = ref._toggle;
|
|
|
|
return function (el, show) {
|
|
|
|
var inProgress = Transition.inProgress(el);
|
|
var inner = el.hasChildNodes ? toFloat(css(el.firstElementChild, 'marginTop')) + toFloat(css(el.lastElementChild, 'marginBottom')) : 0;
|
|
var currentHeight = isVisible(el) ? height(el) + (inProgress ? 0 : inner) : 0;
|
|
|
|
Transition.cancel(el);
|
|
|
|
if (!isToggled(el)) {
|
|
_toggle(el, true);
|
|
}
|
|
|
|
height(el, '');
|
|
|
|
// Update child components first
|
|
fastdom.flush();
|
|
|
|
var endHeight = height(el) + (inProgress ? 0 : inner);
|
|
height(el, currentHeight);
|
|
|
|
return (show
|
|
? Transition.start(el, assign({}, initProps, {overflow: 'hidden', height: endHeight}), Math.round(duration * (1 - currentHeight / endHeight)), transition)
|
|
: Transition.start(el, hideProps, Math.round(duration * (currentHeight / endHeight)), transition).then(function () { return _toggle(el, false); })
|
|
).then(function () { return css(el, initProps); });
|
|
|
|
};
|
|
}
|
|
|
|
function toggleAnimation(ref) {
|
|
var animation = ref.animation;
|
|
var duration = ref.duration;
|
|
var origin = ref.origin;
|
|
var _toggle = ref._toggle;
|
|
|
|
return function (el, show) {
|
|
|
|
Animation.cancel(el);
|
|
|
|
if (show) {
|
|
_toggle(el, true);
|
|
return Animation.in(el, animation[0], duration, origin);
|
|
}
|
|
|
|
return Animation.out(el, animation[1] || animation[0], duration, origin).then(function () { return _toggle(el, false); });
|
|
};
|
|
}
|
|
|
|
var Accordion = {
|
|
|
|
mixins: [Class, Togglable],
|
|
|
|
props: {
|
|
targets: String,
|
|
active: null,
|
|
collapsible: Boolean,
|
|
multiple: Boolean,
|
|
toggle: String,
|
|
content: String,
|
|
transition: String
|
|
},
|
|
|
|
data: {
|
|
targets: '> *',
|
|
active: false,
|
|
animation: [true],
|
|
collapsible: true,
|
|
multiple: false,
|
|
clsOpen: 'uk-open',
|
|
toggle: '> .uk-accordion-title',
|
|
content: '> .uk-accordion-content',
|
|
transition: 'ease'
|
|
},
|
|
|
|
computed: {
|
|
|
|
items: function(ref, $el) {
|
|
var targets = ref.targets;
|
|
|
|
return $$(targets, $el);
|
|
}
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return ((this.targets) + " " + (this.$props.toggle));
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
this.toggle(index($$(((this.targets) + " " + (this.$props.toggle)), this.$el), e.current));
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
connected: function() {
|
|
|
|
if (this.active === false) {
|
|
return;
|
|
}
|
|
|
|
var active = this.items[Number(this.active)];
|
|
if (active && !hasClass(active, this.clsOpen)) {
|
|
this.toggle(active, false);
|
|
}
|
|
},
|
|
|
|
update: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.items.forEach(function (el) { return this$1._toggle($(this$1.content, el), hasClass(el, this$1.clsOpen)); });
|
|
|
|
var active = !this.collapsible && !hasClass(this.items, this.clsOpen) && this.items[0];
|
|
if (active) {
|
|
this.toggle(active, false);
|
|
}
|
|
},
|
|
|
|
methods: {
|
|
|
|
toggle: function(item, animate) {
|
|
var this$1 = this;
|
|
|
|
|
|
var index = getIndex(item, this.items);
|
|
var active = filter(this.items, ("." + (this.clsOpen)));
|
|
|
|
item = this.items[index];
|
|
|
|
item && [item]
|
|
.concat(!this.multiple && !includes(active, item) && active || [])
|
|
.forEach(function (el) {
|
|
|
|
var isItem = el === item;
|
|
var state = isItem && !hasClass(el, this$1.clsOpen);
|
|
|
|
if (!state && isItem && !this$1.collapsible && active.length < 2) {
|
|
return;
|
|
}
|
|
|
|
toggleClass(el, this$1.clsOpen, state);
|
|
|
|
var content = el._wrapper ? el._wrapper.firstElementChild : $(this$1.content, el);
|
|
|
|
if (!el._wrapper) {
|
|
el._wrapper = wrapAll(content, '<div>');
|
|
attr(el._wrapper, 'hidden', state ? '' : null);
|
|
}
|
|
|
|
this$1._toggle(content, true);
|
|
this$1.toggleElement(el._wrapper, state, animate).then(function () {
|
|
|
|
if (hasClass(el, this$1.clsOpen) !== state) {
|
|
return;
|
|
}
|
|
|
|
if (!state) {
|
|
this$1._toggle(content, false);
|
|
}
|
|
|
|
el._wrapper = null;
|
|
unwrap(content);
|
|
|
|
});
|
|
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Alert = {
|
|
|
|
mixins: [Class, Togglable],
|
|
|
|
args: 'animation',
|
|
|
|
props: {
|
|
close: String
|
|
},
|
|
|
|
data: {
|
|
animation: [true],
|
|
selClose: '.uk-alert-close',
|
|
duration: 150,
|
|
hideProps: assign({opacity: 0}, Togglable.data.hideProps)
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return this.selClose;
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
this.close();
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
close: function() {
|
|
var this$1 = this;
|
|
|
|
this.toggleElement(this.$el).then(function () { return this$1.$destroy(true); });
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function Core (UIkit) {
|
|
|
|
ready(function () {
|
|
|
|
UIkit.update();
|
|
on(window, 'load resize', function () { return UIkit.update(null, 'resize'); });
|
|
on(document, 'loadedmetadata load', function (ref) {
|
|
var target = ref.target;
|
|
|
|
return UIkit.update(target, 'resize');
|
|
}, true);
|
|
|
|
// throttle `scroll` event (Safari triggers multiple `scroll` events per frame)
|
|
var pending;
|
|
on(window, 'scroll', function (e) {
|
|
|
|
if (pending) {
|
|
return;
|
|
}
|
|
pending = true;
|
|
fastdom.write(function () { return pending = false; });
|
|
|
|
var target = e.target;
|
|
UIkit.update(target.nodeType !== 1 ? document.body : target, e.type);
|
|
|
|
}, {passive: true, capture: true});
|
|
|
|
var started = 0;
|
|
on(document, 'animationstart', function (ref) {
|
|
var target = ref.target;
|
|
|
|
if ((css(target, 'animationName') || '').match(/^uk-.*(left|right)/)) {
|
|
|
|
started++;
|
|
css(document.body, 'overflowX', 'hidden');
|
|
setTimeout(function () {
|
|
if (!--started) {
|
|
css(document.body, 'overflowX', '');
|
|
}
|
|
}, toMs(css(target, 'animationDuration')) + 100);
|
|
}
|
|
}, true);
|
|
|
|
var off;
|
|
on(document, pointerDown, function (e) {
|
|
|
|
off && off();
|
|
|
|
if (!isTouch(e)) {
|
|
return;
|
|
}
|
|
|
|
var pos = getEventPos(e);
|
|
var target = 'tagName' in e.target ? e.target : e.target.parentNode;
|
|
off = once(document, pointerUp, function (e) {
|
|
|
|
var ref = getEventPos(e);
|
|
var x = ref.x;
|
|
var y = ref.y;
|
|
|
|
// swipe
|
|
if (target && x && Math.abs(pos.x - x) > 100 || y && Math.abs(pos.y - y) > 100) {
|
|
|
|
setTimeout(function () {
|
|
trigger(target, 'swipe');
|
|
trigger(target, ("swipe" + (swipeDirection(pos.x, pos.y, x, y))));
|
|
});
|
|
|
|
}
|
|
|
|
});
|
|
}, {passive: true});
|
|
|
|
});
|
|
|
|
}
|
|
|
|
function swipeDirection(x1, y1, x2, y2) {
|
|
return Math.abs(x1 - x2) >= Math.abs(y1 - y2)
|
|
? x1 - x2 > 0
|
|
? 'Left'
|
|
: 'Right'
|
|
: y1 - y2 > 0
|
|
? 'Up'
|
|
: 'Down';
|
|
}
|
|
|
|
var Video = {
|
|
|
|
args: 'autoplay',
|
|
|
|
props: {
|
|
automute: Boolean,
|
|
autoplay: Boolean
|
|
},
|
|
|
|
data: {
|
|
automute: false,
|
|
autoplay: true
|
|
},
|
|
|
|
computed: {
|
|
|
|
inView: function(ref) {
|
|
var autoplay = ref.autoplay;
|
|
|
|
return autoplay === 'inview';
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
|
|
if (this.inView && !hasAttr(this.$el, 'preload')) {
|
|
this.$el.preload = 'none';
|
|
}
|
|
|
|
this.player = new Player(this.$el);
|
|
|
|
if (this.automute) {
|
|
this.player.mute();
|
|
}
|
|
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
|
|
return !this.player
|
|
? false
|
|
: {
|
|
visible: isVisible(this.$el) && css(this.$el, 'visibility') !== 'hidden',
|
|
inView: this.inView && isInView(this.$el)
|
|
};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var visible = ref.visible;
|
|
var inView = ref.inView;
|
|
|
|
|
|
if (!visible || this.inView && !inView) {
|
|
this.player.pause();
|
|
} else if (this.autoplay === true || this.inView && inView) {
|
|
this.player.play();
|
|
}
|
|
|
|
},
|
|
|
|
events: ['resize', 'scroll']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Cover = {
|
|
|
|
mixins: [Class, Video],
|
|
|
|
props: {
|
|
width: Number,
|
|
height: Number
|
|
},
|
|
|
|
data: {
|
|
automute: true
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
|
|
var el = this.$el;
|
|
|
|
if (!isVisible(el)) {
|
|
return false;
|
|
}
|
|
|
|
var ref = el.parentNode;
|
|
var height = ref.offsetHeight;
|
|
var width = ref.offsetWidth;
|
|
|
|
return {height: height, width: width};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var height = ref.height;
|
|
var width = ref.width;
|
|
|
|
|
|
var el = this.$el;
|
|
var elWidth = this.width || el.naturalWidth || el.videoWidth || el.clientWidth;
|
|
var elHeight = this.height || el.naturalHeight || el.videoHeight || el.clientHeight;
|
|
|
|
if (!elWidth || !elHeight) {
|
|
return;
|
|
}
|
|
|
|
css(el, Dimensions.cover(
|
|
{
|
|
width: elWidth,
|
|
height: elHeight
|
|
},
|
|
{
|
|
width: width + (width % 2 ? 1 : 0),
|
|
height: height + (height % 2 ? 1 : 0)
|
|
}
|
|
));
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Position = {
|
|
|
|
props: {
|
|
pos: String,
|
|
offset: null,
|
|
flip: Boolean,
|
|
clsPos: String
|
|
},
|
|
|
|
data: {
|
|
pos: ("bottom-" + (!isRtl ? 'left' : 'right')),
|
|
flip: true,
|
|
offset: false,
|
|
clsPos: ''
|
|
},
|
|
|
|
computed: {
|
|
|
|
pos: function(ref) {
|
|
var pos = ref.pos;
|
|
|
|
return (pos + (!includes(pos, '-') ? '-center' : '')).split('-');
|
|
},
|
|
|
|
dir: function() {
|
|
return this.pos[0];
|
|
},
|
|
|
|
align: function() {
|
|
return this.pos[1];
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
positionAt: function(element, target, boundary) {
|
|
|
|
removeClasses(element, ((this.clsPos) + "-(top|bottom|left|right)(-[a-z]+)?"));
|
|
css(element, {top: '', left: ''});
|
|
|
|
var node;
|
|
var ref = this;
|
|
var offset$1 = ref.offset;
|
|
var axis = this.getAxis();
|
|
|
|
if (!isNumeric(offset$1)) {
|
|
node = $(offset$1);
|
|
offset$1 = node
|
|
? offset(node)[axis === 'x' ? 'left' : 'top'] - offset(target)[axis === 'x' ? 'right' : 'bottom']
|
|
: 0;
|
|
}
|
|
|
|
var ref$1 = positionAt(
|
|
element,
|
|
target,
|
|
axis === 'x' ? ((flipPosition(this.dir)) + " " + (this.align)) : ((this.align) + " " + (flipPosition(this.dir))),
|
|
axis === 'x' ? ((this.dir) + " " + (this.align)) : ((this.align) + " " + (this.dir)),
|
|
axis === 'x' ? ("" + (this.dir === 'left' ? -offset$1 : offset$1)) : (" " + (this.dir === 'top' ? -offset$1 : offset$1)),
|
|
null,
|
|
this.flip,
|
|
boundary
|
|
).target;
|
|
var x = ref$1.x;
|
|
var y = ref$1.y;
|
|
|
|
this.dir = axis === 'x' ? x : y;
|
|
this.align = axis === 'x' ? y : x;
|
|
|
|
toggleClass(element, ((this.clsPos) + "-" + (this.dir) + "-" + (this.align)), this.offset === false);
|
|
|
|
},
|
|
|
|
getAxis: function() {
|
|
return this.dir === 'top' || this.dir === 'bottom' ? 'y' : 'x';
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var active;
|
|
|
|
var Drop = {
|
|
|
|
mixins: [Position, Togglable],
|
|
|
|
args: 'pos',
|
|
|
|
props: {
|
|
mode: 'list',
|
|
toggle: Boolean,
|
|
boundary: Boolean,
|
|
boundaryAlign: Boolean,
|
|
delayShow: Number,
|
|
delayHide: Number,
|
|
clsDrop: String
|
|
},
|
|
|
|
data: {
|
|
mode: ['click', 'hover'],
|
|
toggle: '- *',
|
|
boundary: window,
|
|
boundaryAlign: false,
|
|
delayShow: 0,
|
|
delayHide: 800,
|
|
clsDrop: false,
|
|
hoverIdle: 200,
|
|
animation: ['uk-animation-fade'],
|
|
cls: 'uk-open'
|
|
},
|
|
|
|
computed: {
|
|
|
|
boundary: function(ref, $el) {
|
|
var boundary = ref.boundary;
|
|
|
|
return query(boundary, $el);
|
|
},
|
|
|
|
clsDrop: function(ref) {
|
|
var clsDrop = ref.clsDrop;
|
|
|
|
return clsDrop || ("uk-" + (this.$options.name));
|
|
},
|
|
|
|
clsPos: function() {
|
|
return this.clsDrop;
|
|
}
|
|
|
|
},
|
|
|
|
created: function() {
|
|
this.tracker = new MouseTracker();
|
|
},
|
|
|
|
connected: function() {
|
|
|
|
addClass(this.$el, this.clsDrop);
|
|
|
|
var ref = this.$props;
|
|
var toggle = ref.toggle;
|
|
this.toggle = toggle && this.$create('toggle', query(toggle, this.$el), {
|
|
target: this.$el,
|
|
mode: this.mode
|
|
});
|
|
|
|
!this.toggle && trigger(this.$el, 'updatearia');
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return ("." + (this.clsDrop) + "-close");
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
this.hide(false);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return 'a[href^="#"]';
|
|
},
|
|
|
|
handler: function(e) {
|
|
|
|
var id = e.target.hash;
|
|
|
|
if (!id) {
|
|
e.preventDefault();
|
|
}
|
|
|
|
if (!id || !within(id, this.$el)) {
|
|
this.hide(false);
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'beforescroll',
|
|
|
|
handler: function() {
|
|
this.hide(false);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'toggle',
|
|
|
|
self: true,
|
|
|
|
handler: function(e, toggle) {
|
|
|
|
e.preventDefault();
|
|
|
|
if (this.isToggled()) {
|
|
this.hide(false);
|
|
} else {
|
|
this.show(toggle, false);
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: pointerEnter,
|
|
|
|
filter: function() {
|
|
return includes(this.mode, 'hover');
|
|
},
|
|
|
|
handler: function(e) {
|
|
|
|
if (isTouch(e)) {
|
|
return;
|
|
}
|
|
|
|
if (active
|
|
&& active !== this
|
|
&& active.toggle
|
|
&& includes(active.toggle.mode, 'hover')
|
|
&& !within(e.target, active.toggle.$el)
|
|
&& !pointInRect({x: e.pageX, y: e.pageY}, offset(active.$el))
|
|
) {
|
|
active.hide(false);
|
|
}
|
|
|
|
e.preventDefault();
|
|
this.show(this.toggle);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'toggleshow',
|
|
|
|
handler: function(e, toggle) {
|
|
|
|
if (toggle && !includes(toggle.target, this.$el)) {
|
|
return;
|
|
}
|
|
|
|
e.preventDefault();
|
|
this.show(toggle || this.toggle);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: ("togglehide " + pointerLeave),
|
|
|
|
handler: function(e, toggle) {
|
|
|
|
if (isTouch(e) || toggle && !includes(toggle.target, this.$el)) {
|
|
return;
|
|
}
|
|
|
|
e.preventDefault();
|
|
|
|
if (this.toggle && includes(this.toggle.mode, 'hover')) {
|
|
this.hide();
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'beforeshow',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
this.clearTimers();
|
|
Animation.cancel(this.$el);
|
|
this.position();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'show',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
this.tracker.init();
|
|
trigger(this.$el, 'updatearia');
|
|
registerEvent();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'beforehide',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
this.clearTimers();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'hide',
|
|
|
|
handler: function(ref) {
|
|
var target = ref.target;
|
|
|
|
|
|
if (this.$el !== target) {
|
|
active = active === null && within(target, this.$el) && this.isToggled() ? this : active;
|
|
return;
|
|
}
|
|
|
|
active = this.isActive() ? null : active;
|
|
trigger(this.$el, 'updatearia');
|
|
this.tracker.cancel();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'updatearia',
|
|
|
|
self: true,
|
|
|
|
handler: function(e, toggle) {
|
|
|
|
e.preventDefault();
|
|
|
|
this.updateAria(this.$el);
|
|
|
|
if (toggle || this.toggle) {
|
|
attr((toggle || this.toggle).$el, 'aria-expanded', this.isToggled() ? 'true' : 'false');
|
|
toggleClass(this.toggle.$el, this.cls, this.isToggled());
|
|
}
|
|
}
|
|
}
|
|
|
|
],
|
|
|
|
update: {
|
|
|
|
write: function() {
|
|
|
|
if (this.isToggled() && !Animation.inProgress(this.$el)) {
|
|
this.position();
|
|
}
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
show: function(toggle, delay) {
|
|
var this$1 = this;
|
|
if ( delay === void 0 ) delay = true;
|
|
|
|
|
|
var show = function () { return !this$1.isToggled() && this$1.toggleElement(this$1.$el, true); };
|
|
var tryShow = function () {
|
|
|
|
this$1.toggle = toggle || this$1.toggle;
|
|
|
|
this$1.clearTimers();
|
|
|
|
if (this$1.isActive()) {
|
|
return;
|
|
} else if (delay && active && active !== this$1 && active.isDelaying) {
|
|
this$1.showTimer = setTimeout(this$1.show, 10);
|
|
return;
|
|
} else if (this$1.isParentOf(active)) {
|
|
|
|
if (active.hideTimer) {
|
|
active.hide(false);
|
|
} else {
|
|
return;
|
|
}
|
|
|
|
} else if (active && this$1.isChildOf(active)) {
|
|
|
|
active.clearTimers();
|
|
|
|
} else if (active && !this$1.isChildOf(active) && !this$1.isParentOf(active)) {
|
|
|
|
var prev;
|
|
while (active && active !== prev && !this$1.isChildOf(active)) {
|
|
prev = active;
|
|
active.hide(false);
|
|
}
|
|
|
|
}
|
|
|
|
if (delay && this$1.delayShow) {
|
|
this$1.showTimer = setTimeout(show, this$1.delayShow);
|
|
} else {
|
|
show();
|
|
}
|
|
|
|
active = this$1;
|
|
};
|
|
|
|
if (toggle && this.toggle && toggle.$el !== this.toggle.$el) {
|
|
|
|
once(this.$el, 'hide', tryShow);
|
|
this.hide(false);
|
|
|
|
} else {
|
|
tryShow();
|
|
}
|
|
},
|
|
|
|
hide: function(delay) {
|
|
var this$1 = this;
|
|
if ( delay === void 0 ) delay = true;
|
|
|
|
|
|
var hide = function () { return this$1.toggleNow(this$1.$el, false); };
|
|
|
|
this.clearTimers();
|
|
|
|
this.isDelaying = this.tracker.movesTo(this.$el);
|
|
|
|
if (delay && this.isDelaying) {
|
|
this.hideTimer = setTimeout(this.hide, this.hoverIdle);
|
|
} else if (delay && this.delayHide) {
|
|
this.hideTimer = setTimeout(hide, this.delayHide);
|
|
} else {
|
|
hide();
|
|
}
|
|
},
|
|
|
|
clearTimers: function() {
|
|
clearTimeout(this.showTimer);
|
|
clearTimeout(this.hideTimer);
|
|
this.showTimer = null;
|
|
this.hideTimer = null;
|
|
this.isDelaying = false;
|
|
},
|
|
|
|
isActive: function() {
|
|
return active === this;
|
|
},
|
|
|
|
isChildOf: function(drop) {
|
|
return drop && drop !== this && within(this.$el, drop.$el);
|
|
},
|
|
|
|
isParentOf: function(drop) {
|
|
return drop && drop !== this && within(drop.$el, this.$el);
|
|
},
|
|
|
|
position: function() {
|
|
|
|
removeClasses(this.$el, ((this.clsDrop) + "-(stack|boundary)"));
|
|
css(this.$el, {top: '', left: '', display: 'block'});
|
|
toggleClass(this.$el, ((this.clsDrop) + "-boundary"), this.boundaryAlign);
|
|
|
|
var boundary = offset(this.boundary);
|
|
var alignTo = this.boundaryAlign ? boundary : offset(this.toggle.$el);
|
|
|
|
if (this.align === 'justify') {
|
|
var prop = this.getAxis() === 'y' ? 'width' : 'height';
|
|
css(this.$el, prop, alignTo[prop]);
|
|
} else if (this.$el.offsetWidth > Math.max(boundary.right - alignTo.left, alignTo.right - boundary.left)) {
|
|
addClass(this.$el, ((this.clsDrop) + "-stack"));
|
|
}
|
|
|
|
this.positionAt(this.$el, this.boundaryAlign ? this.boundary : this.toggle.$el, this.boundary);
|
|
|
|
css(this.$el, 'display', '');
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var registered;
|
|
|
|
function registerEvent() {
|
|
|
|
if (registered) {
|
|
return;
|
|
}
|
|
|
|
registered = true;
|
|
on(document, pointerUp, function (ref) {
|
|
var target = ref.target;
|
|
var defaultPrevented = ref.defaultPrevented;
|
|
|
|
var prev;
|
|
|
|
if (defaultPrevented) {
|
|
return;
|
|
}
|
|
|
|
while (active && active !== prev && !within(target, active.$el) && !(active.toggle && within(target, active.toggle.$el))) {
|
|
prev = active;
|
|
active.hide(false);
|
|
}
|
|
});
|
|
}
|
|
|
|
var Dropdown = {
|
|
|
|
extends: Drop
|
|
|
|
};
|
|
|
|
var FormCustom = {
|
|
|
|
mixins: [Class],
|
|
|
|
args: 'target',
|
|
|
|
props: {
|
|
target: Boolean
|
|
},
|
|
|
|
data: {
|
|
target: false
|
|
},
|
|
|
|
computed: {
|
|
|
|
input: function(_, $el) {
|
|
return $(selInput, $el);
|
|
},
|
|
|
|
state: function() {
|
|
return this.input.nextElementSibling;
|
|
},
|
|
|
|
target: function(ref, $el) {
|
|
var target = ref.target;
|
|
|
|
return target && (target === true
|
|
&& this.input.parentNode === $el
|
|
&& this.input.nextElementSibling
|
|
|| query(target, $el));
|
|
}
|
|
|
|
},
|
|
|
|
update: function() {
|
|
|
|
var ref = this;
|
|
var target = ref.target;
|
|
var input = ref.input;
|
|
|
|
if (!target) {
|
|
return;
|
|
}
|
|
|
|
var option;
|
|
var prop = isInput(target) ? 'value' : 'textContent';
|
|
var prev = target[prop];
|
|
var value = input.files && input.files[0]
|
|
? input.files[0].name
|
|
: matches(input, 'select') && (option = $$('option', input).filter(function (el) { return el.selected; })[0])
|
|
? option.textContent
|
|
: input.value;
|
|
|
|
if (prev !== value) {
|
|
target[prop] = value;
|
|
}
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
name: 'change',
|
|
|
|
handler: function() {
|
|
this.$emit();
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'reset',
|
|
|
|
el: function() {
|
|
return closest(this.$el, 'form');
|
|
},
|
|
|
|
handler: function() {
|
|
this.$emit();
|
|
}
|
|
}
|
|
|
|
]
|
|
|
|
};
|
|
|
|
// Deprecated
|
|
var Gif = {
|
|
|
|
update: {
|
|
|
|
read: function(data) {
|
|
|
|
var inview = isInView(this.$el);
|
|
|
|
if (!inview || data.isInView === inview) {
|
|
return false;
|
|
}
|
|
|
|
data.isInView = inview;
|
|
},
|
|
|
|
write: function() {
|
|
this.$el.src = this.$el.src;
|
|
},
|
|
|
|
events: ['scroll', 'resize']
|
|
}
|
|
|
|
};
|
|
|
|
var Margin = {
|
|
|
|
props: {
|
|
margin: String,
|
|
firstColumn: Boolean
|
|
},
|
|
|
|
data: {
|
|
margin: 'uk-margin-small-top',
|
|
firstColumn: 'uk-first-column'
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function(data) {
|
|
|
|
var items = this.$el.children;
|
|
var rows = [[]];
|
|
|
|
if (!items.length || !isVisible(this.$el)) {
|
|
return data.rows = rows;
|
|
}
|
|
|
|
data.rows = getRows(items);
|
|
data.stacks = !data.rows.some(function (row) { return row.length > 1; });
|
|
|
|
},
|
|
|
|
write: function(ref) {
|
|
var this$1 = this;
|
|
var rows = ref.rows;
|
|
|
|
|
|
rows.forEach(function (row, i) { return row.forEach(function (el, j) {
|
|
toggleClass(el, this$1.margin, i !== 0);
|
|
toggleClass(el, this$1.firstColumn, j === 0);
|
|
}); }
|
|
);
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function getRows(items) {
|
|
var rows = [[]];
|
|
|
|
for (var i = 0; i < items.length; i++) {
|
|
|
|
var el = items[i];
|
|
var dim = getOffset(el);
|
|
|
|
if (!dim.height) {
|
|
continue;
|
|
}
|
|
|
|
for (var j = rows.length - 1; j >= 0; j--) {
|
|
|
|
var row = rows[j];
|
|
|
|
if (!row[0]) {
|
|
row.push(el);
|
|
break;
|
|
}
|
|
|
|
var leftDim = (void 0);
|
|
if (row[0].offsetParent === el.offsetParent) {
|
|
leftDim = getOffset(row[0]);
|
|
} else {
|
|
dim = getOffset(el, true);
|
|
leftDim = getOffset(row[0], true);
|
|
}
|
|
|
|
if (dim.top >= leftDim.bottom - 1) {
|
|
rows.push([el]);
|
|
break;
|
|
}
|
|
|
|
if (dim.bottom > leftDim.top) {
|
|
|
|
if (dim.left < leftDim.left && !isRtl) {
|
|
row.unshift(el);
|
|
break;
|
|
}
|
|
|
|
row.push(el);
|
|
break;
|
|
}
|
|
|
|
if (j === 0) {
|
|
rows.unshift([el]);
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return rows;
|
|
|
|
}
|
|
|
|
function getOffset(element, offset) {
|
|
var assign;
|
|
|
|
if ( offset === void 0 ) offset = false;
|
|
|
|
var offsetTop = element.offsetTop;
|
|
var offsetLeft = element.offsetLeft;
|
|
var offsetHeight = element.offsetHeight;
|
|
|
|
if (offset) {
|
|
(assign = offsetPosition(element), offsetTop = assign[0], offsetLeft = assign[1]);
|
|
}
|
|
|
|
return {
|
|
top: offsetTop,
|
|
left: offsetLeft,
|
|
height: offsetHeight,
|
|
bottom: offsetTop + offsetHeight
|
|
};
|
|
}
|
|
|
|
var Grid = {
|
|
|
|
extends: Margin,
|
|
|
|
mixins: [Class],
|
|
|
|
name: 'grid',
|
|
|
|
props: {
|
|
masonry: Boolean,
|
|
parallax: Number
|
|
},
|
|
|
|
data: {
|
|
margin: 'uk-grid-margin',
|
|
clsStack: 'uk-grid-stack',
|
|
masonry: false,
|
|
parallax: 0
|
|
},
|
|
|
|
computed: {
|
|
|
|
length: function(_, $el) {
|
|
return $el.children.length;
|
|
},
|
|
|
|
parallax: function(ref) {
|
|
var parallax = ref.parallax;
|
|
|
|
return parallax && this.length ? Math.abs(parallax) : '';
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
this.masonry && addClass(this.$el, 'uk-flex-top uk-flex-wrap-top');
|
|
},
|
|
|
|
update: [
|
|
|
|
{
|
|
|
|
read: function(ref) {
|
|
var rows = ref.rows;
|
|
|
|
|
|
if (this.masonry || this.parallax) {
|
|
rows = rows.map(function (elements) { return sortBy(elements, 'offsetLeft'); });
|
|
|
|
if (isRtl) {
|
|
rows.map(function (row) { return row.reverse(); });
|
|
}
|
|
|
|
}
|
|
|
|
var transitionInProgress = rows.some(function (elements) { return elements.some(Transition.inProgress); });
|
|
var translates = false;
|
|
var elHeight = '';
|
|
|
|
if (this.masonry && this.length) {
|
|
|
|
var height = 0;
|
|
|
|
translates = rows.reduce(function (translates, row, i) {
|
|
|
|
translates[i] = row.map(function (_, j) { return i === 0 ? 0 : toFloat(translates[i - 1][j]) + (height - toFloat(rows[i - 1][j] && rows[i - 1][j].offsetHeight)); });
|
|
height = row.reduce(function (height, el) { return Math.max(height, el.offsetHeight); }, 0);
|
|
|
|
return translates;
|
|
|
|
}, []);
|
|
|
|
elHeight = maxColumnHeight(rows) + getMarginTop(this.$el, this.margin) * (rows.length - 1);
|
|
|
|
}
|
|
|
|
return {rows: rows, translates: translates, height: !transitionInProgress ? elHeight : false};
|
|
|
|
},
|
|
|
|
write: function(ref) {
|
|
var stacks = ref.stacks;
|
|
var height = ref.height;
|
|
|
|
|
|
toggleClass(this.$el, this.clsStack, stacks);
|
|
|
|
css(this.$el, 'paddingBottom', this.parallax);
|
|
height !== false && css(this.$el, 'height', height);
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
{
|
|
|
|
read: function(ref) {
|
|
var height$1 = ref.height;
|
|
|
|
return {
|
|
scrolled: this.parallax
|
|
? scrolledOver(this.$el, height$1 ? height$1 - height(this.$el) : 0) * this.parallax
|
|
: false
|
|
};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var rows = ref.rows;
|
|
var scrolled = ref.scrolled;
|
|
var translates = ref.translates;
|
|
|
|
|
|
if (scrolled === false && !translates) {
|
|
return;
|
|
}
|
|
|
|
rows.forEach(function (row, i) { return row.forEach(function (el, j) { return css(el, 'transform', !scrolled && !translates ? '' : ("translateY(" + ((translates && -translates[i][j]) + (scrolled ? j % 2 ? scrolled : scrolled / 8 : 0)) + "px)")); }
|
|
); }
|
|
);
|
|
|
|
},
|
|
|
|
events: ['scroll', 'resize']
|
|
|
|
}
|
|
|
|
]
|
|
|
|
};
|
|
|
|
function getMarginTop(root, cls) {
|
|
|
|
var nodes = toNodes(root.children);
|
|
var ref = nodes.filter(function (el) { return hasClass(el, cls); });
|
|
var node = ref[0];
|
|
|
|
return toFloat(node
|
|
? css(node, 'marginTop')
|
|
: css(nodes[0], 'paddingLeft'));
|
|
}
|
|
|
|
function maxColumnHeight(rows) {
|
|
return Math.max.apply(Math, rows.reduce(function (sum, row) {
|
|
row.forEach(function (el, i) { return sum[i] = (sum[i] || 0) + el.offsetHeight; });
|
|
return sum;
|
|
}, []));
|
|
}
|
|
|
|
// IE 11 fix (min-height on a flex container won't apply to its flex items)
|
|
var FlexBug = isIE ? {
|
|
|
|
data: {
|
|
selMinHeight: false,
|
|
forceHeight: false
|
|
},
|
|
|
|
computed: {
|
|
|
|
elements: function(ref, $el) {
|
|
var selMinHeight = ref.selMinHeight;
|
|
|
|
return selMinHeight ? $$(selMinHeight, $el) : [$el];
|
|
}
|
|
|
|
},
|
|
|
|
update: [
|
|
|
|
{
|
|
|
|
read: function() {
|
|
css(this.elements, 'height', '');
|
|
},
|
|
|
|
order: -5,
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
{
|
|
|
|
write: function() {
|
|
var this$1 = this;
|
|
|
|
this.elements.forEach(function (el) {
|
|
var height = toFloat(css(el, 'minHeight'));
|
|
if (height && (this$1.forceHeight || Math.round(height + boxModelAdjust('height', el, 'content-box')) >= el.offsetHeight)) {
|
|
css(el, 'height', height);
|
|
}
|
|
});
|
|
},
|
|
|
|
order: 5,
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
]
|
|
|
|
} : {};
|
|
|
|
var HeightMatch = {
|
|
|
|
mixins: [FlexBug],
|
|
|
|
args: 'target',
|
|
|
|
props: {
|
|
target: String,
|
|
row: Boolean
|
|
},
|
|
|
|
data: {
|
|
target: '> *',
|
|
row: true,
|
|
forceHeight: true
|
|
},
|
|
|
|
computed: {
|
|
|
|
elements: function(ref, $el) {
|
|
var target = ref.target;
|
|
|
|
return $$(target, $el);
|
|
}
|
|
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
return {
|
|
rows: (this.row ? getRows(this.elements) : [this.elements]).map(match)
|
|
};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var rows = ref.rows;
|
|
|
|
rows.forEach(function (ref) {
|
|
var heights = ref.heights;
|
|
var elements = ref.elements;
|
|
|
|
return elements.forEach(function (el, i) { return css(el, 'minHeight', heights[i]); }
|
|
);
|
|
}
|
|
);
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function match(elements) {
|
|
var assign;
|
|
|
|
|
|
if (elements.length < 2) {
|
|
return {heights: [''], elements: elements};
|
|
}
|
|
|
|
var ref = getHeights(elements);
|
|
var heights = ref.heights;
|
|
var max = ref.max;
|
|
var hasMinHeight = elements.some(function (el) { return el.style.minHeight; });
|
|
var hasShrunk = elements.some(function (el, i) { return !el.style.minHeight && heights[i] < max; });
|
|
|
|
if (hasMinHeight && hasShrunk) {
|
|
css(elements, 'minHeight', '');
|
|
((assign = getHeights(elements), heights = assign.heights, max = assign.max));
|
|
}
|
|
|
|
heights = elements.map(function (el, i) { return heights[i] === max && toFloat(el.style.minHeight).toFixed(2) !== max.toFixed(2) ? '' : max; }
|
|
);
|
|
|
|
return {heights: heights, elements: elements};
|
|
}
|
|
|
|
function getHeights(elements) {
|
|
var heights = elements.map(function (el) { return offset(el).height - boxModelAdjust('height', el, 'content-box'); });
|
|
var max = Math.max.apply(null, heights);
|
|
|
|
return {heights: heights, max: max};
|
|
}
|
|
|
|
var HeightViewport = {
|
|
|
|
mixins: [FlexBug],
|
|
|
|
props: {
|
|
expand: Boolean,
|
|
offsetTop: Boolean,
|
|
offsetBottom: Boolean,
|
|
minHeight: Number
|
|
},
|
|
|
|
data: {
|
|
expand: false,
|
|
offsetTop: false,
|
|
offsetBottom: false,
|
|
minHeight: 0
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function(ref) {
|
|
var prev = ref.minHeight;
|
|
|
|
|
|
var minHeight = '';
|
|
var box = boxModelAdjust('height', this.$el, 'content-box');
|
|
|
|
if (this.expand) {
|
|
|
|
minHeight = height(window) - (offsetHeight(document.documentElement) - offsetHeight(this.$el)) - box || '';
|
|
|
|
} else {
|
|
|
|
// on mobile devices (iOS and Android) window.innerHeight !== 100vh
|
|
minHeight = 'calc(100vh';
|
|
|
|
if (this.offsetTop) {
|
|
|
|
var ref$1 = offset(this.$el);
|
|
var top = ref$1.top;
|
|
minHeight += top < height(window) / 2 ? (" - " + top + "px") : '';
|
|
|
|
}
|
|
|
|
if (this.offsetBottom === true) {
|
|
|
|
minHeight += " - " + (offsetHeight(this.$el.nextElementSibling)) + "px";
|
|
|
|
} else if (isNumeric(this.offsetBottom)) {
|
|
|
|
minHeight += " - " + (this.offsetBottom) + "vh";
|
|
|
|
} else if (this.offsetBottom && endsWith(this.offsetBottom, 'px')) {
|
|
|
|
minHeight += " - " + (toFloat(this.offsetBottom)) + "px";
|
|
|
|
} else if (isString(this.offsetBottom)) {
|
|
|
|
minHeight += " - " + (offsetHeight(query(this.offsetBottom, this.$el))) + "px";
|
|
|
|
}
|
|
|
|
minHeight += (box ? (" - " + box + "px") : '') + ")";
|
|
|
|
}
|
|
|
|
return {minHeight: minHeight, prev: prev};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var minHeight = ref.minHeight;
|
|
var prev = ref.prev;
|
|
|
|
|
|
css(this.$el, {minHeight: minHeight});
|
|
|
|
if (minHeight !== prev) {
|
|
this.$update(this.$el, 'resize');
|
|
}
|
|
|
|
if (this.minHeight && toFloat(css(this.$el, 'minHeight')) < this.minHeight) {
|
|
css(this.$el, 'minHeight', this.minHeight);
|
|
}
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function offsetHeight(el) {
|
|
return el && el.offsetHeight || 0;
|
|
}
|
|
|
|
var Svg = {
|
|
|
|
args: 'src',
|
|
|
|
props: {
|
|
id: Boolean,
|
|
icon: String,
|
|
src: String,
|
|
style: String,
|
|
width: Number,
|
|
height: Number,
|
|
ratio: Number,
|
|
'class': String,
|
|
strokeAnimation: Boolean,
|
|
attributes: 'list'
|
|
},
|
|
|
|
data: {
|
|
ratio: 1,
|
|
include: ['style', 'class'],
|
|
'class': '',
|
|
strokeAnimation: false
|
|
},
|
|
|
|
beforeConnect: function() {
|
|
var this$1 = this;
|
|
var assign;
|
|
|
|
|
|
this.class += ' uk-svg';
|
|
|
|
if (!this.icon && includes(this.src, '#')) {
|
|
|
|
var parts = this.src.split('#');
|
|
|
|
if (parts.length > 1) {
|
|
(assign = parts, this.src = assign[0], this.icon = assign[1]);
|
|
}
|
|
}
|
|
|
|
this.svg = this.getSvg().then(function (el) {
|
|
this$1.applyAttributes(el);
|
|
return this$1.svgEl = insertSVG(el, this$1.$el);
|
|
}, noop);
|
|
|
|
},
|
|
|
|
disconnected: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
if (isVoidElement(this.$el)) {
|
|
attr(this.$el, 'hidden', null);
|
|
}
|
|
|
|
if (this.svg) {
|
|
this.svg.then(function (svg) { return (!this$1._connected || svg !== this$1.svgEl) && remove(svg); }, noop);
|
|
}
|
|
|
|
this.svg = this.svgEl = null;
|
|
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
return !!(this.strokeAnimation && this.svgEl && isVisible(this.svgEl));
|
|
},
|
|
|
|
write: function() {
|
|
applyAnimation(this.svgEl);
|
|
},
|
|
|
|
type: ['resize']
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
getSvg: function() {
|
|
var this$1 = this;
|
|
|
|
return loadSVG(this.src).then(function (svg) { return parseSVG(svg, this$1.icon) || Promise.reject('SVG not found.'); }
|
|
);
|
|
},
|
|
|
|
applyAttributes: function(el) {
|
|
var this$1 = this;
|
|
|
|
|
|
for (var prop in this.$options.props) {
|
|
if (this[prop] && includes(this.include, prop)) {
|
|
attr(el, prop, this[prop]);
|
|
}
|
|
}
|
|
|
|
for (var attribute in this.attributes) {
|
|
var ref = this.attributes[attribute].split(':', 2);
|
|
var prop$1 = ref[0];
|
|
var value = ref[1];
|
|
attr(el, prop$1, value);
|
|
}
|
|
|
|
if (!this.id) {
|
|
removeAttr(el, 'id');
|
|
}
|
|
|
|
var props = ['width', 'height'];
|
|
var dimensions = [this.width, this.height];
|
|
|
|
if (!dimensions.some(function (val) { return val; })) {
|
|
dimensions = props.map(function (prop) { return attr(el, prop); });
|
|
}
|
|
|
|
var viewBox = attr(el, 'viewBox');
|
|
if (viewBox && !dimensions.some(function (val) { return val; })) {
|
|
dimensions = viewBox.split(' ').slice(2);
|
|
}
|
|
|
|
dimensions.forEach(function (val, i) {
|
|
val = (val | 0) * this$1.ratio;
|
|
val && attr(el, props[i], val);
|
|
|
|
if (val && !dimensions[i ^ 1]) {
|
|
removeAttr(el, props[i ^ 1]);
|
|
}
|
|
});
|
|
|
|
attr(el, 'data-svg', this.icon || this.src);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var svgs = {};
|
|
|
|
function loadSVG(src) {
|
|
|
|
if (svgs[src]) {
|
|
return svgs[src];
|
|
}
|
|
|
|
return svgs[src] = new Promise(function (resolve, reject) {
|
|
|
|
if (!src) {
|
|
reject();
|
|
return;
|
|
}
|
|
|
|
if (startsWith(src, 'data:')) {
|
|
resolve(decodeURIComponent(src.split(',')[1]));
|
|
} else {
|
|
|
|
ajax(src).then(
|
|
function (xhr) { return resolve(xhr.response); },
|
|
function () { return reject('SVG not found.'); }
|
|
);
|
|
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
function parseSVG(svg, icon) {
|
|
|
|
if (icon && includes(svg, '<symbol')) {
|
|
svg = parseSymbols(svg, icon) || svg;
|
|
}
|
|
|
|
svg = $(svg.substr(svg.indexOf('<svg')));
|
|
return svg && svg.hasChildNodes() && svg;
|
|
}
|
|
|
|
var symbolRe = /<symbol(.*?id=(['"])(.*?)\2[^]*?<\/)symbol>/g;
|
|
var symbols = {};
|
|
|
|
function parseSymbols(svg, icon) {
|
|
|
|
if (!symbols[svg]) {
|
|
|
|
symbols[svg] = {};
|
|
|
|
var match;
|
|
while ((match = symbolRe.exec(svg))) {
|
|
symbols[svg][match[3]] = "<svg xmlns=\"http://www.w3.org/2000/svg\"" + (match[1]) + "svg>";
|
|
}
|
|
|
|
symbolRe.lastIndex = 0;
|
|
|
|
}
|
|
|
|
return symbols[svg][icon];
|
|
}
|
|
|
|
function applyAnimation(el) {
|
|
|
|
var length = getMaxPathLength(el);
|
|
|
|
if (length) {
|
|
el.style.setProperty('--uk-animation-stroke', length);
|
|
}
|
|
|
|
}
|
|
|
|
function getMaxPathLength(el) {
|
|
return Math.ceil(Math.max.apply(Math, $$('[stroke]', el).map(function (stroke) { return stroke.getTotalLength && stroke.getTotalLength() || 0; }
|
|
).concat([0])));
|
|
}
|
|
|
|
function insertSVG(el, root) {
|
|
if (isVoidElement(root) || root.tagName === 'CANVAS') {
|
|
|
|
attr(root, 'hidden', true);
|
|
|
|
var next = root.nextElementSibling;
|
|
return equals(el, next)
|
|
? next
|
|
: after(root, el);
|
|
|
|
} else {
|
|
|
|
var last = root.lastElementChild;
|
|
return equals(el, last)
|
|
? last
|
|
: append(root, el);
|
|
|
|
}
|
|
}
|
|
|
|
function equals(el, other) {
|
|
return attr(el, 'data-svg') === attr(other, 'data-svg');
|
|
}
|
|
|
|
var closeIcon = "<svg width=\"14\" height=\"14\" viewBox=\"0 0 14 14\" xmlns=\"http://www.w3.org/2000/svg\"><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"1\" y1=\"1\" x2=\"13\" y2=\"13\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"13\" y1=\"1\" x2=\"1\" y2=\"13\"/></svg>";
|
|
|
|
var closeLarge = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" x1=\"1\" y1=\"1\" x2=\"19\" y2=\"19\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" x1=\"19\" y1=\"1\" x2=\"1\" y2=\"19\"/></svg>";
|
|
|
|
var marker = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><rect x=\"9\" y=\"4\" width=\"1\" height=\"11\"/><rect x=\"4\" y=\"9\" width=\"11\" height=\"1\"/></svg>";
|
|
|
|
var navbarToggleIcon = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><rect y=\"9\" width=\"20\" height=\"2\"/><rect y=\"3\" width=\"20\" height=\"2\"/><rect y=\"15\" width=\"20\" height=\"2\"/></svg>";
|
|
|
|
var overlayIcon = "<svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\" xmlns=\"http://www.w3.org/2000/svg\"><rect x=\"19\" y=\"0\" width=\"1\" height=\"40\"/><rect x=\"0\" y=\"19\" width=\"40\" height=\"1\"/></svg>";
|
|
|
|
var paginationNext = "<svg width=\"7\" height=\"12\" viewBox=\"0 0 7 12\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"1 1 6 6 1 11\"/></svg>";
|
|
|
|
var paginationPrevious = "<svg width=\"7\" height=\"12\" viewBox=\"0 0 7 12\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"6 1 1 6 6 11\"/></svg>";
|
|
|
|
var searchIcon = "<svg width=\"20\" height=\"20\" viewBox=\"0 0 20 20\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" cx=\"9\" cy=\"9\" r=\"7\"/><path fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" d=\"M14,14 L18,18 L14,14 Z\"/></svg>";
|
|
|
|
var searchLarge = "<svg width=\"40\" height=\"40\" viewBox=\"0 0 40 40\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.8\" cx=\"17.5\" cy=\"17.5\" r=\"16.5\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.8\" x1=\"38\" y1=\"39\" x2=\"29\" y2=\"30\"/></svg>";
|
|
|
|
var searchNavbar = "<svg width=\"24\" height=\"24\" viewBox=\"0 0 24 24\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" cx=\"10.5\" cy=\"10.5\" r=\"9.5\"/><line fill=\"none\" stroke=\"#000\" stroke-width=\"1.1\" x1=\"23\" y1=\"23\" x2=\"17\" y2=\"17\"/></svg>";
|
|
|
|
var slidenavNext = "<svg width=\"14px\" height=\"24px\" viewBox=\"0 0 14 24\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" points=\"1.225,23 12.775,12 1.225,1 \"/></svg>";
|
|
|
|
var slidenavNextLarge = "<svg width=\"25px\" height=\"40px\" viewBox=\"0 0 25 40\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"2\" points=\"4.002,38.547 22.527,20.024 4,1.5 \"/></svg>";
|
|
|
|
var slidenavPrevious = "<svg width=\"14px\" height=\"24px\" viewBox=\"0 0 14 24\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.4\" points=\"12.775,1 1.225,12 12.775,23 \"/></svg>";
|
|
|
|
var slidenavPreviousLarge = "<svg width=\"25px\" height=\"40px\" viewBox=\"0 0 25 40\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"2\" points=\"20.527,1.5 2,20.024 20.525,38.547 \"/></svg>";
|
|
|
|
var spinner = "<svg width=\"30\" height=\"30\" viewBox=\"0 0 30 30\" xmlns=\"http://www.w3.org/2000/svg\"><circle fill=\"none\" stroke=\"#000\" cx=\"15\" cy=\"15\" r=\"14\"/></svg>";
|
|
|
|
var totop = "<svg width=\"18\" height=\"10\" viewBox=\"0 0 18 10\" xmlns=\"http://www.w3.org/2000/svg\"><polyline fill=\"none\" stroke=\"#000\" stroke-width=\"1.2\" points=\"1 9 9 1 17 9 \"/></svg>";
|
|
|
|
var parsed = {};
|
|
var icons = {
|
|
spinner: spinner,
|
|
totop: totop,
|
|
marker: marker,
|
|
'close-icon': closeIcon,
|
|
'close-large': closeLarge,
|
|
'navbar-toggle-icon': navbarToggleIcon,
|
|
'overlay-icon': overlayIcon,
|
|
'pagination-next': paginationNext,
|
|
'pagination-previous': paginationPrevious,
|
|
'search-icon': searchIcon,
|
|
'search-large': searchLarge,
|
|
'search-navbar': searchNavbar,
|
|
'slidenav-next': slidenavNext,
|
|
'slidenav-next-large': slidenavNextLarge,
|
|
'slidenav-previous': slidenavPrevious,
|
|
'slidenav-previous-large': slidenavPreviousLarge
|
|
};
|
|
|
|
var Icon = {
|
|
|
|
install: install,
|
|
|
|
extends: Svg,
|
|
|
|
args: 'icon',
|
|
|
|
props: ['icon'],
|
|
|
|
data: {include: []},
|
|
|
|
isIcon: true,
|
|
|
|
beforeConnect: function() {
|
|
addClass(this.$el, 'uk-icon');
|
|
},
|
|
|
|
methods: {
|
|
|
|
getSvg: function() {
|
|
|
|
var icon = getIcon(applyRtl(this.icon));
|
|
|
|
if (!icon) {
|
|
return Promise.reject('Icon not found.');
|
|
}
|
|
|
|
return Promise.resolve(icon);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var IconComponent = {
|
|
|
|
args: false,
|
|
|
|
extends: Icon,
|
|
|
|
data: function (vm) { return ({
|
|
icon: hyphenate(vm.constructor.options.name)
|
|
}); },
|
|
|
|
beforeConnect: function() {
|
|
addClass(this.$el, this.$name);
|
|
}
|
|
|
|
};
|
|
|
|
var Slidenav = {
|
|
|
|
extends: IconComponent,
|
|
|
|
beforeConnect: function() {
|
|
addClass(this.$el, 'uk-slidenav');
|
|
},
|
|
|
|
computed: {
|
|
|
|
icon: function(ref, $el) {
|
|
var icon = ref.icon;
|
|
|
|
return hasClass($el, 'uk-slidenav-large')
|
|
? (icon + "-large")
|
|
: icon;
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Search = {
|
|
|
|
extends: IconComponent,
|
|
|
|
computed: {
|
|
|
|
icon: function(ref, $el) {
|
|
var icon = ref.icon;
|
|
|
|
return hasClass($el, 'uk-search-icon') && parents($el, '.uk-search-large').length
|
|
? 'search-large'
|
|
: parents($el, '.uk-search-navbar').length
|
|
? 'search-navbar'
|
|
: icon;
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Close = {
|
|
|
|
extends: IconComponent,
|
|
|
|
computed: {
|
|
|
|
icon: function() {
|
|
return ("close-" + (hasClass(this.$el, 'uk-close-large') ? 'large' : 'icon'));
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Spinner = {
|
|
|
|
extends: IconComponent,
|
|
|
|
connected: function() {
|
|
var this$1 = this;
|
|
|
|
this.svg.then(function (svg) { return this$1.ratio !== 1 && css($('circle', svg), 'strokeWidth', 1 / this$1.ratio); }, noop);
|
|
}
|
|
|
|
};
|
|
|
|
function install(UIkit) {
|
|
UIkit.icon.add = function (name, svg) {
|
|
var obj;
|
|
|
|
|
|
var added = isString(name) ? (( obj = {}, obj[name] = svg, obj )) : name;
|
|
each(added, function (svg, name) {
|
|
icons[name] = svg;
|
|
delete parsed[name];
|
|
});
|
|
|
|
if (UIkit._initialized) {
|
|
apply(document.body, function (el) { return each(UIkit.getComponents(el), function (cmp) {
|
|
cmp.$options.isIcon && cmp.icon in added && cmp.$reset();
|
|
}); }
|
|
);
|
|
}
|
|
};
|
|
}
|
|
|
|
function getIcon(icon) {
|
|
|
|
if (!icons[icon]) {
|
|
return null;
|
|
}
|
|
|
|
if (!parsed[icon]) {
|
|
parsed[icon] = $(icons[icon].trim());
|
|
}
|
|
|
|
return parsed[icon].cloneNode(true);
|
|
}
|
|
|
|
function applyRtl(icon) {
|
|
return isRtl ? swap(swap(icon, 'left', 'right'), 'previous', 'next') : icon;
|
|
}
|
|
|
|
var Img = {
|
|
|
|
args: 'dataSrc',
|
|
|
|
props: {
|
|
dataSrc: String,
|
|
dataSrcset: Boolean,
|
|
sizes: String,
|
|
width: Number,
|
|
height: Number,
|
|
offsetTop: String,
|
|
offsetLeft: String,
|
|
target: String
|
|
},
|
|
|
|
data: {
|
|
dataSrc: '',
|
|
dataSrcset: false,
|
|
sizes: false,
|
|
width: false,
|
|
height: false,
|
|
offsetTop: '50vh',
|
|
offsetLeft: 0,
|
|
target: false
|
|
},
|
|
|
|
computed: {
|
|
|
|
cacheKey: function(ref) {
|
|
var dataSrc = ref.dataSrc;
|
|
|
|
return ((this.$name) + "." + dataSrc);
|
|
},
|
|
|
|
width: function(ref) {
|
|
var width = ref.width;
|
|
var dataWidth = ref.dataWidth;
|
|
|
|
return width || dataWidth;
|
|
},
|
|
|
|
height: function(ref) {
|
|
var height = ref.height;
|
|
var dataHeight = ref.dataHeight;
|
|
|
|
return height || dataHeight;
|
|
},
|
|
|
|
sizes: function(ref) {
|
|
var sizes = ref.sizes;
|
|
var dataSizes = ref.dataSizes;
|
|
|
|
return sizes || dataSizes;
|
|
},
|
|
|
|
isImg: function(_, $el) {
|
|
return isImg($el);
|
|
},
|
|
|
|
target: {
|
|
|
|
get: function(ref) {
|
|
var target = ref.target;
|
|
|
|
return [this.$el].concat(queryAll(target, this.$el));
|
|
},
|
|
|
|
watch: function() {
|
|
this.observe();
|
|
}
|
|
|
|
},
|
|
|
|
offsetTop: function(ref) {
|
|
var offsetTop = ref.offsetTop;
|
|
|
|
return toPx(offsetTop, 'height');
|
|
},
|
|
|
|
offsetLeft: function(ref) {
|
|
var offsetLeft = ref.offsetLeft;
|
|
|
|
return toPx(offsetLeft, 'width');
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
|
|
if (storage[this.cacheKey]) {
|
|
setSrcAttrs(this.$el, storage[this.cacheKey] || this.dataSrc, this.dataSrcset, this.sizes);
|
|
} else if (this.isImg && this.width && this.height) {
|
|
setSrcAttrs(this.$el, getPlaceholderImage(this.width, this.height, this.sizes));
|
|
}
|
|
|
|
this.observer = new IntersectionObserver(this.load, {
|
|
rootMargin: ((this.offsetTop) + "px " + (this.offsetLeft) + "px")
|
|
});
|
|
|
|
requestAnimationFrame(this.observe);
|
|
|
|
},
|
|
|
|
disconnected: function() {
|
|
this.observer.disconnect();
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function(ref) {
|
|
var this$1 = this;
|
|
var image = ref.image;
|
|
|
|
|
|
if (!image && document.readyState === 'complete') {
|
|
this.load(this.observer.takeRecords());
|
|
}
|
|
|
|
if (this.isImg) {
|
|
return false;
|
|
}
|
|
|
|
image && image.then(function (img) { return img && img.currentSrc !== '' && setSrcAttrs(this$1.$el, currentSrc(img)); });
|
|
|
|
},
|
|
|
|
write: function(data) {
|
|
|
|
if (this.dataSrcset && window.devicePixelRatio !== 1) {
|
|
|
|
var bgSize = css(this.$el, 'backgroundSize');
|
|
if (bgSize.match(/^(auto\s?)+$/) || toFloat(bgSize) === data.bgSize) {
|
|
data.bgSize = getSourceSize(this.dataSrcset, this.sizes);
|
|
css(this.$el, 'backgroundSize', ((data.bgSize) + "px"));
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
load: function(entries) {
|
|
var this$1 = this;
|
|
|
|
|
|
if (!entries.some(function (entry) { return entry.isIntersecting; })) {
|
|
return;
|
|
}
|
|
|
|
this._data.image = getImage(this.dataSrc, this.dataSrcset, this.sizes).then(function (img) {
|
|
|
|
setSrcAttrs(this$1.$el, currentSrc(img), img.srcset, img.sizes);
|
|
storage[this$1.cacheKey] = currentSrc(img);
|
|
return img;
|
|
|
|
}, noop);
|
|
|
|
this.observer.disconnect();
|
|
},
|
|
|
|
observe: function() {
|
|
var this$1 = this;
|
|
|
|
if (!this._data.image && this._connected) {
|
|
this.target.forEach(function (el) { return this$1.observer.observe(el); });
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function setSrcAttrs(el, src, srcset, sizes) {
|
|
|
|
if (isImg(el)) {
|
|
sizes && (el.sizes = sizes);
|
|
srcset && (el.srcset = srcset);
|
|
src && (el.src = src);
|
|
} else if (src) {
|
|
|
|
var change = !includes(el.style.backgroundImage, src);
|
|
if (change) {
|
|
css(el, 'backgroundImage', ("url(" + (escape(src)) + ")"));
|
|
trigger(el, createEvent('load', false));
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
function getPlaceholderImage(width, height, sizes) {
|
|
var assign;
|
|
|
|
|
|
if (sizes) {
|
|
((assign = Dimensions.ratio({width: width, height: height}, 'width', toPx(sizesToPixel(sizes))), width = assign.width, height = assign.height));
|
|
}
|
|
|
|
return ("data:image/svg+xml;utf8,<svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + width + "\" height=\"" + height + "\"></svg>");
|
|
}
|
|
|
|
var sizesRe = /\s*(.*?)\s*(\w+|calc\(.*?\))\s*(?:,|$)/g;
|
|
function sizesToPixel(sizes) {
|
|
var matches;
|
|
|
|
sizesRe.lastIndex = 0;
|
|
|
|
while ((matches = sizesRe.exec(sizes))) {
|
|
if (!matches[1] || window.matchMedia(matches[1]).matches) {
|
|
matches = evaluateSize(matches[2]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return matches || '100vw';
|
|
}
|
|
|
|
var sizeRe = /\d+(?:\w+|%)/g;
|
|
var additionRe = /[+-]?(\d+)/g;
|
|
function evaluateSize(size) {
|
|
return startsWith(size, 'calc')
|
|
? size
|
|
.substring(5, size.length - 1)
|
|
.replace(sizeRe, function (size) { return toPx(size); })
|
|
.replace(/ /g, '')
|
|
.match(additionRe)
|
|
.reduce(function (a, b) { return a + +b; }, 0)
|
|
: size;
|
|
}
|
|
|
|
var srcSetRe = /\s+\d+w\s*(?:,|$)/g;
|
|
function getSourceSize(srcset, sizes) {
|
|
var srcSize = toPx(sizesToPixel(sizes));
|
|
var descriptors = (srcset.match(srcSetRe) || []).map(toFloat).sort(function (a, b) { return a - b; });
|
|
|
|
return descriptors.filter(function (size) { return size >= srcSize; })[0] || descriptors.pop() || '';
|
|
}
|
|
|
|
function isImg(el) {
|
|
return el.tagName === 'IMG';
|
|
}
|
|
|
|
function currentSrc(el) {
|
|
return el.currentSrc || el.src;
|
|
}
|
|
|
|
var key = '__test__';
|
|
var storage;
|
|
|
|
// workaround for Safari's private browsing mode and accessing sessionStorage in Blink
|
|
try {
|
|
storage = window.sessionStorage || {};
|
|
storage[key] = 1;
|
|
delete storage[key];
|
|
} catch (e) {
|
|
storage = {};
|
|
}
|
|
|
|
var Media = {
|
|
|
|
props: {
|
|
media: Boolean
|
|
},
|
|
|
|
data: {
|
|
media: false
|
|
},
|
|
|
|
computed: {
|
|
|
|
matchMedia: function() {
|
|
var media = toMedia(this.media);
|
|
return !media || window.matchMedia(media).matches;
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function toMedia(value) {
|
|
|
|
if (isString(value)) {
|
|
if (value[0] === '@') {
|
|
var name = "breakpoint-" + (value.substr(1));
|
|
value = toFloat(getCssVar(name));
|
|
} else if (isNaN(value)) {
|
|
return value;
|
|
}
|
|
}
|
|
|
|
return value && !isNaN(value) ? ("(min-width: " + value + "px)") : false;
|
|
}
|
|
|
|
var Leader = {
|
|
|
|
mixins: [Class, Media],
|
|
|
|
props: {
|
|
fill: String
|
|
},
|
|
|
|
data: {
|
|
fill: '',
|
|
clsWrapper: 'uk-leader-fill',
|
|
clsHide: 'uk-leader-hide',
|
|
attrFill: 'data-fill'
|
|
},
|
|
|
|
computed: {
|
|
|
|
fill: function(ref) {
|
|
var fill = ref.fill;
|
|
|
|
return fill || getCssVar('leader-fill-content');
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
var assign;
|
|
|
|
(assign = wrapInner(this.$el, ("<span class=\"" + (this.clsWrapper) + "\">")), this.wrapper = assign[0]);
|
|
},
|
|
|
|
disconnected: function() {
|
|
unwrap(this.wrapper.childNodes);
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function(ref) {
|
|
var changed = ref.changed;
|
|
var width = ref.width;
|
|
|
|
|
|
var prev = width;
|
|
|
|
width = Math.floor(this.$el.offsetWidth / 2);
|
|
|
|
return {
|
|
width: width,
|
|
fill: this.fill,
|
|
changed: changed || prev !== width,
|
|
hide: !this.matchMedia
|
|
};
|
|
},
|
|
|
|
write: function(data) {
|
|
|
|
toggleClass(this.wrapper, this.clsHide, data.hide);
|
|
|
|
if (data.changed) {
|
|
data.changed = false;
|
|
attr(this.wrapper, this.attrFill, new Array(data.width).join(data.fill));
|
|
}
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Container = {
|
|
|
|
props: {
|
|
container: Boolean
|
|
},
|
|
|
|
data: {
|
|
container: true
|
|
},
|
|
|
|
computed: {
|
|
|
|
container: function(ref) {
|
|
var container = ref.container;
|
|
|
|
return container === true && this.$container || container && $(container);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var active$1;
|
|
|
|
var Modal = {
|
|
|
|
mixins: [Class, Container, Togglable],
|
|
|
|
props: {
|
|
selPanel: String,
|
|
selClose: String,
|
|
escClose: Boolean,
|
|
bgClose: Boolean,
|
|
stack: Boolean
|
|
},
|
|
|
|
data: {
|
|
cls: 'uk-open',
|
|
escClose: true,
|
|
bgClose: true,
|
|
overlay: true,
|
|
stack: false
|
|
},
|
|
|
|
computed: {
|
|
|
|
panel: function(ref, $el) {
|
|
var selPanel = ref.selPanel;
|
|
|
|
return $(selPanel, $el);
|
|
},
|
|
|
|
transitionElement: function() {
|
|
return this.panel;
|
|
},
|
|
|
|
bgClose: function(ref) {
|
|
var bgClose = ref.bgClose;
|
|
|
|
return bgClose && this.panel;
|
|
}
|
|
|
|
},
|
|
|
|
beforeDisconnect: function() {
|
|
if (this.isToggled()) {
|
|
this.toggleNow(this.$el, false);
|
|
}
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return this.selClose;
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
this.hide();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'toggle',
|
|
|
|
self: true,
|
|
|
|
handler: function(e) {
|
|
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
|
|
e.preventDefault();
|
|
this.toggle();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'beforeshow',
|
|
|
|
self: true,
|
|
|
|
handler: function(e) {
|
|
|
|
var prev = active$1 && active$1 !== this && active$1;
|
|
|
|
active$1 = this;
|
|
|
|
if (prev) {
|
|
if (this.stack) {
|
|
this.prev = prev;
|
|
} else {
|
|
|
|
active$1 = prev;
|
|
|
|
if (prev.isToggled()) {
|
|
prev.hide().then(this.show);
|
|
} else {
|
|
once(prev.$el, 'beforeshow hidden', this.show, false, function (ref) {
|
|
var target = ref.target;
|
|
var type = ref.type;
|
|
|
|
return type === 'hidden' && target === prev.$el;
|
|
});
|
|
}
|
|
e.preventDefault();
|
|
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
registerEvents();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'show',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
|
|
if (!hasClass(document.documentElement, this.clsPage)) {
|
|
this.scrollbarWidth = width(window) - width(document);
|
|
css(document.body, 'overflowY', this.scrollbarWidth && this.overlay ? 'scroll' : '');
|
|
}
|
|
|
|
addClass(document.documentElement, this.clsPage);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'hide',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
if (!active$1 || active$1 === this && !this.prev) {
|
|
deregisterEvents();
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'hidden',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
|
|
var found;
|
|
var ref = this;
|
|
var prev = ref.prev;
|
|
|
|
active$1 = active$1 && active$1 !== this && active$1 || prev;
|
|
|
|
if (!active$1) {
|
|
|
|
css(document.body, 'overflowY', '');
|
|
|
|
} else {
|
|
while (prev) {
|
|
|
|
if (prev.clsPage === this.clsPage) {
|
|
found = true;
|
|
break;
|
|
}
|
|
|
|
prev = prev.prev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!found) {
|
|
removeClass(document.documentElement, this.clsPage);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
toggle: function() {
|
|
return this.isToggled() ? this.hide() : this.show();
|
|
},
|
|
|
|
show: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
if (this.isToggled()) {
|
|
return Promise.resolve();
|
|
}
|
|
|
|
if (this.container && this.$el.parentNode !== this.container) {
|
|
append(this.container, this.$el);
|
|
return new Promise(function (resolve) { return requestAnimationFrame(function () { return this$1.show().then(resolve); }
|
|
); }
|
|
);
|
|
}
|
|
|
|
return this.toggleElement(this.$el, true, animate$1(this));
|
|
},
|
|
|
|
hide: function() {
|
|
return this.isToggled()
|
|
? this.toggleElement(this.$el, false, animate$1(this))
|
|
: Promise.resolve();
|
|
},
|
|
|
|
getActive: function() {
|
|
return active$1;
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var events;
|
|
|
|
function registerEvents() {
|
|
|
|
if (events) {
|
|
return;
|
|
}
|
|
|
|
events = [
|
|
on(document, pointerUp, function (ref) {
|
|
var target = ref.target;
|
|
var defaultPrevented = ref.defaultPrevented;
|
|
|
|
if (active$1 && active$1.bgClose && !defaultPrevented && (!active$1.overlay || within(target, active$1.$el)) && !within(target, active$1.panel)) {
|
|
active$1.hide();
|
|
}
|
|
}),
|
|
on(document, 'keydown', function (e) {
|
|
if (e.keyCode === 27 && active$1 && active$1.escClose) {
|
|
e.preventDefault();
|
|
active$1.hide();
|
|
}
|
|
})
|
|
];
|
|
}
|
|
|
|
function deregisterEvents() {
|
|
events && events.forEach(function (unbind) { return unbind(); });
|
|
events = null;
|
|
}
|
|
|
|
function animate$1(ref) {
|
|
var transitionElement = ref.transitionElement;
|
|
var _toggle = ref._toggle;
|
|
|
|
return function (el, show) { return new Promise(function (resolve, reject) { return once(el, 'show hide', function () {
|
|
el._reject && el._reject();
|
|
el._reject = reject;
|
|
|
|
_toggle(el, show);
|
|
|
|
if (toMs(css(transitionElement, 'transitionDuration'))) {
|
|
once(transitionElement, 'transitionend', resolve, false, function (e) { return e.target === transitionElement; });
|
|
} else {
|
|
resolve();
|
|
}
|
|
}); }
|
|
); };
|
|
}
|
|
|
|
var Modal$1 = {
|
|
|
|
install: install$1,
|
|
|
|
mixins: [Modal],
|
|
|
|
data: {
|
|
clsPage: 'uk-modal-page',
|
|
selPanel: '.uk-modal-dialog',
|
|
selClose: '.uk-modal-close, .uk-modal-close-default, .uk-modal-close-outside, .uk-modal-close-full'
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
name: 'show',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
|
|
if (hasClass(this.panel, 'uk-margin-auto-vertical')) {
|
|
addClass(this.$el, 'uk-flex');
|
|
} else {
|
|
css(this.$el, 'display', 'block');
|
|
}
|
|
|
|
height(this.$el); // force reflow
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'hidden',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
|
|
css(this.$el, 'display', '');
|
|
removeClass(this.$el, 'uk-flex');
|
|
|
|
}
|
|
}
|
|
|
|
]
|
|
|
|
};
|
|
|
|
function install$1(UIkit) {
|
|
|
|
UIkit.modal.dialog = function (content, options) {
|
|
|
|
var dialog = UIkit.modal((" <div class=\"uk-modal\"> <div class=\"uk-modal-dialog\">" + content + "</div> </div> "), options);
|
|
|
|
dialog.show();
|
|
|
|
on(dialog.$el, 'hidden', function (ref) {
|
|
var target = ref.target;
|
|
var currentTarget = ref.currentTarget;
|
|
|
|
if (target === currentTarget) {
|
|
Promise.resolve(function () { return dialog.$destroy(true); });
|
|
}
|
|
});
|
|
|
|
return dialog;
|
|
};
|
|
|
|
UIkit.modal.alert = function (message, options) {
|
|
|
|
options = assign({bgClose: false, escClose: false, labels: UIkit.modal.labels}, options);
|
|
|
|
return new Promise(
|
|
function (resolve) { return on(UIkit.modal.dialog((" <div class=\"uk-modal-body\">" + (isString(message) ? message : html(message)) + "</div> <div class=\"uk-modal-footer uk-text-right\"> <button class=\"uk-button uk-button-primary uk-modal-close\" autofocus>" + (options.labels.ok) + "</button> </div> "), options).$el, 'hide', resolve); }
|
|
);
|
|
};
|
|
|
|
UIkit.modal.confirm = function (message, options) {
|
|
|
|
options = assign({bgClose: false, escClose: true, labels: UIkit.modal.labels}, options);
|
|
|
|
return new Promise(function (resolve, reject) {
|
|
|
|
var confirm = UIkit.modal.dialog((" <form> <div class=\"uk-modal-body\">" + (isString(message) ? message : html(message)) + "</div> <div class=\"uk-modal-footer uk-text-right\"> <button class=\"uk-button uk-button-default uk-modal-close\" type=\"button\">" + (options.labels.cancel) + "</button> <button class=\"uk-button uk-button-primary\" autofocus>" + (options.labels.ok) + "</button> </div> </form> "), options);
|
|
|
|
var resolved = false;
|
|
|
|
on(confirm.$el, 'submit', 'form', function (e) {
|
|
e.preventDefault();
|
|
resolve();
|
|
resolved = true;
|
|
confirm.hide();
|
|
});
|
|
on(confirm.$el, 'hide', function () {
|
|
if (!resolved) {
|
|
reject();
|
|
}
|
|
});
|
|
|
|
});
|
|
};
|
|
|
|
UIkit.modal.prompt = function (message, value, options) {
|
|
|
|
options = assign({bgClose: false, escClose: true, labels: UIkit.modal.labels}, options);
|
|
|
|
return new Promise(function (resolve) {
|
|
|
|
var prompt = UIkit.modal.dialog((" <form class=\"uk-form-stacked\"> <div class=\"uk-modal-body\"> <label>" + (isString(message) ? message : html(message)) + "</label> <input class=\"uk-input\" autofocus> </div> <div class=\"uk-modal-footer uk-text-right\"> <button class=\"uk-button uk-button-default uk-modal-close\" type=\"button\">" + (options.labels.cancel) + "</button> <button class=\"uk-button uk-button-primary\">" + (options.labels.ok) + "</button> </div> </form> "), options),
|
|
input = $('input', prompt.$el);
|
|
|
|
input.value = value;
|
|
|
|
var resolved = false;
|
|
|
|
on(prompt.$el, 'submit', 'form', function (e) {
|
|
e.preventDefault();
|
|
resolve(input.value);
|
|
resolved = true;
|
|
prompt.hide();
|
|
});
|
|
on(prompt.$el, 'hide', function () {
|
|
if (!resolved) {
|
|
resolve(null);
|
|
}
|
|
});
|
|
|
|
});
|
|
};
|
|
|
|
UIkit.modal.labels = {
|
|
ok: 'Ok',
|
|
cancel: 'Cancel'
|
|
};
|
|
|
|
}
|
|
|
|
var Nav = {
|
|
|
|
extends: Accordion,
|
|
|
|
data: {
|
|
targets: '> .uk-parent',
|
|
toggle: '> a',
|
|
content: '> ul'
|
|
}
|
|
|
|
};
|
|
|
|
var Navbar = {
|
|
|
|
mixins: [Class, FlexBug],
|
|
|
|
props: {
|
|
dropdown: String,
|
|
mode: 'list',
|
|
align: String,
|
|
offset: Number,
|
|
boundary: Boolean,
|
|
boundaryAlign: Boolean,
|
|
clsDrop: String,
|
|
delayShow: Number,
|
|
delayHide: Number,
|
|
dropbar: Boolean,
|
|
dropbarMode: String,
|
|
dropbarAnchor: Boolean,
|
|
duration: Number
|
|
},
|
|
|
|
data: {
|
|
dropdown: '.uk-navbar-nav > li',
|
|
align: !isRtl ? 'left' : 'right',
|
|
clsDrop: 'uk-navbar-dropdown',
|
|
mode: undefined,
|
|
offset: undefined,
|
|
delayShow: undefined,
|
|
delayHide: undefined,
|
|
boundaryAlign: undefined,
|
|
flip: 'x',
|
|
boundary: true,
|
|
dropbar: false,
|
|
dropbarMode: 'slide',
|
|
dropbarAnchor: false,
|
|
duration: 200,
|
|
forceHeight: true,
|
|
selMinHeight: '.uk-navbar-nav > li > a, .uk-navbar-item, .uk-navbar-toggle'
|
|
},
|
|
|
|
computed: {
|
|
|
|
boundary: function(ref, $el) {
|
|
var boundary = ref.boundary;
|
|
var boundaryAlign = ref.boundaryAlign;
|
|
|
|
return (boundary === true || boundaryAlign) ? $el : boundary;
|
|
},
|
|
|
|
dropbarAnchor: function(ref, $el) {
|
|
var dropbarAnchor = ref.dropbarAnchor;
|
|
|
|
return query(dropbarAnchor, $el);
|
|
},
|
|
|
|
pos: function(ref) {
|
|
var align = ref.align;
|
|
|
|
return ("bottom-" + align);
|
|
},
|
|
|
|
dropdowns: function(ref, $el) {
|
|
var dropdown = ref.dropdown;
|
|
var clsDrop = ref.clsDrop;
|
|
|
|
return $$((dropdown + " ." + clsDrop), $el);
|
|
}
|
|
|
|
},
|
|
|
|
beforeConnect: function() {
|
|
|
|
var ref = this.$props;
|
|
var dropbar = ref.dropbar;
|
|
|
|
this.dropbar = dropbar && (query(dropbar, this.$el) || $('+ .uk-navbar-dropbar', this.$el) || $('<div></div>'));
|
|
|
|
if (this.dropbar) {
|
|
|
|
addClass(this.dropbar, 'uk-navbar-dropbar');
|
|
|
|
if (this.dropbarMode === 'slide') {
|
|
addClass(this.dropbar, 'uk-navbar-dropbar-slide');
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
disconnected: function() {
|
|
this.dropbar && remove(this.dropbar);
|
|
},
|
|
|
|
update: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.$create(
|
|
'drop',
|
|
this.dropdowns.filter(function (el) { return !this$1.getDropdown(el); }),
|
|
assign({}, this.$props, {boundary: this.boundary, pos: this.pos, offset: this.dropbar || this.offset})
|
|
);
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
name: 'mouseover',
|
|
|
|
delegate: function() {
|
|
return this.dropdown;
|
|
},
|
|
|
|
handler: function(ref) {
|
|
var current = ref.current;
|
|
|
|
var active = this.getActive();
|
|
if (active && active.toggle && !within(active.toggle.$el, current) && !active.tracker.movesTo(active.$el)) {
|
|
active.hide(false);
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'mouseleave',
|
|
|
|
el: function() {
|
|
return this.dropbar;
|
|
},
|
|
|
|
handler: function() {
|
|
var active = this.getActive();
|
|
|
|
if (active && !this.dropdowns.some(function (el) { return matches(el, ':hover'); })) {
|
|
active.hide();
|
|
}
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'beforeshow',
|
|
|
|
capture: true,
|
|
|
|
filter: function() {
|
|
return this.dropbar;
|
|
},
|
|
|
|
handler: function() {
|
|
|
|
if (!this.dropbar.parentNode) {
|
|
after(this.dropbarAnchor || this.$el, this.dropbar);
|
|
}
|
|
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'show',
|
|
|
|
capture: true,
|
|
|
|
filter: function() {
|
|
return this.dropbar;
|
|
},
|
|
|
|
handler: function(_, drop) {
|
|
|
|
var $el = drop.$el;
|
|
var dir = drop.dir;
|
|
|
|
this.clsDrop && addClass($el, ((this.clsDrop) + "-dropbar"));
|
|
|
|
if (dir === 'bottom') {
|
|
this.transitionTo($el.offsetHeight + toFloat(css($el, 'marginTop')) + toFloat(css($el, 'marginBottom')), $el);
|
|
}
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'beforehide',
|
|
|
|
filter: function() {
|
|
return this.dropbar;
|
|
},
|
|
|
|
handler: function(e, ref) {
|
|
var $el = ref.$el;
|
|
|
|
|
|
var active = this.getActive();
|
|
|
|
if (matches(this.dropbar, ':hover') && active && active.$el === $el) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'hide',
|
|
|
|
filter: function() {
|
|
return this.dropbar;
|
|
},
|
|
|
|
handler: function(_, ref) {
|
|
var $el = ref.$el;
|
|
|
|
|
|
var active = this.getActive();
|
|
|
|
if (!active || active && active.$el === $el) {
|
|
this.transitionTo(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
getActive: function() {
|
|
var ref = this.dropdowns.map(this.getDropdown).filter(function (drop) { return drop && drop.isActive(); });
|
|
var active = ref[0];
|
|
return active && includes(active.mode, 'hover') && within(active.toggle.$el, this.$el) && active;
|
|
},
|
|
|
|
transitionTo: function(newHeight, el) {
|
|
var this$1 = this;
|
|
|
|
|
|
var ref = this;
|
|
var dropbar = ref.dropbar;
|
|
var oldHeight = isVisible(dropbar) ? height(dropbar) : 0;
|
|
|
|
el = oldHeight < newHeight && el;
|
|
|
|
css(el, 'clip', ("rect(0," + (el.offsetWidth) + "px," + oldHeight + "px,0)"));
|
|
|
|
height(dropbar, oldHeight);
|
|
|
|
Transition.cancel([el, dropbar]);
|
|
return Promise.all([
|
|
Transition.start(dropbar, {height: newHeight}, this.duration),
|
|
Transition.start(el, {clip: ("rect(0," + (el.offsetWidth) + "px," + newHeight + "px,0)")}, this.duration)
|
|
])
|
|
.catch(noop)
|
|
.then(function () {
|
|
css(el, {clip: ''});
|
|
this$1.$update(dropbar);
|
|
});
|
|
},
|
|
|
|
getDropdown: function(el) {
|
|
return this.$getComponent(el, 'drop') || this.$getComponent(el, 'dropdown');
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Offcanvas = {
|
|
|
|
mixins: [Modal],
|
|
|
|
args: 'mode',
|
|
|
|
props: {
|
|
mode: String,
|
|
flip: Boolean,
|
|
overlay: Boolean
|
|
},
|
|
|
|
data: {
|
|
mode: 'slide',
|
|
flip: false,
|
|
overlay: false,
|
|
clsPage: 'uk-offcanvas-page',
|
|
clsContainer: 'uk-offcanvas-container',
|
|
selPanel: '.uk-offcanvas-bar',
|
|
clsFlip: 'uk-offcanvas-flip',
|
|
clsContainerAnimation: 'uk-offcanvas-container-animation',
|
|
clsSidebarAnimation: 'uk-offcanvas-bar-animation',
|
|
clsMode: 'uk-offcanvas',
|
|
clsOverlay: 'uk-offcanvas-overlay',
|
|
selClose: '.uk-offcanvas-close'
|
|
},
|
|
|
|
computed: {
|
|
|
|
clsFlip: function(ref) {
|
|
var flip = ref.flip;
|
|
var clsFlip = ref.clsFlip;
|
|
|
|
return flip ? clsFlip : '';
|
|
},
|
|
|
|
clsOverlay: function(ref) {
|
|
var overlay = ref.overlay;
|
|
var clsOverlay = ref.clsOverlay;
|
|
|
|
return overlay ? clsOverlay : '';
|
|
},
|
|
|
|
clsMode: function(ref) {
|
|
var mode = ref.mode;
|
|
var clsMode = ref.clsMode;
|
|
|
|
return (clsMode + "-" + mode);
|
|
},
|
|
|
|
clsSidebarAnimation: function(ref) {
|
|
var mode = ref.mode;
|
|
var clsSidebarAnimation = ref.clsSidebarAnimation;
|
|
|
|
return mode === 'none' || mode === 'reveal' ? '' : clsSidebarAnimation;
|
|
},
|
|
|
|
clsContainerAnimation: function(ref) {
|
|
var mode = ref.mode;
|
|
var clsContainerAnimation = ref.clsContainerAnimation;
|
|
|
|
return mode !== 'push' && mode !== 'reveal' ? '' : clsContainerAnimation;
|
|
},
|
|
|
|
transitionElement: function(ref) {
|
|
var mode = ref.mode;
|
|
|
|
return mode === 'reveal' ? this.panel.parentNode : this.panel;
|
|
}
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return 'a[href^="#"]';
|
|
},
|
|
|
|
handler: function(ref) {
|
|
var current = ref.current;
|
|
|
|
if (current.hash && $(current.hash, document.body)) {
|
|
this.hide();
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'touchstart',
|
|
|
|
passive: true,
|
|
|
|
el: function() {
|
|
return this.panel;
|
|
},
|
|
|
|
handler: function(ref) {
|
|
var targetTouches = ref.targetTouches;
|
|
|
|
|
|
if (targetTouches.length === 1) {
|
|
this.clientY = targetTouches[0].clientY;
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'touchmove',
|
|
|
|
self: true,
|
|
passive: false,
|
|
|
|
filter: function() {
|
|
return this.overlay;
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.cancelable && e.preventDefault();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'touchmove',
|
|
|
|
passive: false,
|
|
|
|
el: function() {
|
|
return this.panel;
|
|
},
|
|
|
|
handler: function(e) {
|
|
|
|
if (e.targetTouches.length !== 1) {
|
|
return;
|
|
}
|
|
|
|
var clientY = event.targetTouches[0].clientY - this.clientY;
|
|
var ref = this.panel;
|
|
var scrollTop = ref.scrollTop;
|
|
var scrollHeight = ref.scrollHeight;
|
|
var clientHeight = ref.clientHeight;
|
|
|
|
if (clientHeight >= scrollHeight
|
|
|| scrollTop === 0 && clientY > 0
|
|
|| scrollHeight - scrollTop <= clientHeight && clientY < 0
|
|
) {
|
|
e.cancelable && e.preventDefault();
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'show',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
|
|
if (this.mode === 'reveal' && !hasClass(this.panel.parentNode, this.clsMode)) {
|
|
wrapAll(this.panel, '<div>');
|
|
addClass(this.panel.parentNode, this.clsMode);
|
|
}
|
|
|
|
css(document.documentElement, 'overflowY', this.overlay ? 'hidden' : '');
|
|
addClass(document.body, this.clsContainer, this.clsFlip);
|
|
css(this.$el, 'display', 'block');
|
|
addClass(this.$el, this.clsOverlay);
|
|
addClass(this.panel, this.clsSidebarAnimation, this.mode !== 'reveal' ? this.clsMode : '');
|
|
|
|
height(document.body); // force reflow
|
|
addClass(document.body, this.clsContainerAnimation);
|
|
|
|
this.clsContainerAnimation && suppressUserScale();
|
|
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'hide',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
removeClass(document.body, this.clsContainerAnimation);
|
|
|
|
var active = this.getActive();
|
|
if (this.mode === 'none' || active && active !== this && active !== this.prev) {
|
|
trigger(this.panel, 'transitionend');
|
|
}
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'hidden',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
|
|
this.clsContainerAnimation && resumeUserScale();
|
|
|
|
if (this.mode === 'reveal') {
|
|
unwrap(this.panel);
|
|
}
|
|
|
|
removeClass(this.panel, this.clsSidebarAnimation, this.clsMode);
|
|
removeClass(this.$el, this.clsOverlay);
|
|
css(this.$el, 'display', '');
|
|
removeClass(document.body, this.clsContainer, this.clsFlip);
|
|
|
|
css(document.documentElement, 'overflowY', '');
|
|
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'swipeLeft swipeRight',
|
|
|
|
handler: function(e) {
|
|
|
|
if (this.isToggled() && endsWith(e.type, 'Left') ^ this.flip) {
|
|
this.hide();
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
]
|
|
|
|
};
|
|
|
|
// Chrome in responsive mode zooms page upon opening offcanvas
|
|
function suppressUserScale() {
|
|
getViewport().content += ',user-scalable=0';
|
|
}
|
|
|
|
function resumeUserScale() {
|
|
var viewport = getViewport();
|
|
viewport.content = viewport.content.replace(/,user-scalable=0$/, '');
|
|
}
|
|
|
|
function getViewport() {
|
|
return $('meta[name="viewport"]', document.head) || append(document.head, '<meta name="viewport">');
|
|
}
|
|
|
|
var OverflowAuto = {
|
|
|
|
mixins: [Class],
|
|
|
|
props: {
|
|
selContainer: String,
|
|
selContent: String
|
|
},
|
|
|
|
data: {
|
|
selContainer: '.uk-modal',
|
|
selContent: '.uk-modal-dialog'
|
|
},
|
|
|
|
computed: {
|
|
|
|
container: function(ref, $el) {
|
|
var selContainer = ref.selContainer;
|
|
|
|
return closest($el, selContainer);
|
|
},
|
|
|
|
content: function(ref, $el) {
|
|
var selContent = ref.selContent;
|
|
|
|
return closest($el, selContent);
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
css(this.$el, 'minHeight', 150);
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
|
|
if (!this.content || !this.container) {
|
|
return false;
|
|
}
|
|
|
|
return {
|
|
current: toFloat(css(this.$el, 'maxHeight')),
|
|
max: Math.max(150, height(this.container) - (offset(this.content).height - height(this.$el)))
|
|
};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var current = ref.current;
|
|
var max = ref.max;
|
|
|
|
css(this.$el, 'maxHeight', max);
|
|
if (Math.round(current) !== Math.round(max)) {
|
|
trigger(this.$el, 'resize');
|
|
}
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Responsive = {
|
|
|
|
props: ['width', 'height'],
|
|
|
|
connected: function() {
|
|
addClass(this.$el, 'uk-responsive-width');
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
return isVisible(this.$el) && this.width && this.height
|
|
? {width: width(this.$el.parentNode), height: this.height}
|
|
: false;
|
|
},
|
|
|
|
write: function(dim) {
|
|
height(this.$el, Dimensions.contain({
|
|
height: this.height,
|
|
width: this.width
|
|
}, dim).height);
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Scroll = {
|
|
|
|
props: {
|
|
duration: Number,
|
|
offset: Number
|
|
},
|
|
|
|
data: {
|
|
duration: 1000,
|
|
offset: 0
|
|
},
|
|
|
|
methods: {
|
|
|
|
scrollTo: function(el) {
|
|
var this$1 = this;
|
|
|
|
|
|
el = el && $(el) || document.body;
|
|
|
|
var docHeight = height(document);
|
|
var winHeight = height(window);
|
|
|
|
var target = offset(el).top - this.offset;
|
|
if (target + winHeight > docHeight) {
|
|
target = docHeight - winHeight;
|
|
}
|
|
|
|
if (!trigger(this.$el, 'beforescroll', [this, el])) {
|
|
return;
|
|
}
|
|
|
|
var start = Date.now();
|
|
var startY = window.pageYOffset;
|
|
var step = function () {
|
|
|
|
var currentY = startY + (target - startY) * ease(clamp((Date.now() - start) / this$1.duration));
|
|
|
|
scrollTop(window, currentY);
|
|
|
|
// scroll more if we have not reached our destination
|
|
if (currentY !== target) {
|
|
requestAnimationFrame(step);
|
|
} else {
|
|
trigger(this$1.$el, 'scrolled', [this$1, el]);
|
|
}
|
|
|
|
};
|
|
|
|
step();
|
|
|
|
}
|
|
|
|
},
|
|
|
|
events: {
|
|
|
|
click: function(e) {
|
|
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
|
|
e.preventDefault();
|
|
this.scrollTo(escape(decodeURIComponent(this.$el.hash)).substr(1));
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function ease(k) {
|
|
return 0.5 * (1 - Math.cos(Math.PI * k));
|
|
}
|
|
|
|
var Scrollspy = {
|
|
|
|
args: 'cls',
|
|
|
|
props: {
|
|
cls: String,
|
|
target: String,
|
|
hidden: Boolean,
|
|
offsetTop: Number,
|
|
offsetLeft: Number,
|
|
repeat: Boolean,
|
|
delay: Number
|
|
},
|
|
|
|
data: function () { return ({
|
|
cls: false,
|
|
target: false,
|
|
hidden: true,
|
|
offsetTop: 0,
|
|
offsetLeft: 0,
|
|
repeat: false,
|
|
delay: 0,
|
|
inViewClass: 'uk-scrollspy-inview'
|
|
}); },
|
|
|
|
computed: {
|
|
|
|
elements: function(ref, $el) {
|
|
var target = ref.target;
|
|
|
|
return target ? $$(target, $el) : [$el];
|
|
}
|
|
|
|
},
|
|
|
|
update: [
|
|
|
|
{
|
|
|
|
write: function() {
|
|
if (this.hidden) {
|
|
css(filter(this.elements, (":not(." + (this.inViewClass) + ")")), 'visibility', 'hidden');
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
read: function(ref) {
|
|
var this$1 = this;
|
|
var update = ref.update;
|
|
|
|
|
|
if (!update) {
|
|
return;
|
|
}
|
|
|
|
this.elements.forEach(function (el) {
|
|
|
|
var state = el._ukScrollspyState;
|
|
|
|
if (!state) {
|
|
state = {cls: data(el, 'uk-scrollspy-class') || this$1.cls};
|
|
}
|
|
|
|
state.show = isInView(el, this$1.offsetTop, this$1.offsetLeft);
|
|
el._ukScrollspyState = state;
|
|
|
|
});
|
|
|
|
},
|
|
|
|
write: function(data) {
|
|
var this$1 = this;
|
|
|
|
|
|
// Let child components be applied at least once first
|
|
if (!data.update) {
|
|
this.$emit();
|
|
return data.update = true;
|
|
}
|
|
|
|
this.elements.forEach(function (el) {
|
|
|
|
var state = el._ukScrollspyState;
|
|
var cls = state.cls;
|
|
|
|
if (state.show && !state.inview && !state.queued) {
|
|
|
|
var show = function () {
|
|
|
|
css(el, 'visibility', '');
|
|
addClass(el, this$1.inViewClass);
|
|
toggleClass(el, cls);
|
|
|
|
trigger(el, 'inview');
|
|
|
|
this$1.$update(el);
|
|
|
|
state.inview = true;
|
|
state.abort && state.abort();
|
|
};
|
|
|
|
if (this$1.delay) {
|
|
|
|
state.queued = true;
|
|
data.promise = (data.promise || Promise.resolve()).then(function () {
|
|
return !state.inview && new Promise(function (resolve) {
|
|
|
|
var timer = setTimeout(function () {
|
|
|
|
show();
|
|
resolve();
|
|
|
|
}, data.promise || this$1.elements.length === 1 ? this$1.delay : 0);
|
|
|
|
state.abort = function () {
|
|
clearTimeout(timer);
|
|
resolve();
|
|
state.queued = false;
|
|
};
|
|
|
|
});
|
|
|
|
});
|
|
|
|
} else {
|
|
show();
|
|
}
|
|
|
|
} else if (!state.show && (state.inview || state.queued) && this$1.repeat) {
|
|
|
|
state.abort && state.abort();
|
|
|
|
if (!state.inview) {
|
|
return;
|
|
}
|
|
|
|
css(el, 'visibility', this$1.hidden ? 'hidden' : '');
|
|
removeClass(el, this$1.inViewClass);
|
|
toggleClass(el, cls);
|
|
|
|
trigger(el, 'outview');
|
|
|
|
this$1.$update(el);
|
|
|
|
state.inview = false;
|
|
|
|
}
|
|
|
|
|
|
});
|
|
|
|
},
|
|
|
|
events: ['scroll', 'resize']
|
|
|
|
}
|
|
|
|
]
|
|
|
|
};
|
|
|
|
var ScrollspyNav = {
|
|
|
|
props: {
|
|
cls: String,
|
|
closest: String,
|
|
scroll: Boolean,
|
|
overflow: Boolean,
|
|
offset: Number
|
|
},
|
|
|
|
data: {
|
|
cls: 'uk-active',
|
|
closest: false,
|
|
scroll: false,
|
|
overflow: true,
|
|
offset: 0
|
|
},
|
|
|
|
computed: {
|
|
|
|
links: function(_, $el) {
|
|
return $$('a[href^="#"]', $el).filter(function (el) { return el.hash; });
|
|
},
|
|
|
|
elements: function(ref) {
|
|
var selector = ref.closest;
|
|
|
|
return closest(this.links, selector || '*');
|
|
},
|
|
|
|
targets: function() {
|
|
return $$(this.links.map(function (el) { return escape(el.hash).substr(1); }).join(','));
|
|
}
|
|
|
|
},
|
|
|
|
update: [
|
|
|
|
{
|
|
|
|
read: function() {
|
|
if (this.scroll) {
|
|
this.$create('scroll', this.links, {offset: this.offset || 0});
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
read: function(data) {
|
|
var this$1 = this;
|
|
|
|
|
|
var scroll = window.pageYOffset + this.offset + 1;
|
|
var max = height(document) - height(window) + this.offset;
|
|
|
|
data.active = false;
|
|
|
|
this.targets.every(function (el, i) {
|
|
|
|
var ref = offset(el);
|
|
var top = ref.top;
|
|
var last = i + 1 === this$1.targets.length;
|
|
|
|
if (!this$1.overflow && (i === 0 && top > scroll || last && top + el.offsetTop < scroll)) {
|
|
return false;
|
|
}
|
|
|
|
if (!last && offset(this$1.targets[i + 1]).top <= scroll) {
|
|
return true;
|
|
}
|
|
|
|
if (scroll >= max) {
|
|
for (var j = this$1.targets.length - 1; j > i; j--) {
|
|
if (isInView(this$1.targets[j])) {
|
|
el = this$1.targets[j];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return !(data.active = $(filter(this$1.links, ("[href=\"#" + (el.id) + "\"]"))));
|
|
|
|
});
|
|
|
|
},
|
|
|
|
write: function(ref) {
|
|
var active = ref.active;
|
|
|
|
|
|
this.links.forEach(function (el) { return el.blur(); });
|
|
removeClass(this.elements, this.cls);
|
|
|
|
if (active) {
|
|
trigger(this.$el, 'active', [active, addClass(this.closest ? closest(active, this.closest) : active, this.cls)]);
|
|
}
|
|
|
|
},
|
|
|
|
events: ['scroll', 'resize']
|
|
|
|
}
|
|
|
|
]
|
|
|
|
};
|
|
|
|
var Sticky = {
|
|
|
|
mixins: [Class, Media],
|
|
|
|
props: {
|
|
top: null,
|
|
bottom: Boolean,
|
|
offset: Number,
|
|
animation: String,
|
|
clsActive: String,
|
|
clsInactive: String,
|
|
clsFixed: String,
|
|
clsBelow: String,
|
|
selTarget: String,
|
|
widthElement: Boolean,
|
|
showOnUp: Boolean,
|
|
targetOffset: Number
|
|
},
|
|
|
|
data: {
|
|
top: 0,
|
|
bottom: false,
|
|
offset: 0,
|
|
animation: '',
|
|
clsActive: 'uk-active',
|
|
clsInactive: '',
|
|
clsFixed: 'uk-sticky-fixed',
|
|
clsBelow: 'uk-sticky-below',
|
|
selTarget: '',
|
|
widthElement: false,
|
|
showOnUp: false,
|
|
targetOffset: false
|
|
},
|
|
|
|
computed: {
|
|
|
|
selTarget: function(ref, $el) {
|
|
var selTarget = ref.selTarget;
|
|
|
|
return selTarget && $(selTarget, $el) || $el;
|
|
},
|
|
|
|
widthElement: function(ref, $el) {
|
|
var widthElement = ref.widthElement;
|
|
|
|
return query(widthElement, $el) || this.placeholder;
|
|
},
|
|
|
|
isActive: {
|
|
|
|
get: function() {
|
|
return hasClass(this.selTarget, this.clsActive);
|
|
},
|
|
|
|
set: function(value) {
|
|
if (value && !this.isActive) {
|
|
replaceClass(this.selTarget, this.clsInactive, this.clsActive);
|
|
trigger(this.$el, 'active');
|
|
} else if (!value && !hasClass(this.selTarget, this.clsInactive)) {
|
|
replaceClass(this.selTarget, this.clsActive, this.clsInactive);
|
|
trigger(this.$el, 'inactive');
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
this.placeholder = $('+ .uk-sticky-placeholder', this.$el) || $('<div class="uk-sticky-placeholder"></div>');
|
|
this.isFixed = false;
|
|
this.isActive = false;
|
|
},
|
|
|
|
disconnected: function() {
|
|
|
|
if (this.isFixed) {
|
|
this.hide();
|
|
removeClass(this.selTarget, this.clsInactive);
|
|
}
|
|
|
|
remove(this.placeholder);
|
|
this.placeholder = null;
|
|
this.widthElement = null;
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'load hashchange popstate',
|
|
|
|
el: window,
|
|
|
|
handler: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
if (!(this.targetOffset !== false && location.hash && window.pageYOffset > 0)) {
|
|
return;
|
|
}
|
|
|
|
var target = $(location.hash);
|
|
|
|
if (target) {
|
|
fastdom.read(function () {
|
|
|
|
var ref = offset(target);
|
|
var top = ref.top;
|
|
var elTop = offset(this$1.$el).top;
|
|
var elHeight = this$1.$el.offsetHeight;
|
|
|
|
if (this$1.isFixed && elTop + elHeight >= top && elTop <= top + target.offsetHeight) {
|
|
scrollTop(window, top - elHeight - (isNumeric(this$1.targetOffset) ? this$1.targetOffset : 0) - this$1.offset);
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
update: [
|
|
|
|
{
|
|
|
|
read: function(ref, type) {
|
|
var height = ref.height;
|
|
|
|
|
|
if (this.isActive && type !== 'update') {
|
|
|
|
this.hide();
|
|
height = this.$el.offsetHeight;
|
|
this.show();
|
|
|
|
}
|
|
|
|
height = !this.isActive ? this.$el.offsetHeight : height;
|
|
|
|
this.topOffset = offset(this.isFixed ? this.placeholder : this.$el).top;
|
|
this.bottomOffset = this.topOffset + height;
|
|
|
|
var bottom = parseProp('bottom', this);
|
|
|
|
this.top = Math.max(toFloat(parseProp('top', this)), this.topOffset) - this.offset;
|
|
this.bottom = bottom && bottom - height;
|
|
this.inactive = !this.matchMedia;
|
|
|
|
return {
|
|
lastScroll: false,
|
|
height: height,
|
|
margins: css(this.$el, ['marginTop', 'marginBottom', 'marginLeft', 'marginRight'])
|
|
};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var height = ref.height;
|
|
var margins = ref.margins;
|
|
|
|
|
|
var ref$1 = this;
|
|
var placeholder = ref$1.placeholder;
|
|
|
|
css(placeholder, assign({height: height}, margins));
|
|
|
|
if (!within(placeholder, document)) {
|
|
after(this.$el, placeholder);
|
|
attr(placeholder, 'hidden', '');
|
|
}
|
|
|
|
// ensure active/inactive classes are applied
|
|
this.isActive = this.isActive;
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
{
|
|
|
|
read: function(ref) {
|
|
var scroll = ref.scroll; if ( scroll === void 0 ) scroll = 0;
|
|
|
|
|
|
this.width = (isVisible(this.widthElement) ? this.widthElement : this.$el).offsetWidth;
|
|
|
|
this.scroll = window.pageYOffset;
|
|
|
|
return {
|
|
dir: scroll <= this.scroll ? 'down' : 'up',
|
|
scroll: this.scroll,
|
|
visible: isVisible(this.$el),
|
|
top: offsetPosition(this.placeholder)[0]
|
|
};
|
|
},
|
|
|
|
write: function(data, type) {
|
|
var this$1 = this;
|
|
|
|
|
|
var initTimestamp = data.initTimestamp; if ( initTimestamp === void 0 ) initTimestamp = 0;
|
|
var dir = data.dir;
|
|
var lastDir = data.lastDir;
|
|
var lastScroll = data.lastScroll;
|
|
var scroll = data.scroll;
|
|
var top = data.top;
|
|
var visible = data.visible;
|
|
var now = performance.now();
|
|
|
|
data.lastScroll = scroll;
|
|
|
|
if (scroll < 0 || scroll === lastScroll || !visible || this.disabled || this.showOnUp && type !== 'scroll') {
|
|
return;
|
|
}
|
|
|
|
if (now - initTimestamp > 300 || dir !== lastDir) {
|
|
data.initScroll = scroll;
|
|
data.initTimestamp = now;
|
|
}
|
|
|
|
data.lastDir = dir;
|
|
|
|
if (this.showOnUp && Math.abs(data.initScroll - scroll) <= 30 && Math.abs(lastScroll - scroll) <= 10) {
|
|
return;
|
|
}
|
|
|
|
if (this.inactive
|
|
|| scroll < this.top
|
|
|| this.showOnUp && (scroll <= this.top || dir === 'down' || dir === 'up' && !this.isFixed && scroll <= this.bottomOffset)
|
|
) {
|
|
|
|
if (!this.isFixed) {
|
|
|
|
if (Animation.inProgress(this.$el) && top > scroll) {
|
|
Animation.cancel(this.$el);
|
|
this.hide();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
this.isFixed = false;
|
|
|
|
if (this.animation && scroll > this.topOffset) {
|
|
Animation.cancel(this.$el);
|
|
Animation.out(this.$el, this.animation).then(function () { return this$1.hide(); }, noop);
|
|
} else {
|
|
this.hide();
|
|
}
|
|
|
|
} else if (this.isFixed) {
|
|
|
|
this.update();
|
|
|
|
} else if (this.animation) {
|
|
|
|
Animation.cancel(this.$el);
|
|
this.show();
|
|
Animation.in(this.$el, this.animation).catch(noop);
|
|
|
|
} else {
|
|
this.show();
|
|
}
|
|
|
|
},
|
|
|
|
events: ['resize', 'scroll']
|
|
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
show: function() {
|
|
|
|
this.isFixed = true;
|
|
this.update();
|
|
attr(this.placeholder, 'hidden', null);
|
|
|
|
},
|
|
|
|
hide: function() {
|
|
|
|
this.isActive = false;
|
|
removeClass(this.$el, this.clsFixed, this.clsBelow);
|
|
css(this.$el, {position: '', top: '', width: ''});
|
|
attr(this.placeholder, 'hidden', '');
|
|
|
|
},
|
|
|
|
update: function() {
|
|
|
|
var active = this.top !== 0 || this.scroll > this.top;
|
|
var top = Math.max(0, this.offset);
|
|
|
|
if (this.bottom && this.scroll > this.bottom - this.offset) {
|
|
top = this.bottom - this.scroll;
|
|
}
|
|
|
|
css(this.$el, {
|
|
position: 'fixed',
|
|
top: (top + "px"),
|
|
width: this.width
|
|
});
|
|
|
|
this.isActive = active;
|
|
toggleClass(this.$el, this.clsBelow, this.scroll > this.bottomOffset);
|
|
addClass(this.$el, this.clsFixed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function parseProp(prop, ref) {
|
|
var $props = ref.$props;
|
|
var $el = ref.$el;
|
|
var propOffset = ref[(prop + "Offset")];
|
|
|
|
|
|
var value = $props[prop];
|
|
|
|
if (!value) {
|
|
return;
|
|
}
|
|
|
|
if (isNumeric(value)) {
|
|
|
|
return propOffset + toFloat(value);
|
|
|
|
} else if (isString(value) && value.match(/^-?\d+vh$/)) {
|
|
|
|
return height(window) * toFloat(value) / 100;
|
|
|
|
} else {
|
|
|
|
var el = value === true ? $el.parentNode : query(value, $el);
|
|
|
|
if (el) {
|
|
return offset(el).top + el.offsetHeight;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
var Switcher = {
|
|
|
|
mixins: [Togglable],
|
|
|
|
args: 'connect',
|
|
|
|
props: {
|
|
connect: String,
|
|
toggle: String,
|
|
active: Number,
|
|
swiping: Boolean
|
|
},
|
|
|
|
data: {
|
|
connect: '~.uk-switcher',
|
|
toggle: '> * > :first-child',
|
|
active: 0,
|
|
swiping: true,
|
|
cls: 'uk-active',
|
|
clsContainer: 'uk-switcher',
|
|
attrItem: 'uk-switcher-item',
|
|
queued: true
|
|
},
|
|
|
|
computed: {
|
|
|
|
connects: function(ref, $el) {
|
|
var connect = ref.connect;
|
|
|
|
return queryAll(connect, $el);
|
|
},
|
|
|
|
toggles: function(ref, $el) {
|
|
var toggle = ref.toggle;
|
|
|
|
return $$(toggle, $el);
|
|
}
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return ((this.toggle) + ":not(.uk-disabled)");
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
this.show(toNodes(this.$el.children).filter(function (el) { return within(e.current, el); })[0]);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'click',
|
|
|
|
el: function() {
|
|
return this.connects;
|
|
},
|
|
|
|
delegate: function() {
|
|
return ("[" + (this.attrItem) + "],[data-" + (this.attrItem) + "]");
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
this.show(data(e.current, this.attrItem));
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'swipeRight swipeLeft',
|
|
|
|
filter: function() {
|
|
return this.swiping;
|
|
},
|
|
|
|
el: function() {
|
|
return this.connects;
|
|
},
|
|
|
|
handler: function(ref) {
|
|
var type = ref.type;
|
|
|
|
this.show(endsWith(type, 'Left') ? 'next' : 'previous');
|
|
}
|
|
}
|
|
|
|
],
|
|
|
|
update: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.connects.forEach(function (list) { return this$1.updateAria(list.children); });
|
|
var ref = this.$el;
|
|
var children = ref.children;
|
|
this.show(filter(children, ("." + (this.cls)))[0] || children[this.active] || children[0]);
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
index: function() {
|
|
return !isEmpty(this.connects) && index(filter(this.connects[0].children, ("." + (this.cls)))[0]);
|
|
},
|
|
|
|
show: function(item) {
|
|
var this$1 = this;
|
|
|
|
|
|
var ref = this.$el;
|
|
var children = ref.children;
|
|
var length = children.length;
|
|
var prev = this.index();
|
|
var hasPrev = prev >= 0;
|
|
var dir = item === 'previous' ? -1 : 1;
|
|
|
|
var toggle, active, next = getIndex(item, children, prev);
|
|
|
|
for (var i = 0; i < length; i++, next = (next + dir + length) % length) {
|
|
if (!matches(this.toggles[next], '.uk-disabled *, .uk-disabled, [disabled]')) {
|
|
toggle = this.toggles[next];
|
|
active = children[next];
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!active || prev >= 0 && hasClass(active, this.cls) || prev === next) {
|
|
return;
|
|
}
|
|
|
|
removeClass(children, this.cls);
|
|
addClass(active, this.cls);
|
|
attr(this.toggles, 'aria-expanded', false);
|
|
attr(toggle, 'aria-expanded', true);
|
|
|
|
this.connects.forEach(function (list) {
|
|
if (!hasPrev) {
|
|
this$1.toggleNow(list.children[next]);
|
|
} else {
|
|
this$1.toggleElement([list.children[prev], list.children[next]]);
|
|
}
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Tab = {
|
|
|
|
mixins: [Class],
|
|
|
|
extends: Switcher,
|
|
|
|
props: {
|
|
media: Boolean
|
|
},
|
|
|
|
data: {
|
|
media: 960,
|
|
attrItem: 'uk-tab-item'
|
|
},
|
|
|
|
connected: function() {
|
|
|
|
var cls = hasClass(this.$el, 'uk-tab-left')
|
|
? 'uk-tab-left'
|
|
: hasClass(this.$el, 'uk-tab-right')
|
|
? 'uk-tab-right'
|
|
: false;
|
|
|
|
if (cls) {
|
|
this.$create('toggle', this.$el, {cls: cls, mode: 'media', media: this.media});
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
var Toggle = {
|
|
|
|
mixins: [Media, Togglable],
|
|
|
|
args: 'target',
|
|
|
|
props: {
|
|
href: String,
|
|
target: null,
|
|
mode: 'list'
|
|
},
|
|
|
|
data: {
|
|
href: false,
|
|
target: false,
|
|
mode: 'click',
|
|
queued: true
|
|
},
|
|
|
|
computed: {
|
|
|
|
target: function(ref, $el) {
|
|
var href = ref.href;
|
|
var target = ref.target;
|
|
|
|
target = queryAll(target || href, $el);
|
|
return target.length && target || [$el];
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
trigger(this.target, 'updatearia', [this]);
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: (pointerEnter + " " + pointerLeave),
|
|
|
|
filter: function() {
|
|
return includes(this.mode, 'hover');
|
|
},
|
|
|
|
handler: function(e) {
|
|
if (!isTouch(e)) {
|
|
this.toggle(("toggle" + (e.type === pointerEnter ? 'show' : 'hide')));
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
filter: function() {
|
|
return includes(this.mode, 'click') || hasTouch && includes(this.mode, 'hover');
|
|
},
|
|
|
|
handler: function(e) {
|
|
|
|
// TODO better isToggled handling
|
|
var link;
|
|
if (closest(e.target, 'a[href="#"], a[href=""]')
|
|
|| (link = closest(e.target, 'a[href]')) && (
|
|
this.cls
|
|
|| !isVisible(this.target)
|
|
|| link.hash && matches(this.target, link.hash)
|
|
)
|
|
) {
|
|
e.preventDefault();
|
|
}
|
|
|
|
this.toggle();
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
return includes(this.mode, 'media') && this.media
|
|
? {match: this.matchMedia}
|
|
: false;
|
|
},
|
|
|
|
write: function(ref) {
|
|
var match = ref.match;
|
|
|
|
|
|
var toggled = this.isToggled(this.target);
|
|
if (match ? !toggled : toggled) {
|
|
this.toggle();
|
|
}
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
toggle: function(type) {
|
|
if (trigger(this.target, type || 'toggle', [this])) {
|
|
this.toggleElement(this.target);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function core (UIkit) {
|
|
|
|
// core components
|
|
UIkit.component('accordion', Accordion);
|
|
UIkit.component('alert', Alert);
|
|
UIkit.component('cover', Cover);
|
|
UIkit.component('drop', Drop);
|
|
UIkit.component('dropdown', Dropdown);
|
|
UIkit.component('formCustom', FormCustom);
|
|
UIkit.component('gif', Gif);
|
|
UIkit.component('grid', Grid);
|
|
UIkit.component('heightMatch', HeightMatch);
|
|
UIkit.component('heightViewport', HeightViewport);
|
|
UIkit.component('icon', Icon);
|
|
UIkit.component('img', Img);
|
|
UIkit.component('leader', Leader);
|
|
UIkit.component('margin', Margin);
|
|
UIkit.component('modal', Modal$1);
|
|
UIkit.component('nav', Nav);
|
|
UIkit.component('navbar', Navbar);
|
|
UIkit.component('offcanvas', Offcanvas);
|
|
UIkit.component('overflowAuto', OverflowAuto);
|
|
UIkit.component('responsive', Responsive);
|
|
UIkit.component('scroll', Scroll);
|
|
UIkit.component('scrollspy', Scrollspy);
|
|
UIkit.component('scrollspyNav', ScrollspyNav);
|
|
UIkit.component('sticky', Sticky);
|
|
UIkit.component('svg', Svg);
|
|
UIkit.component('switcher', Switcher);
|
|
UIkit.component('tab', Tab);
|
|
UIkit.component('toggle', Toggle);
|
|
UIkit.component('video', Video);
|
|
|
|
// Icon components
|
|
UIkit.component('close', Close);
|
|
UIkit.component('marker', IconComponent);
|
|
UIkit.component('navbarToggleIcon', IconComponent);
|
|
UIkit.component('overlayIcon', IconComponent);
|
|
UIkit.component('paginationNext', IconComponent);
|
|
UIkit.component('paginationPrevious', IconComponent);
|
|
UIkit.component('searchIcon', Search);
|
|
UIkit.component('slidenavNext', Slidenav);
|
|
UIkit.component('slidenavPrevious', Slidenav);
|
|
UIkit.component('spinner', Spinner);
|
|
UIkit.component('totop', IconComponent);
|
|
|
|
// core functionality
|
|
UIkit.use(Core);
|
|
|
|
}
|
|
|
|
UIkit.version = '3.1.6';
|
|
|
|
core(UIkit);
|
|
|
|
var Countdown = {
|
|
|
|
mixins: [Class],
|
|
|
|
props: {
|
|
date: String,
|
|
clsWrapper: String
|
|
},
|
|
|
|
data: {
|
|
date: '',
|
|
clsWrapper: '.uk-countdown-%unit%'
|
|
},
|
|
|
|
computed: {
|
|
|
|
date: function(ref) {
|
|
var date = ref.date;
|
|
|
|
return Date.parse(date);
|
|
},
|
|
|
|
days: function(ref, $el) {
|
|
var clsWrapper = ref.clsWrapper;
|
|
|
|
return $(clsWrapper.replace('%unit%', 'days'), $el);
|
|
},
|
|
|
|
hours: function(ref, $el) {
|
|
var clsWrapper = ref.clsWrapper;
|
|
|
|
return $(clsWrapper.replace('%unit%', 'hours'), $el);
|
|
},
|
|
|
|
minutes: function(ref, $el) {
|
|
var clsWrapper = ref.clsWrapper;
|
|
|
|
return $(clsWrapper.replace('%unit%', 'minutes'), $el);
|
|
},
|
|
|
|
seconds: function(ref, $el) {
|
|
var clsWrapper = ref.clsWrapper;
|
|
|
|
return $(clsWrapper.replace('%unit%', 'seconds'), $el);
|
|
},
|
|
|
|
units: function() {
|
|
var this$1 = this;
|
|
|
|
return ['days', 'hours', 'minutes', 'seconds'].filter(function (unit) { return this$1[unit]; });
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
this.start();
|
|
},
|
|
|
|
disconnected: function() {
|
|
var this$1 = this;
|
|
|
|
this.stop();
|
|
this.units.forEach(function (unit) { return empty(this$1[unit]); });
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'visibilitychange',
|
|
|
|
el: document,
|
|
|
|
handler: function() {
|
|
if (document.hidden) {
|
|
this.stop();
|
|
} else {
|
|
this.start();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
update: {
|
|
|
|
write: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
var timespan = getTimeSpan(this.date);
|
|
|
|
if (timespan.total <= 0) {
|
|
|
|
this.stop();
|
|
|
|
timespan.days
|
|
= timespan.hours
|
|
= timespan.minutes
|
|
= timespan.seconds
|
|
= 0;
|
|
}
|
|
|
|
this.units.forEach(function (unit) {
|
|
|
|
var digits = String(Math.floor(timespan[unit]));
|
|
|
|
digits = digits.length < 2 ? ("0" + digits) : digits;
|
|
|
|
var el = this$1[unit];
|
|
if (el.textContent !== digits) {
|
|
digits = digits.split('');
|
|
|
|
if (digits.length !== el.children.length) {
|
|
html(el, digits.map(function () { return '<span></span>'; }).join(''));
|
|
}
|
|
|
|
digits.forEach(function (digit, i) { return el.children[i].textContent = digit; });
|
|
}
|
|
|
|
});
|
|
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
start: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.stop();
|
|
|
|
if (this.date && this.units.length) {
|
|
this.$emit();
|
|
this.timer = setInterval(function () { return this$1.$emit(); }, 1000);
|
|
}
|
|
|
|
},
|
|
|
|
stop: function() {
|
|
|
|
if (this.timer) {
|
|
clearInterval(this.timer);
|
|
this.timer = null;
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function getTimeSpan(date) {
|
|
|
|
var total = date - Date.now();
|
|
|
|
return {
|
|
total: total,
|
|
seconds: total / 1000 % 60,
|
|
minutes: total / 1000 / 60 % 60,
|
|
hours: total / 1000 / 60 / 60 % 24,
|
|
days: total / 1000 / 60 / 60 / 24
|
|
};
|
|
}
|
|
|
|
var targetClass = 'uk-animation-target';
|
|
|
|
var Animate = {
|
|
|
|
props: {
|
|
animation: Number
|
|
},
|
|
|
|
data: {
|
|
animation: 150
|
|
},
|
|
|
|
computed: {
|
|
|
|
target: function() {
|
|
return this.$el;
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
animate: function(action) {
|
|
var this$1 = this;
|
|
|
|
|
|
addStyle();
|
|
|
|
var children = toNodes(this.target.children);
|
|
var propsFrom = children.map(function (el) { return getProps(el, true); });
|
|
|
|
var oldHeight = height(this.target);
|
|
var oldScrollY = window.pageYOffset;
|
|
|
|
action();
|
|
|
|
Transition.cancel(this.target);
|
|
children.forEach(Transition.cancel);
|
|
|
|
reset(this.target);
|
|
this.$update(this.target);
|
|
fastdom.flush();
|
|
|
|
var newHeight = height(this.target);
|
|
|
|
children = children.concat(toNodes(this.target.children).filter(function (el) { return !includes(children, el); }));
|
|
|
|
var propsTo = children.map(function (el, i) { return el.parentNode && i in propsFrom
|
|
? propsFrom[i]
|
|
? isVisible(el)
|
|
? getPositionWithMargin(el)
|
|
: {opacity: 0}
|
|
: {opacity: isVisible(el) ? 1 : 0}
|
|
: false; }
|
|
);
|
|
|
|
propsFrom = propsTo.map(function (props, i) {
|
|
var from = children[i].parentNode === this$1.target
|
|
? propsFrom[i] || getProps(children[i])
|
|
: false;
|
|
|
|
if (from) {
|
|
if (!props) {
|
|
delete from.opacity;
|
|
} else if (!('opacity' in props)) {
|
|
var opacity = from.opacity;
|
|
|
|
if (opacity % 1) {
|
|
props.opacity = 1;
|
|
} else {
|
|
delete from.opacity;
|
|
}
|
|
}
|
|
}
|
|
|
|
return from;
|
|
});
|
|
|
|
addClass(this.target, targetClass);
|
|
children.forEach(function (el, i) { return propsFrom[i] && css(el, propsFrom[i]); });
|
|
css(this.target, 'height', oldHeight);
|
|
scrollTop(window, oldScrollY);
|
|
|
|
return Promise.all(children.map(function (el, i) { return propsFrom[i] && propsTo[i]
|
|
? Transition.start(el, propsTo[i], this$1.animation, 'ease')
|
|
: Promise.resolve(); }
|
|
).concat(Transition.start(this.target, {height: newHeight}, this.animation, 'ease'))).then(function () {
|
|
children.forEach(function (el, i) { return css(el, {display: propsTo[i].opacity === 0 ? 'none' : '', zIndex: ''}); });
|
|
reset(this$1.target);
|
|
this$1.$update(this$1.target);
|
|
fastdom.flush(); // needed for IE11
|
|
}, noop);
|
|
|
|
}
|
|
}
|
|
};
|
|
|
|
function getProps(el, opacity) {
|
|
|
|
var zIndex = css(el, 'zIndex');
|
|
|
|
return isVisible(el)
|
|
? assign({
|
|
display: '',
|
|
opacity: opacity ? css(el, 'opacity') : '0',
|
|
pointerEvents: 'none',
|
|
position: 'absolute',
|
|
zIndex: zIndex === 'auto' ? index(el) : zIndex
|
|
}, getPositionWithMargin(el))
|
|
: false;
|
|
}
|
|
|
|
function reset(el) {
|
|
css(el.children, {
|
|
height: '',
|
|
left: '',
|
|
opacity: '',
|
|
pointerEvents: '',
|
|
position: '',
|
|
top: '',
|
|
width: ''
|
|
});
|
|
removeClass(el, targetClass);
|
|
css(el, 'height', '');
|
|
}
|
|
|
|
function getPositionWithMargin(el) {
|
|
var ref = el.getBoundingClientRect();
|
|
var height = ref.height;
|
|
var width = ref.width;
|
|
var ref$1 = position(el);
|
|
var top = ref$1.top;
|
|
var left = ref$1.left;
|
|
top += toFloat(css(el, 'marginTop'));
|
|
|
|
return {top: top, left: left, height: height, width: width};
|
|
}
|
|
|
|
var style;
|
|
|
|
function addStyle() {
|
|
if (style) {
|
|
return;
|
|
}
|
|
style = append(document.head, '<style>').sheet;
|
|
style.insertRule(
|
|
("." + targetClass + " > * {\n margin-top: 0 !important;\n transform: none !important;\n }"), 0
|
|
);
|
|
}
|
|
|
|
var Filter = {
|
|
|
|
mixins: [Animate],
|
|
|
|
args: 'target',
|
|
|
|
props: {
|
|
target: Boolean,
|
|
selActive: Boolean
|
|
},
|
|
|
|
data: {
|
|
target: null,
|
|
selActive: false,
|
|
attrItem: 'uk-filter-control',
|
|
cls: 'uk-active',
|
|
animation: 250
|
|
},
|
|
|
|
computed: {
|
|
|
|
toggles: {
|
|
|
|
get: function(ref, $el) {
|
|
var attrItem = ref.attrItem;
|
|
|
|
return $$(("[" + (this.attrItem) + "],[data-" + (this.attrItem) + "]"), $el);
|
|
},
|
|
|
|
watch: function() {
|
|
this.updateState();
|
|
}
|
|
|
|
},
|
|
|
|
target: function(ref, $el) {
|
|
var target = ref.target;
|
|
|
|
return $(target, $el);
|
|
},
|
|
|
|
children: {
|
|
|
|
get: function() {
|
|
return toNodes(this.target && this.target.children);
|
|
},
|
|
|
|
watch: function(list, old) {
|
|
if (!isEqualList(list, old)) {
|
|
this.updateState();
|
|
}
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return ("[" + (this.attrItem) + "],[data-" + (this.attrItem) + "]");
|
|
},
|
|
|
|
handler: function(e) {
|
|
|
|
e.preventDefault();
|
|
this.apply(e.current);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
connected: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.updateState();
|
|
|
|
if (this.selActive !== false) {
|
|
var actives = $$(this.selActive, this.$el);
|
|
this.toggles.forEach(function (el) { return toggleClass(el, this$1.cls, includes(actives, el)); });
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
apply: function(el) {
|
|
this.setState(mergeState(el, this.attrItem, this.getState()));
|
|
},
|
|
|
|
getState: function() {
|
|
var this$1 = this;
|
|
|
|
return this.toggles
|
|
.filter(function (item) { return hasClass(item, this$1.cls); })
|
|
.reduce(function (state, el) { return mergeState(el, this$1.attrItem, state); }, {filter: {'': ''}, sort: []});
|
|
},
|
|
|
|
setState: function(state, animate) {
|
|
var this$1 = this;
|
|
if ( animate === void 0 ) animate = true;
|
|
|
|
|
|
state = assign({filter: {'': ''}, sort: []}, state);
|
|
|
|
trigger(this.$el, 'beforeFilter', [this, state]);
|
|
|
|
var ref = this;
|
|
var children = ref.children;
|
|
|
|
this.toggles.forEach(function (el) { return toggleClass(el, this$1.cls, !!matchFilter(el, this$1.attrItem, state)); });
|
|
|
|
var apply = function () {
|
|
|
|
var selector = getSelector(state);
|
|
|
|
children.forEach(function (el) { return css(el, 'display', selector && !matches(el, selector) ? 'none' : ''); });
|
|
|
|
var ref = state.sort;
|
|
var sort = ref[0];
|
|
var order = ref[1];
|
|
|
|
if (sort) {
|
|
var sorted = sortItems(children, sort, order);
|
|
if (!isEqual(sorted, children)) {
|
|
sorted.forEach(function (el) { return append(this$1.target, el); });
|
|
}
|
|
}
|
|
|
|
};
|
|
|
|
if (animate) {
|
|
this.animate(apply).then(function () { return trigger(this$1.$el, 'afterFilter', [this$1]); });
|
|
} else {
|
|
apply();
|
|
trigger(this.$el, 'afterFilter', [this]);
|
|
}
|
|
|
|
},
|
|
|
|
updateState: function() {
|
|
var this$1 = this;
|
|
|
|
fastdom.write(function () { return this$1.setState(this$1.getState(), false); });
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function getFilter(el, attr) {
|
|
return parseOptions(data(el, attr), ['filter']);
|
|
}
|
|
|
|
function mergeState(el, attr, state) {
|
|
|
|
var filterBy = getFilter(el, attr);
|
|
var filter = filterBy.filter;
|
|
var group = filterBy.group;
|
|
var sort = filterBy.sort;
|
|
var order = filterBy.order; if ( order === void 0 ) order = 'asc';
|
|
|
|
if (filter || isUndefined(sort)) {
|
|
|
|
if (group) {
|
|
|
|
if (filter) {
|
|
delete state.filter[''];
|
|
state.filter[group] = filter;
|
|
} else {
|
|
delete state.filter[group];
|
|
|
|
if (isEmpty(state.filter) || '' in state.filter) {
|
|
state.filter = {'': filter || ''};
|
|
}
|
|
|
|
}
|
|
|
|
} else {
|
|
state.filter = {'': filter || ''};
|
|
}
|
|
|
|
}
|
|
|
|
if (!isUndefined(sort)) {
|
|
state.sort = [sort, order];
|
|
}
|
|
|
|
return state;
|
|
}
|
|
|
|
function matchFilter(el, attr, ref) {
|
|
var stateFilter = ref.filter; if ( stateFilter === void 0 ) stateFilter = {'': ''};
|
|
var ref_sort = ref.sort;
|
|
var stateSort = ref_sort[0];
|
|
var stateOrder = ref_sort[1];
|
|
|
|
|
|
var ref$1 = getFilter(el, attr);
|
|
var filter = ref$1.filter; if ( filter === void 0 ) filter = '';
|
|
var group = ref$1.group; if ( group === void 0 ) group = '';
|
|
var sort = ref$1.sort;
|
|
var order = ref$1.order; if ( order === void 0 ) order = 'asc';
|
|
|
|
return isUndefined(sort)
|
|
? group in stateFilter && filter === stateFilter[group]
|
|
|| !filter && group && !(group in stateFilter) && !stateFilter['']
|
|
: stateSort === sort && stateOrder === order;
|
|
}
|
|
|
|
function isEqualList(listA, listB) {
|
|
return listA.length === listB.length
|
|
&& listA.every(function (el) { return ~listB.indexOf(el); });
|
|
}
|
|
|
|
function getSelector(ref) {
|
|
var filter = ref.filter;
|
|
|
|
var selector = '';
|
|
each(filter, function (value) { return selector += value || ''; });
|
|
return selector;
|
|
}
|
|
|
|
function sortItems(nodes, sort, order) {
|
|
return assign([], nodes).sort(function (a, b) { return data(a, sort).localeCompare(data(b, sort), undefined, {numeric: true}) * (order === 'asc' || -1); });
|
|
}
|
|
|
|
var Animations = {
|
|
|
|
slide: {
|
|
|
|
show: function(dir) {
|
|
return [
|
|
{transform: translate(dir * -100)},
|
|
{transform: translate()}
|
|
];
|
|
},
|
|
|
|
percent: function(current) {
|
|
return translated(current);
|
|
},
|
|
|
|
translate: function(percent, dir) {
|
|
return [
|
|
{transform: translate(dir * -100 * percent)},
|
|
{transform: translate(dir * 100 * (1 - percent))}
|
|
];
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function translated(el) {
|
|
return Math.abs(css(el, 'transform').split(',')[4] / el.offsetWidth) || 0;
|
|
}
|
|
|
|
function translate(value, unit) {
|
|
if ( value === void 0 ) value = 0;
|
|
if ( unit === void 0 ) unit = '%';
|
|
|
|
value += value ? unit : '';
|
|
return isIE ? ("translateX(" + value + ")") : ("translate3d(" + value + ", 0, 0)"); // currently not translate3d in IE, translate3d within translate3d does not work while transitioning
|
|
}
|
|
|
|
function scale3d(value) {
|
|
return ("scale3d(" + value + ", " + value + ", 1)");
|
|
}
|
|
|
|
var Animations$1 = assign({}, Animations, {
|
|
|
|
fade: {
|
|
|
|
show: function() {
|
|
return [
|
|
{opacity: 0},
|
|
{opacity: 1}
|
|
];
|
|
},
|
|
|
|
percent: function(current) {
|
|
return 1 - css(current, 'opacity');
|
|
},
|
|
|
|
translate: function(percent) {
|
|
return [
|
|
{opacity: 1 - percent},
|
|
{opacity: percent}
|
|
];
|
|
}
|
|
|
|
},
|
|
|
|
scale: {
|
|
|
|
show: function() {
|
|
return [
|
|
{opacity: 0, transform: scale3d(1 - .2)},
|
|
{opacity: 1, transform: scale3d(1)}
|
|
];
|
|
},
|
|
|
|
percent: function(current) {
|
|
return 1 - css(current, 'opacity');
|
|
},
|
|
|
|
translate: function(percent) {
|
|
return [
|
|
{opacity: 1 - percent, transform: scale3d(1 - .2 * percent)},
|
|
{opacity: percent, transform: scale3d(1 - .2 + .2 * percent)}
|
|
];
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
function Transitioner(prev, next, dir, ref) {
|
|
var animation = ref.animation;
|
|
var easing = ref.easing;
|
|
|
|
|
|
var percent = animation.percent;
|
|
var translate = animation.translate;
|
|
var show = animation.show; if ( show === void 0 ) show = noop;
|
|
var props = show(dir);
|
|
var deferred = new Deferred();
|
|
|
|
return {
|
|
|
|
dir: dir,
|
|
|
|
show: function(duration, percent, linear) {
|
|
var this$1 = this;
|
|
if ( percent === void 0 ) percent = 0;
|
|
|
|
|
|
var timing = linear ? 'linear' : easing;
|
|
duration -= Math.round(duration * clamp(percent, -1, 1));
|
|
|
|
this.translate(percent);
|
|
|
|
triggerUpdate(next, 'itemin', {percent: percent, duration: duration, timing: timing, dir: dir});
|
|
triggerUpdate(prev, 'itemout', {percent: 1 - percent, duration: duration, timing: timing, dir: dir});
|
|
|
|
Promise.all([
|
|
Transition.start(next, props[1], duration, timing),
|
|
Transition.start(prev, props[0], duration, timing)
|
|
]).then(function () {
|
|
this$1.reset();
|
|
deferred.resolve();
|
|
}, noop);
|
|
|
|
return deferred.promise;
|
|
},
|
|
|
|
stop: function() {
|
|
return Transition.stop([next, prev]);
|
|
},
|
|
|
|
cancel: function() {
|
|
Transition.cancel([next, prev]);
|
|
},
|
|
|
|
reset: function() {
|
|
for (var prop in props[0]) {
|
|
css([next, prev], prop, '');
|
|
}
|
|
},
|
|
|
|
forward: function(duration, percent) {
|
|
if ( percent === void 0 ) percent = this.percent();
|
|
|
|
Transition.cancel([next, prev]);
|
|
return this.show(duration, percent, true);
|
|
|
|
},
|
|
|
|
translate: function(percent) {
|
|
|
|
this.reset();
|
|
|
|
var props = translate(percent, dir);
|
|
css(next, props[1]);
|
|
css(prev, props[0]);
|
|
triggerUpdate(next, 'itemtranslatein', {percent: percent, dir: dir});
|
|
triggerUpdate(prev, 'itemtranslateout', {percent: 1 - percent, dir: dir});
|
|
|
|
},
|
|
|
|
percent: function() {
|
|
return percent(prev || next, next, dir);
|
|
},
|
|
|
|
getDistance: function() {
|
|
return prev && prev.offsetWidth;
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
function triggerUpdate(el, type, data) {
|
|
trigger(el, createEvent(type, false, false, data));
|
|
}
|
|
|
|
var SliderAutoplay = {
|
|
|
|
props: {
|
|
autoplay: Boolean,
|
|
autoplayInterval: Number,
|
|
pauseOnHover: Boolean
|
|
},
|
|
|
|
data: {
|
|
autoplay: false,
|
|
autoplayInterval: 7000,
|
|
pauseOnHover: true
|
|
},
|
|
|
|
connected: function() {
|
|
this.autoplay && this.startAutoplay();
|
|
},
|
|
|
|
disconnected: function() {
|
|
this.stopAutoplay();
|
|
},
|
|
|
|
update: function() {
|
|
attr(this.slides, 'tabindex', '-1');
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'visibilitychange',
|
|
|
|
el: document,
|
|
|
|
filter: function() {
|
|
return this.autoplay;
|
|
},
|
|
|
|
handler: function() {
|
|
if (document.hidden) {
|
|
this.stopAutoplay();
|
|
} else {
|
|
this.startAutoplay();
|
|
}
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'mouseenter',
|
|
|
|
filter: function() {
|
|
return this.autoplay && this.pauseOnHover;
|
|
},
|
|
|
|
handler: function() {
|
|
this.isHovering = true;
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'mouseleave',
|
|
|
|
filter: function() {
|
|
return this.autoplay && this.pauseOnHover;
|
|
},
|
|
|
|
handler: function() {
|
|
this.isHovering = false;
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
startAutoplay: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.stopAutoplay();
|
|
|
|
this.interval = setInterval(
|
|
function () { return !within(document.activeElement, this$1.$el)
|
|
&& !this$1.isHovering
|
|
&& !this$1.stack.length
|
|
&& this$1.show('next'); },
|
|
this.autoplayInterval
|
|
);
|
|
|
|
},
|
|
|
|
stopAutoplay: function() {
|
|
this.interval && clearInterval(this.interval);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var SliderDrag = {
|
|
|
|
props: {
|
|
draggable: Boolean
|
|
},
|
|
|
|
data: {
|
|
draggable: true,
|
|
threshold: 10
|
|
},
|
|
|
|
created: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
['start', 'move', 'end'].forEach(function (key) {
|
|
|
|
var fn = this$1[key];
|
|
this$1[key] = function (e) {
|
|
|
|
var pos = getEventPos(e).x * (isRtl ? -1 : 1);
|
|
|
|
this$1.prevPos = pos !== this$1.pos ? this$1.pos : this$1.prevPos;
|
|
this$1.pos = pos;
|
|
|
|
fn(e);
|
|
};
|
|
|
|
});
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: pointerDown,
|
|
|
|
delegate: function() {
|
|
return this.selSlides;
|
|
},
|
|
|
|
handler: function(e) {
|
|
|
|
if (!this.draggable
|
|
|| !isTouch(e) && hasTextNodesOnly(e.target)
|
|
|| e.button > 0
|
|
|| this.length < 2
|
|
) {
|
|
return;
|
|
}
|
|
|
|
this.start(e);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
// Workaround for iOS 11 bug: https://bugs.webkit.org/show_bug.cgi?id=184250
|
|
|
|
name: 'touchmove',
|
|
passive: false,
|
|
handler: 'move',
|
|
delegate: function() {
|
|
return this.selSlides;
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'dragstart',
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
}
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
start: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.drag = this.pos;
|
|
|
|
if (this._transitioner) {
|
|
|
|
this.percent = this._transitioner.percent();
|
|
this.drag += this._transitioner.getDistance() * this.percent * this.dir;
|
|
|
|
this._transitioner.cancel();
|
|
this._transitioner.translate(this.percent);
|
|
|
|
this.dragging = true;
|
|
|
|
this.stack = [];
|
|
|
|
} else {
|
|
this.prevIndex = this.index;
|
|
}
|
|
|
|
// See above workaround notice
|
|
var off = pointerMove !== 'touchmove'
|
|
? on(document, pointerMove, this.move, {passive: false})
|
|
: noop;
|
|
this.unbindMove = function () {
|
|
off();
|
|
this$1.unbindMove = null;
|
|
};
|
|
on(window, 'scroll', this.unbindMove);
|
|
on(document, pointerUp, this.end, true);
|
|
|
|
css(this.list, 'userSelect', 'none');
|
|
|
|
},
|
|
|
|
move: function(e) {
|
|
var this$1 = this;
|
|
|
|
|
|
// See above workaround notice
|
|
if (!this.unbindMove) {
|
|
return;
|
|
}
|
|
|
|
var distance = this.pos - this.drag;
|
|
|
|
if (distance === 0 || this.prevPos === this.pos || !this.dragging && Math.abs(distance) < this.threshold) {
|
|
return;
|
|
}
|
|
|
|
css(this.list, 'pointerEvents', 'none');
|
|
|
|
e.cancelable && e.preventDefault();
|
|
|
|
this.dragging = true;
|
|
this.dir = (distance < 0 ? 1 : -1);
|
|
|
|
var ref = this;
|
|
var slides = ref.slides;
|
|
var ref$1 = this;
|
|
var prevIndex = ref$1.prevIndex;
|
|
var dis = Math.abs(distance);
|
|
var nextIndex = this.getIndex(prevIndex + this.dir, prevIndex);
|
|
var width = this._getDistance(prevIndex, nextIndex) || slides[prevIndex].offsetWidth;
|
|
|
|
while (nextIndex !== prevIndex && dis > width) {
|
|
|
|
this.drag -= width * this.dir;
|
|
|
|
prevIndex = nextIndex;
|
|
dis -= width;
|
|
nextIndex = this.getIndex(prevIndex + this.dir, prevIndex);
|
|
width = this._getDistance(prevIndex, nextIndex) || slides[prevIndex].offsetWidth;
|
|
|
|
}
|
|
|
|
this.percent = dis / width;
|
|
|
|
var prev = slides[prevIndex];
|
|
var next = slides[nextIndex];
|
|
var changed = this.index !== nextIndex;
|
|
var edge = prevIndex === nextIndex;
|
|
|
|
var itemShown;
|
|
|
|
[this.index, this.prevIndex].filter(function (i) { return !includes([nextIndex, prevIndex], i); }).forEach(function (i) {
|
|
trigger(slides[i], 'itemhidden', [this$1]);
|
|
|
|
if (edge) {
|
|
itemShown = true;
|
|
this$1.prevIndex = prevIndex;
|
|
}
|
|
|
|
});
|
|
|
|
if (this.index === prevIndex && this.prevIndex !== prevIndex || itemShown) {
|
|
trigger(slides[this.index], 'itemshown', [this]);
|
|
}
|
|
|
|
if (changed) {
|
|
this.prevIndex = prevIndex;
|
|
this.index = nextIndex;
|
|
|
|
!edge && trigger(prev, 'beforeitemhide', [this]);
|
|
trigger(next, 'beforeitemshow', [this]);
|
|
}
|
|
|
|
this._transitioner = this._translate(Math.abs(this.percent), prev, !edge && next);
|
|
|
|
if (changed) {
|
|
!edge && trigger(prev, 'itemhide', [this]);
|
|
trigger(next, 'itemshow', [this]);
|
|
}
|
|
|
|
},
|
|
|
|
end: function() {
|
|
|
|
off(window, 'scroll', this.unbindMove);
|
|
this.unbindMove && this.unbindMove();
|
|
off(document, pointerUp, this.end, true);
|
|
|
|
if (this.dragging) {
|
|
|
|
this.dragging = null;
|
|
|
|
if (this.index === this.prevIndex) {
|
|
this.percent = 1 - this.percent;
|
|
this.dir *= -1;
|
|
this._show(false, this.index, true);
|
|
this._transitioner = null;
|
|
} else {
|
|
|
|
var dirChange = (isRtl ? this.dir * (isRtl ? 1 : -1) : this.dir) < 0 === this.prevPos > this.pos;
|
|
this.index = dirChange ? this.index : this.prevIndex;
|
|
|
|
if (dirChange) {
|
|
this.percent = 1 - this.percent;
|
|
}
|
|
|
|
this.show(this.dir > 0 && !dirChange || this.dir < 0 && dirChange ? 'next' : 'previous', true);
|
|
}
|
|
|
|
}
|
|
|
|
css(this.list, {userSelect: '', pointerEvents: ''});
|
|
|
|
this.drag
|
|
= this.percent
|
|
= null;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function hasTextNodesOnly(el) {
|
|
return !el.children.length && el.childNodes.length;
|
|
}
|
|
|
|
var SliderNav = {
|
|
|
|
data: {
|
|
selNav: false
|
|
},
|
|
|
|
computed: {
|
|
|
|
nav: function(ref, $el) {
|
|
var selNav = ref.selNav;
|
|
|
|
return $(selNav, $el);
|
|
},
|
|
|
|
selNavItem: function(ref) {
|
|
var attrItem = ref.attrItem;
|
|
|
|
return ("[" + attrItem + "],[data-" + attrItem + "]");
|
|
},
|
|
|
|
navItems: function(_, $el) {
|
|
return $$(this.selNavItem, $el);
|
|
}
|
|
|
|
},
|
|
|
|
update: {
|
|
|
|
write: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
if (this.nav && this.length !== this.nav.children.length) {
|
|
html(this.nav, this.slides.map(function (_, i) { return ("<li " + (this$1.attrItem) + "=\"" + i + "\"><a href=\"#\"></a></li>"); }).join(''));
|
|
}
|
|
|
|
toggleClass($$(this.selNavItem, this.$el).concat(this.nav), 'uk-hidden', !this.maxIndex);
|
|
|
|
this.updateNav();
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return this.selNavItem;
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
this.show(data(e.current, this.attrItem));
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'itemshow',
|
|
handler: 'updateNav'
|
|
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
updateNav: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
var i = this.getValidIndex();
|
|
this.navItems.forEach(function (el) {
|
|
|
|
var cmd = data(el, this$1.attrItem);
|
|
|
|
toggleClass(el, this$1.clsActive, toNumber(cmd) === i);
|
|
toggleClass(el, 'uk-invisible', this$1.finite && (cmd === 'previous' && i === 0 || cmd === 'next' && i >= this$1.maxIndex));
|
|
});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Slider = {
|
|
|
|
mixins: [SliderAutoplay, SliderDrag, SliderNav],
|
|
|
|
props: {
|
|
clsActivated: Boolean,
|
|
easing: String,
|
|
index: Number,
|
|
finite: Boolean,
|
|
velocity: Number
|
|
},
|
|
|
|
data: function () { return ({
|
|
easing: 'ease',
|
|
finite: false,
|
|
velocity: 1,
|
|
index: 0,
|
|
stack: [],
|
|
percent: 0,
|
|
clsActive: 'uk-active',
|
|
clsActivated: false,
|
|
Transitioner: false,
|
|
transitionOptions: {}
|
|
}); },
|
|
|
|
computed: {
|
|
|
|
duration: function(ref, $el) {
|
|
var velocity = ref.velocity;
|
|
|
|
return speedUp($el.offsetWidth / velocity);
|
|
},
|
|
|
|
length: function() {
|
|
return this.slides.length;
|
|
},
|
|
|
|
list: function(ref, $el) {
|
|
var selList = ref.selList;
|
|
|
|
return $(selList, $el);
|
|
},
|
|
|
|
maxIndex: function() {
|
|
return this.length - 1;
|
|
},
|
|
|
|
selSlides: function(ref) {
|
|
var selList = ref.selList;
|
|
|
|
return (selList + " > *");
|
|
},
|
|
|
|
slides: function() {
|
|
return toNodes(this.list.children);
|
|
}
|
|
|
|
},
|
|
|
|
events: {
|
|
|
|
itemshown: function() {
|
|
this.$update(this.list);
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
show: function(index, force) {
|
|
var this$1 = this;
|
|
if ( force === void 0 ) force = false;
|
|
|
|
|
|
if (this.dragging || !this.length) {
|
|
return;
|
|
}
|
|
|
|
var ref = this;
|
|
var stack = ref.stack;
|
|
var queueIndex = force ? 0 : stack.length;
|
|
var reset = function () {
|
|
stack.splice(queueIndex, 1);
|
|
|
|
if (stack.length) {
|
|
this$1.show(stack.shift(), true);
|
|
}
|
|
};
|
|
|
|
stack[force ? 'unshift' : 'push'](index);
|
|
|
|
if (!force && stack.length > 1) {
|
|
|
|
if (stack.length === 2) {
|
|
this._transitioner.forward(Math.min(this.duration, 200));
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
var prevIndex = this.index;
|
|
var prev = hasClass(this.slides, this.clsActive) && this.slides[prevIndex];
|
|
var nextIndex = this.getIndex(index, this.index);
|
|
var next = this.slides[nextIndex];
|
|
|
|
if (prev === next) {
|
|
reset();
|
|
return;
|
|
}
|
|
|
|
this.dir = getDirection(index, prevIndex);
|
|
this.prevIndex = prevIndex;
|
|
this.index = nextIndex;
|
|
|
|
prev && trigger(prev, 'beforeitemhide', [this]);
|
|
if (!trigger(next, 'beforeitemshow', [this, prev])) {
|
|
this.index = this.prevIndex;
|
|
reset();
|
|
return;
|
|
}
|
|
|
|
var promise = this._show(prev, next, force).then(function () {
|
|
|
|
prev && trigger(prev, 'itemhidden', [this$1]);
|
|
trigger(next, 'itemshown', [this$1]);
|
|
|
|
return new Promise(function (resolve) {
|
|
fastdom.write(function () {
|
|
stack.shift();
|
|
if (stack.length) {
|
|
this$1.show(stack.shift(), true);
|
|
} else {
|
|
this$1._transitioner = null;
|
|
}
|
|
resolve();
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
prev && trigger(prev, 'itemhide', [this]);
|
|
trigger(next, 'itemshow', [this]);
|
|
|
|
return promise;
|
|
|
|
},
|
|
|
|
getIndex: function(index, prev) {
|
|
if ( index === void 0 ) index = this.index;
|
|
if ( prev === void 0 ) prev = this.index;
|
|
|
|
return clamp(getIndex(index, this.slides, prev, this.finite), 0, this.maxIndex);
|
|
},
|
|
|
|
getValidIndex: function(index, prevIndex) {
|
|
if ( index === void 0 ) index = this.index;
|
|
if ( prevIndex === void 0 ) prevIndex = this.prevIndex;
|
|
|
|
return this.getIndex(index, prevIndex);
|
|
},
|
|
|
|
_show: function(prev, next, force) {
|
|
|
|
this._transitioner = this._getTransitioner(
|
|
prev,
|
|
next,
|
|
this.dir,
|
|
assign({
|
|
easing: force
|
|
? next.offsetWidth < 600
|
|
? 'cubic-bezier(0.25, 0.46, 0.45, 0.94)' /* easeOutQuad */
|
|
: 'cubic-bezier(0.165, 0.84, 0.44, 1)' /* easeOutQuart */
|
|
: this.easing
|
|
}, this.transitionOptions)
|
|
);
|
|
|
|
if (!force && !prev) {
|
|
this._transitioner.translate(1);
|
|
return Promise.resolve();
|
|
}
|
|
|
|
var ref = this.stack;
|
|
var length = ref.length;
|
|
return this._transitioner[length > 1 ? 'forward' : 'show'](length > 1 ? Math.min(this.duration, 75 + 75 / (length - 1)) : this.duration, this.percent);
|
|
|
|
},
|
|
|
|
_getDistance: function(prev, next) {
|
|
return new this._getTransitioner(prev, prev !== next && next).getDistance();
|
|
},
|
|
|
|
_translate: function(percent, prev, next) {
|
|
if ( prev === void 0 ) prev = this.prevIndex;
|
|
if ( next === void 0 ) next = this.index;
|
|
|
|
var transitioner = this._getTransitioner(prev !== next ? prev : false, next);
|
|
transitioner.translate(percent);
|
|
return transitioner;
|
|
},
|
|
|
|
_getTransitioner: function(prev, next, dir, options) {
|
|
if ( prev === void 0 ) prev = this.prevIndex;
|
|
if ( next === void 0 ) next = this.index;
|
|
if ( dir === void 0 ) dir = this.dir || 1;
|
|
if ( options === void 0 ) options = this.transitionOptions;
|
|
|
|
return new this.Transitioner(
|
|
isNumber(prev) ? this.slides[prev] : prev,
|
|
isNumber(next) ? this.slides[next] : next,
|
|
dir * (isRtl ? -1 : 1),
|
|
options
|
|
);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function getDirection(index, prevIndex) {
|
|
return index === 'next'
|
|
? 1
|
|
: index === 'previous'
|
|
? -1
|
|
: index < prevIndex
|
|
? -1
|
|
: 1;
|
|
}
|
|
|
|
function speedUp(x) {
|
|
return .5 * x + 300; // parabola through (400,500; 600,600; 1800,1200)
|
|
}
|
|
|
|
var Slideshow = {
|
|
|
|
mixins: [Slider],
|
|
|
|
props: {
|
|
animation: String
|
|
},
|
|
|
|
data: {
|
|
animation: 'slide',
|
|
clsActivated: 'uk-transition-active',
|
|
Animations: Animations,
|
|
Transitioner: Transitioner
|
|
},
|
|
|
|
computed: {
|
|
|
|
animation: function(ref) {
|
|
var animation = ref.animation;
|
|
var Animations = ref.Animations;
|
|
|
|
return assign(animation in Animations ? Animations[animation] : Animations.slide, {name: animation});
|
|
},
|
|
|
|
transitionOptions: function() {
|
|
return {animation: this.animation};
|
|
}
|
|
|
|
},
|
|
|
|
events: {
|
|
|
|
'itemshow itemhide itemshown itemhidden': function(ref) {
|
|
var target = ref.target;
|
|
|
|
this.$update(target);
|
|
},
|
|
|
|
beforeitemshow: function(ref) {
|
|
var target = ref.target;
|
|
|
|
addClass(target, this.clsActive);
|
|
},
|
|
|
|
itemshown: function(ref) {
|
|
var target = ref.target;
|
|
|
|
addClass(target, this.clsActivated);
|
|
},
|
|
|
|
itemhidden: function(ref) {
|
|
var target = ref.target;
|
|
|
|
removeClass(target, this.clsActive, this.clsActivated);
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var lightboxPanel = {
|
|
|
|
mixins: [Container, Modal, Togglable, Slideshow],
|
|
|
|
functional: true,
|
|
|
|
props: {
|
|
delayControls: Number,
|
|
preload: Number,
|
|
videoAutoplay: Boolean,
|
|
template: String
|
|
},
|
|
|
|
data: function () { return ({
|
|
preload: 1,
|
|
videoAutoplay: false,
|
|
delayControls: 3000,
|
|
items: [],
|
|
cls: 'uk-open',
|
|
clsPage: 'uk-lightbox-page',
|
|
selList: '.uk-lightbox-items',
|
|
attrItem: 'uk-lightbox-item',
|
|
selClose: '.uk-close-large',
|
|
pauseOnHover: false,
|
|
velocity: 2,
|
|
Animations: Animations$1,
|
|
template: "<div class=\"uk-lightbox uk-overflow-hidden\"> <ul class=\"uk-lightbox-items\"></ul> <div class=\"uk-lightbox-toolbar uk-position-top uk-text-right uk-transition-slide-top uk-transition-opaque\"> <button class=\"uk-lightbox-toolbar-icon uk-close-large\" type=\"button\" uk-close></button> </div> <a class=\"uk-lightbox-button uk-position-center-left uk-position-medium uk-transition-fade\" href=\"#\" uk-slidenav-previous uk-lightbox-item=\"previous\"></a> <a class=\"uk-lightbox-button uk-position-center-right uk-position-medium uk-transition-fade\" href=\"#\" uk-slidenav-next uk-lightbox-item=\"next\"></a> <div class=\"uk-lightbox-toolbar uk-lightbox-caption uk-position-bottom uk-text-center uk-transition-slide-bottom uk-transition-opaque\"></div> </div>"
|
|
}); },
|
|
|
|
created: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
this.$mount(append(this.container, this.template));
|
|
|
|
this.caption = $('.uk-lightbox-caption', this.$el);
|
|
|
|
this.items.forEach(function () { return append(this$1.list, '<li></li>'); });
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: (pointerMove + " " + pointerDown + " keydown"),
|
|
|
|
handler: 'showControls'
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
self: true,
|
|
|
|
delegate: function() {
|
|
return this.selSlides;
|
|
},
|
|
|
|
handler: function(e) {
|
|
|
|
if (e.defaultPrevented) {
|
|
return;
|
|
}
|
|
|
|
this.hide();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'shown',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
this.showControls();
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'hide',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
|
|
this.hideControls();
|
|
|
|
removeClass(this.slides, this.clsActive);
|
|
Transition.stop(this.slides);
|
|
|
|
}
|
|
},
|
|
|
|
{
|
|
|
|
name: 'hidden',
|
|
|
|
self: true,
|
|
|
|
handler: function() {
|
|
this.$destroy(true);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'keyup',
|
|
|
|
el: document,
|
|
|
|
handler: function(e) {
|
|
|
|
if (!this.isToggled(this.$el)) {
|
|
return;
|
|
}
|
|
|
|
switch (e.keyCode) {
|
|
case 37:
|
|
this.show('previous');
|
|
break;
|
|
case 39:
|
|
this.show('next');
|
|
break;
|
|
}
|
|
}
|
|
},
|
|
|
|
{
|
|
|
|
name: 'beforeitemshow',
|
|
|
|
handler: function(e) {
|
|
|
|
if (this.isToggled()) {
|
|
return;
|
|
}
|
|
|
|
this.draggable = false;
|
|
|
|
e.preventDefault();
|
|
|
|
this.toggleNow(this.$el, true);
|
|
|
|
this.animation = Animations$1['scale'];
|
|
removeClass(e.target, this.clsActive);
|
|
this.stack.splice(1, 0, this.index);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'itemshow',
|
|
|
|
handler: function(ref) {
|
|
var target = ref.target;
|
|
|
|
|
|
var i = index(target);
|
|
var ref$1 = this.getItem(i);
|
|
var caption = ref$1.caption;
|
|
|
|
css(this.caption, 'display', caption ? '' : 'none');
|
|
html(this.caption, caption);
|
|
|
|
for (var j = 0; j <= this.preload; j++) {
|
|
this.loadItem(this.getIndex(i + j));
|
|
this.loadItem(this.getIndex(i - j));
|
|
}
|
|
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'itemshown',
|
|
|
|
handler: function() {
|
|
this.draggable = this.$props.draggable;
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: 'itemload',
|
|
|
|
handler: function(_, item) {
|
|
var this$1 = this;
|
|
|
|
|
|
var source = item.source;
|
|
var type = item.type;
|
|
var alt = item.alt;
|
|
|
|
this.setItem(item, '<span uk-spinner></span>');
|
|
|
|
if (!source) {
|
|
return;
|
|
}
|
|
|
|
var matches;
|
|
|
|
// Image
|
|
if (type === 'image' || source.match(/\.(jp(e)?g|png|gif|svg|webp)($|\?)/i)) {
|
|
|
|
getImage(source).then(
|
|
function (img) { return this$1.setItem(item, ("<img width=\"" + (img.width) + "\" height=\"" + (img.height) + "\" src=\"" + source + "\" alt=\"" + (alt ? alt : '') + "\">")); },
|
|
function () { return this$1.setError(item); }
|
|
);
|
|
|
|
// Video
|
|
} else if (type === 'video' || source.match(/\.(mp4|webm|ogv)($|\?)/i)) {
|
|
|
|
var video = $(("<video controls playsinline" + (item.poster ? (" poster=\"" + (item.poster) + "\"") : '') + " uk-video=\"" + (this.videoAutoplay) + "\"></video>"));
|
|
attr(video, 'src', source);
|
|
|
|
once(video, 'error loadedmetadata', function (type) {
|
|
if (type === 'error') {
|
|
this$1.setError(item);
|
|
} else {
|
|
attr(video, {width: video.videoWidth, height: video.videoHeight});
|
|
this$1.setItem(item, video);
|
|
}
|
|
});
|
|
|
|
// Iframe
|
|
} else if (type === 'iframe' || source.match(/\.(html|php)($|\?)/i)) {
|
|
|
|
this.setItem(item, ("<iframe class=\"uk-lightbox-iframe\" src=\"" + source + "\" frameborder=\"0\" allowfullscreen></iframe>"));
|
|
|
|
// YouTube
|
|
} else if ((matches = source.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/watch\?v=([^&\s]+)/) || source.match(/()youtu\.be\/(.*)/))) {
|
|
|
|
var id = matches[2];
|
|
var setIframe = function (width, height) {
|
|
if ( width === void 0 ) width = 640;
|
|
if ( height === void 0 ) height = 450;
|
|
|
|
return this$1.setItem(item, getIframe(("https://www.youtube" + (matches[1] || '') + ".com/embed/" + id), width, height, this$1.videoAutoplay));
|
|
};
|
|
|
|
getImage(("https://img.youtube.com/vi/" + id + "/maxresdefault.jpg")).then(
|
|
function (ref) {
|
|
var width = ref.width;
|
|
var height = ref.height;
|
|
|
|
// YouTube default 404 thumb, fall back to low resolution
|
|
if (width === 120 && height === 90) {
|
|
getImage(("https://img.youtube.com/vi/" + id + "/0.jpg")).then(
|
|
function (ref) {
|
|
var width = ref.width;
|
|
var height = ref.height;
|
|
|
|
return setIframe(width, height);
|
|
},
|
|
setIframe
|
|
);
|
|
} else {
|
|
setIframe(width, height);
|
|
}
|
|
},
|
|
setIframe
|
|
);
|
|
|
|
// Vimeo
|
|
} else if ((matches = source.match(/(\/\/.*?)vimeo\.[a-z]+\/([0-9]+).*?/))) {
|
|
|
|
ajax(("https://vimeo.com/api/oembed.json?maxwidth=1920&url=" + (encodeURI(source))), {responseType: 'json', withCredentials: false})
|
|
.then(
|
|
function (ref) {
|
|
var ref_response = ref.response;
|
|
var height = ref_response.height;
|
|
var width = ref_response.width;
|
|
|
|
return this$1.setItem(item, getIframe(("https://player.vimeo.com/video/" + (matches[2])), width, height, this$1.videoAutoplay));
|
|
},
|
|
function () { return this$1.setError(item); }
|
|
);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
loadItem: function(index) {
|
|
if ( index === void 0 ) index = this.index;
|
|
|
|
|
|
var item = this.getItem(index);
|
|
|
|
if (item.content) {
|
|
return;
|
|
}
|
|
|
|
trigger(this.$el, 'itemload', [item]);
|
|
},
|
|
|
|
getItem: function(index) {
|
|
if ( index === void 0 ) index = this.index;
|
|
|
|
return this.items[index] || {};
|
|
},
|
|
|
|
setItem: function(item, content) {
|
|
assign(item, {content: content});
|
|
var el = html(this.slides[this.items.indexOf(item)], content);
|
|
trigger(this.$el, 'itemloaded', [this, el]);
|
|
this.$update(el);
|
|
},
|
|
|
|
setError: function(item) {
|
|
this.setItem(item, '<span uk-icon="icon: bolt; ratio: 2"></span>');
|
|
},
|
|
|
|
showControls: function() {
|
|
|
|
clearTimeout(this.controlsTimer);
|
|
this.controlsTimer = setTimeout(this.hideControls, this.delayControls);
|
|
|
|
addClass(this.$el, 'uk-active', 'uk-transition-active');
|
|
|
|
},
|
|
|
|
hideControls: function() {
|
|
removeClass(this.$el, 'uk-active', 'uk-transition-active');
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function getIframe(src, width, height, autoplay) {
|
|
return ("<iframe src=\"" + src + "\" width=\"" + width + "\" height=\"" + height + "\" style=\"max-width: 100%; box-sizing: border-box;\" frameborder=\"0\" allowfullscreen uk-video=\"autoplay: " + autoplay + "\" uk-responsive></iframe>");
|
|
}
|
|
|
|
var Lightbox = {
|
|
|
|
install: install$2,
|
|
|
|
props: {toggle: String},
|
|
|
|
data: {toggle: 'a'},
|
|
|
|
computed: {
|
|
|
|
toggles: {
|
|
|
|
get: function(ref, $el) {
|
|
var toggle = ref.toggle;
|
|
|
|
return $$(toggle, $el);
|
|
},
|
|
|
|
watch: function() {
|
|
this.hide();
|
|
}
|
|
|
|
},
|
|
|
|
items: function() {
|
|
return uniqueBy(this.toggles.map(toItem), 'source');
|
|
}
|
|
|
|
},
|
|
|
|
disconnected: function() {
|
|
this.hide();
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'click',
|
|
|
|
delegate: function() {
|
|
return ((this.toggle) + ":not(.uk-disabled)");
|
|
},
|
|
|
|
handler: function(e) {
|
|
e.preventDefault();
|
|
var src = data(e.current, 'href');
|
|
this.show(findIndex(this.items, function (ref) {
|
|
var source = ref.source;
|
|
|
|
return source === src;
|
|
}));
|
|
}
|
|
|
|
}
|
|
|
|
],
|
|
|
|
methods: {
|
|
|
|
show: function(index) {
|
|
var this$1 = this;
|
|
|
|
|
|
this.panel = this.panel || this.$create('lightboxPanel', assign({}, this.$props, {items: this.items}));
|
|
|
|
on(this.panel.$el, 'hidden', function () { return this$1.panel = false; });
|
|
|
|
return this.panel.show(index);
|
|
|
|
},
|
|
|
|
hide: function() {
|
|
|
|
return this.panel && this.panel.hide();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function install$2(UIkit, Lightbox) {
|
|
|
|
if (!UIkit.lightboxPanel) {
|
|
UIkit.component('lightboxPanel', lightboxPanel);
|
|
}
|
|
|
|
assign(
|
|
Lightbox.props,
|
|
UIkit.component('lightboxPanel').options.props
|
|
);
|
|
|
|
}
|
|
|
|
function toItem(el) {
|
|
return ['href', 'caption', 'type', 'poster', 'alt'].reduce(function (obj, attr) {
|
|
obj[attr === 'href' ? 'source' : attr] = data(el, attr);
|
|
return obj;
|
|
}, {});
|
|
}
|
|
|
|
var obj;
|
|
|
|
var containers = {};
|
|
|
|
var Notification = {
|
|
|
|
functional: true,
|
|
|
|
args: ['message', 'status'],
|
|
|
|
data: {
|
|
message: '',
|
|
status: '',
|
|
timeout: 5000,
|
|
group: null,
|
|
pos: 'top-center',
|
|
clsClose: 'uk-notification-close',
|
|
clsMsg: 'uk-notification-message'
|
|
},
|
|
|
|
install: install$3,
|
|
|
|
computed: {
|
|
|
|
marginProp: function(ref) {
|
|
var pos = ref.pos;
|
|
|
|
return ("margin" + (startsWith(pos, 'top') ? 'Top' : 'Bottom'));
|
|
},
|
|
|
|
startProps: function() {
|
|
var obj;
|
|
|
|
return ( obj = {opacity: 0}, obj[this.marginProp] = -this.$el.offsetHeight, obj );
|
|
}
|
|
|
|
},
|
|
|
|
created: function() {
|
|
|
|
if (!containers[this.pos]) {
|
|
containers[this.pos] = append(this.$container, ("<div class=\"uk-notification uk-notification-" + (this.pos) + "\"></div>"));
|
|
}
|
|
|
|
var container = css(containers[this.pos], 'display', 'block');
|
|
|
|
this.$mount(append(container,
|
|
("<div class=\"" + (this.clsMsg) + (this.status ? (" " + (this.clsMsg) + "-" + (this.status)) : '') + "\"> <a href=\"#\" class=\"" + (this.clsClose) + "\" data-uk-close></a> <div>" + (this.message) + "</div> </div>")
|
|
));
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
var this$1 = this;
|
|
var obj;
|
|
|
|
|
|
var margin = toFloat(css(this.$el, this.marginProp));
|
|
Transition.start(
|
|
css(this.$el, this.startProps),
|
|
( obj = {opacity: 1}, obj[this.marginProp] = margin, obj )
|
|
).then(function () {
|
|
if (this$1.timeout) {
|
|
this$1.timer = setTimeout(this$1.close, this$1.timeout);
|
|
}
|
|
});
|
|
|
|
},
|
|
|
|
events: ( obj = {
|
|
|
|
click: function(e) {
|
|
if (closest(e.target, 'a[href="#"],a[href=""]')) {
|
|
e.preventDefault();
|
|
}
|
|
this.close();
|
|
}
|
|
|
|
}, obj[pointerEnter] = function () {
|
|
if (this.timer) {
|
|
clearTimeout(this.timer);
|
|
}
|
|
}, obj[pointerLeave] = function () {
|
|
if (this.timeout) {
|
|
this.timer = setTimeout(this.close, this.timeout);
|
|
}
|
|
}, obj ),
|
|
|
|
methods: {
|
|
|
|
close: function(immediate) {
|
|
var this$1 = this;
|
|
|
|
|
|
var removeFn = function () {
|
|
|
|
trigger(this$1.$el, 'close', [this$1]);
|
|
remove(this$1.$el);
|
|
|
|
if (!containers[this$1.pos].children.length) {
|
|
css(containers[this$1.pos], 'display', 'none');
|
|
}
|
|
|
|
};
|
|
|
|
if (this.timer) {
|
|
clearTimeout(this.timer);
|
|
}
|
|
|
|
if (immediate) {
|
|
removeFn();
|
|
} else {
|
|
Transition.start(this.$el, this.startProps).then(removeFn);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function install$3(UIkit) {
|
|
UIkit.notification.closeAll = function (group, immediate) {
|
|
apply(document.body, function (el) {
|
|
var notification = UIkit.getComponent(el, 'notification');
|
|
if (notification && (!group || group === notification.group)) {
|
|
notification.close(immediate);
|
|
}
|
|
});
|
|
};
|
|
}
|
|
|
|
var props = ['x', 'y', 'bgx', 'bgy', 'rotate', 'scale', 'color', 'backgroundColor', 'borderColor', 'opacity', 'blur', 'hue', 'grayscale', 'invert', 'saturate', 'sepia', 'fopacity', 'stroke'];
|
|
|
|
var Parallax = {
|
|
|
|
mixins: [Media],
|
|
|
|
props: props.reduce(function (props, prop) {
|
|
props[prop] = 'list';
|
|
return props;
|
|
}, {}),
|
|
|
|
data: props.reduce(function (data, prop) {
|
|
data[prop] = undefined;
|
|
return data;
|
|
}, {}),
|
|
|
|
computed: {
|
|
|
|
props: function(properties, $el) {
|
|
var this$1 = this;
|
|
|
|
|
|
return props.reduce(function (props, prop) {
|
|
|
|
if (isUndefined(properties[prop])) {
|
|
return props;
|
|
}
|
|
|
|
var isColor = prop.match(/color/i);
|
|
var isCssProp = isColor || prop === 'opacity';
|
|
|
|
var pos, bgPos, diff;
|
|
var steps = properties[prop].slice(0);
|
|
|
|
if (isCssProp) {
|
|
css($el, prop, '');
|
|
}
|
|
|
|
if (steps.length < 2) {
|
|
steps.unshift((prop === 'scale'
|
|
? 1
|
|
: isCssProp
|
|
? css($el, prop)
|
|
: 0) || 0);
|
|
}
|
|
|
|
var unit = getUnit(steps);
|
|
|
|
if (isColor) {
|
|
|
|
var ref = $el.style;
|
|
var color = ref.color;
|
|
steps = steps.map(function (step) { return parseColor($el, step); });
|
|
$el.style.color = color;
|
|
|
|
} else if (startsWith(prop, 'bg')) {
|
|
|
|
var attr = prop === 'bgy' ? 'height' : 'width';
|
|
steps = steps.map(function (step) { return toPx(step, attr, this$1.$el); });
|
|
|
|
css($el, ("background-position-" + (prop[2])), '');
|
|
bgPos = css($el, 'backgroundPosition').split(' ')[prop[2] === 'x' ? 0 : 1]; // IE 11 can't read background-position-[x|y]
|
|
|
|
if (this$1.covers) {
|
|
|
|
var min = Math.min.apply(Math, steps);
|
|
var max = Math.max.apply(Math, steps);
|
|
var down = steps.indexOf(min) < steps.indexOf(max);
|
|
|
|
diff = max - min;
|
|
|
|
steps = steps.map(function (step) { return step - (down ? min : max); });
|
|
pos = (down ? -diff : 0) + "px";
|
|
|
|
} else {
|
|
|
|
pos = bgPos;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
steps = steps.map(toFloat);
|
|
|
|
}
|
|
|
|
if (prop === 'stroke') {
|
|
|
|
if (!steps.some(function (step) { return step; })) {
|
|
return props;
|
|
}
|
|
|
|
var length = getMaxPathLength(this$1.$el);
|
|
css($el, 'strokeDasharray', length);
|
|
|
|
if (unit === '%') {
|
|
steps = steps.map(function (step) { return step * length / 100; });
|
|
}
|
|
|
|
steps = steps.reverse();
|
|
|
|
prop = 'strokeDashoffset';
|
|
}
|
|
|
|
props[prop] = {steps: steps, unit: unit, pos: pos, bgPos: bgPos, diff: diff};
|
|
|
|
return props;
|
|
|
|
}, {});
|
|
|
|
},
|
|
|
|
bgProps: function() {
|
|
var this$1 = this;
|
|
|
|
return ['bgx', 'bgy'].filter(function (bg) { return bg in this$1.props; });
|
|
},
|
|
|
|
covers: function(_, $el) {
|
|
return covers($el);
|
|
}
|
|
|
|
},
|
|
|
|
disconnected: function() {
|
|
delete this._image;
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function(data) {
|
|
var this$1 = this;
|
|
|
|
|
|
data.active = this.matchMedia;
|
|
|
|
if (!data.active) {
|
|
return;
|
|
}
|
|
|
|
if (!data.image && this.covers && this.bgProps.length) {
|
|
var src = css(this.$el, 'backgroundImage').replace(/^none|url\(["']?(.+?)["']?\)$/, '$1');
|
|
|
|
if (src) {
|
|
var img = new Image();
|
|
img.src = src;
|
|
data.image = img;
|
|
|
|
if (!img.naturalWidth) {
|
|
img.onload = function () { return this$1.$emit(); };
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
var image = data.image;
|
|
|
|
if (!image || !image.naturalWidth) {
|
|
return;
|
|
}
|
|
|
|
var dimEl = {
|
|
width: this.$el.offsetWidth,
|
|
height: this.$el.offsetHeight
|
|
};
|
|
var dimImage = {
|
|
width: image.naturalWidth,
|
|
height: image.naturalHeight
|
|
};
|
|
|
|
var dim = Dimensions.cover(dimImage, dimEl);
|
|
|
|
this.bgProps.forEach(function (prop) {
|
|
|
|
var ref = this$1.props[prop];
|
|
var diff = ref.diff;
|
|
var bgPos = ref.bgPos;
|
|
var steps = ref.steps;
|
|
var attr = prop === 'bgy' ? 'height' : 'width';
|
|
var span = dim[attr] - dimEl[attr];
|
|
|
|
if (span < diff) {
|
|
dimEl[attr] = dim[attr] + diff - span;
|
|
} else if (span > diff) {
|
|
|
|
var posPercentage = dimEl[attr] / toPx(bgPos, attr, this$1.$el);
|
|
|
|
if (posPercentage) {
|
|
this$1.props[prop].steps = steps.map(function (step) { return step - (span - diff) / posPercentage; });
|
|
}
|
|
}
|
|
|
|
dim = Dimensions.cover(dimImage, dimEl);
|
|
});
|
|
|
|
data.dim = dim;
|
|
},
|
|
|
|
write: function(ref) {
|
|
var dim = ref.dim;
|
|
var active = ref.active;
|
|
|
|
|
|
if (!active) {
|
|
css(this.$el, {backgroundSize: '', backgroundRepeat: ''});
|
|
return;
|
|
}
|
|
|
|
dim && css(this.$el, {
|
|
backgroundSize: ((dim.width) + "px " + (dim.height) + "px"),
|
|
backgroundRepeat: 'no-repeat'
|
|
});
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
reset: function() {
|
|
var this$1 = this;
|
|
|
|
each(this.getCss(0), function (_, prop) { return css(this$1.$el, prop, ''); });
|
|
},
|
|
|
|
getCss: function(percent) {
|
|
|
|
var ref = this;
|
|
var props = ref.props;
|
|
return Object.keys(props).reduce(function (css, prop) {
|
|
|
|
var ref = props[prop];
|
|
var steps = ref.steps;
|
|
var unit = ref.unit;
|
|
var pos = ref.pos;
|
|
var value = getValue(steps, percent);
|
|
|
|
switch (prop) {
|
|
|
|
// transforms
|
|
case 'x':
|
|
case 'y': {
|
|
unit = unit || 'px';
|
|
css.transform += " translate" + (ucfirst(prop)) + "(" + (toFloat(value).toFixed(unit === 'px' ? 0 : 2)) + unit + ")";
|
|
break;
|
|
}
|
|
case 'rotate':
|
|
unit = unit || 'deg';
|
|
css.transform += " rotate(" + (value + unit) + ")";
|
|
break;
|
|
case 'scale':
|
|
css.transform += " scale(" + value + ")";
|
|
break;
|
|
|
|
// bg image
|
|
case 'bgy':
|
|
case 'bgx':
|
|
css[("background-position-" + (prop[2]))] = "calc(" + pos + " + " + value + "px)";
|
|
break;
|
|
|
|
// color
|
|
case 'color':
|
|
case 'backgroundColor':
|
|
case 'borderColor': {
|
|
|
|
var ref$1 = getStep(steps, percent);
|
|
var start = ref$1[0];
|
|
var end = ref$1[1];
|
|
var p = ref$1[2];
|
|
|
|
css[prop] = "rgba(" + (start.map(function (value, i) {
|
|
value = value + p * (end[i] - value);
|
|
return i === 3 ? toFloat(value) : parseInt(value, 10);
|
|
}).join(',')) + ")";
|
|
break;
|
|
}
|
|
// CSS Filter
|
|
case 'blur':
|
|
unit = unit || 'px';
|
|
css.filter += " blur(" + (value + unit) + ")";
|
|
break;
|
|
case 'hue':
|
|
unit = unit || 'deg';
|
|
css.filter += " hue-rotate(" + (value + unit) + ")";
|
|
break;
|
|
case 'fopacity':
|
|
unit = unit || '%';
|
|
css.filter += " opacity(" + (value + unit) + ")";
|
|
break;
|
|
case 'grayscale':
|
|
case 'invert':
|
|
case 'saturate':
|
|
case 'sepia':
|
|
unit = unit || '%';
|
|
css.filter += " " + prop + "(" + (value + unit) + ")";
|
|
break;
|
|
default:
|
|
css[prop] = value;
|
|
}
|
|
|
|
return css;
|
|
|
|
}, {transform: '', filter: ''});
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function parseColor(el, color) {
|
|
return css(css(el, 'color', color), 'color')
|
|
.split(/[(),]/g)
|
|
.slice(1, -1)
|
|
.concat(1)
|
|
.slice(0, 4)
|
|
.map(toFloat);
|
|
}
|
|
|
|
function getStep(steps, percent) {
|
|
var count = steps.length - 1;
|
|
var index = Math.min(Math.floor(count * percent), count - 1);
|
|
var step = steps.slice(index, index + 2);
|
|
|
|
step.push(percent === 1 ? 1 : percent % (1 / count) * count);
|
|
|
|
return step;
|
|
}
|
|
|
|
function getValue(steps, percent, digits) {
|
|
if ( digits === void 0 ) digits = 2;
|
|
|
|
var ref = getStep(steps, percent);
|
|
var start = ref[0];
|
|
var end = ref[1];
|
|
var p = ref[2];
|
|
return (isNumber(start)
|
|
? start + Math.abs(start - end) * p * (start < end ? 1 : -1)
|
|
: +end
|
|
).toFixed(digits);
|
|
}
|
|
|
|
function getUnit(steps) {
|
|
return steps.reduce(function (unit, step) { return isString(step) && step.replace(/-|\d/g, '').trim() || unit; }, '');
|
|
}
|
|
|
|
function covers(el) {
|
|
var ref = el.style;
|
|
var backgroundSize = ref.backgroundSize;
|
|
var covers = css(css(el, 'backgroundSize', ''), 'backgroundSize') === 'cover';
|
|
el.style.backgroundSize = backgroundSize;
|
|
return covers;
|
|
}
|
|
|
|
var Parallax$1 = {
|
|
|
|
mixins: [Parallax],
|
|
|
|
props: {
|
|
target: String,
|
|
viewport: Number,
|
|
easing: Number
|
|
},
|
|
|
|
data: {
|
|
target: false,
|
|
viewport: 1,
|
|
easing: 1
|
|
},
|
|
|
|
computed: {
|
|
|
|
target: function(ref, $el) {
|
|
var target = ref.target;
|
|
|
|
return getOffsetElement(target && query(target, $el) || $el);
|
|
}
|
|
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function(ref, type) {
|
|
var percent = ref.percent;
|
|
var active = ref.active;
|
|
|
|
|
|
if (type !== 'scroll') {
|
|
percent = false;
|
|
}
|
|
|
|
if (!active) {
|
|
return;
|
|
}
|
|
|
|
var prev = percent;
|
|
percent = ease$1(scrolledOver(this.target) / (this.viewport || 1), this.easing);
|
|
|
|
return {
|
|
percent: percent,
|
|
style: prev !== percent ? this.getCss(percent) : false
|
|
};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var style = ref.style;
|
|
var active = ref.active;
|
|
|
|
|
|
if (!active) {
|
|
this.reset();
|
|
return;
|
|
}
|
|
|
|
style && css(this.$el, style);
|
|
|
|
},
|
|
|
|
events: ['scroll', 'resize']
|
|
}
|
|
|
|
};
|
|
|
|
function ease$1(percent, easing) {
|
|
return clamp(percent * (1 - (easing - easing * percent)));
|
|
}
|
|
|
|
// SVG elements do not inherit from HTMLElement
|
|
function getOffsetElement(el) {
|
|
return el
|
|
? 'offsetTop' in el
|
|
? el
|
|
: getOffsetElement(el.parentNode)
|
|
: document.body;
|
|
}
|
|
|
|
var SliderReactive = {
|
|
|
|
update: {
|
|
|
|
write: function() {
|
|
|
|
if (this.stack.length || this.dragging) {
|
|
return;
|
|
}
|
|
|
|
var index = this.getValidIndex();
|
|
delete this.index;
|
|
removeClass(this.slides, this.clsActive, this.clsActivated);
|
|
this.show(index);
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function Transitioner$1 (prev, next, dir, ref) {
|
|
var center = ref.center;
|
|
var easing = ref.easing;
|
|
var list = ref.list;
|
|
|
|
|
|
var deferred = new Deferred();
|
|
|
|
var from = prev
|
|
? getLeft(prev, list, center)
|
|
: getLeft(next, list, center) + bounds(next).width * dir;
|
|
var to = next
|
|
? getLeft(next, list, center)
|
|
: from + bounds(prev).width * dir * (isRtl ? -1 : 1);
|
|
|
|
return {
|
|
|
|
dir: dir,
|
|
|
|
show: function(duration, percent, linear) {
|
|
if ( percent === void 0 ) percent = 0;
|
|
|
|
|
|
var timing = linear ? 'linear' : easing;
|
|
duration -= Math.round(duration * clamp(percent, -1, 1));
|
|
|
|
this.translate(percent);
|
|
|
|
prev && this.updateTranslates();
|
|
percent = prev ? percent : clamp(percent, 0, 1);
|
|
triggerUpdate$1(this.getItemIn(), 'itemin', {percent: percent, duration: duration, timing: timing, dir: dir});
|
|
prev && triggerUpdate$1(this.getItemIn(true), 'itemout', {percent: 1 - percent, duration: duration, timing: timing, dir: dir});
|
|
|
|
Transition
|
|
.start(list, {transform: translate(-to * (isRtl ? -1 : 1), 'px')}, duration, timing)
|
|
.then(deferred.resolve, noop);
|
|
|
|
return deferred.promise;
|
|
|
|
},
|
|
|
|
stop: function() {
|
|
return Transition.stop(list);
|
|
},
|
|
|
|
cancel: function() {
|
|
Transition.cancel(list);
|
|
},
|
|
|
|
reset: function() {
|
|
css(list, 'transform', '');
|
|
},
|
|
|
|
forward: function(duration, percent) {
|
|
if ( percent === void 0 ) percent = this.percent();
|
|
|
|
Transition.cancel(list);
|
|
return this.show(duration, percent, true);
|
|
},
|
|
|
|
translate: function(percent) {
|
|
|
|
var distance = this.getDistance() * dir * (isRtl ? -1 : 1);
|
|
|
|
css(list, 'transform', translate(clamp(
|
|
-to + (distance - distance * percent),
|
|
-getWidth(list),
|
|
bounds(list).width
|
|
) * (isRtl ? -1 : 1), 'px'));
|
|
|
|
this.updateTranslates();
|
|
|
|
if (prev) {
|
|
percent = clamp(percent, -1, 1);
|
|
triggerUpdate$1(this.getItemIn(), 'itemtranslatein', {percent: percent, dir: dir});
|
|
triggerUpdate$1(this.getItemIn(true), 'itemtranslateout', {percent: 1 - percent, dir: dir});
|
|
}
|
|
|
|
},
|
|
|
|
percent: function() {
|
|
return Math.abs((css(list, 'transform').split(',')[4] * (isRtl ? -1 : 1) + from) / (to - from));
|
|
},
|
|
|
|
getDistance: function() {
|
|
return Math.abs(to - from);
|
|
},
|
|
|
|
getItemIn: function(out) {
|
|
if ( out === void 0 ) out = false;
|
|
|
|
|
|
var actives = this.getActives();
|
|
var all = sortBy(slides(list), 'offsetLeft');
|
|
var i = index(all, actives[dir * (out ? -1 : 1) > 0 ? actives.length - 1 : 0]);
|
|
|
|
return ~i && all[i + (prev && !out ? dir : 0)];
|
|
|
|
},
|
|
|
|
getActives: function() {
|
|
|
|
var left = getLeft(prev || next, list, center);
|
|
|
|
return sortBy(slides(list).filter(function (slide) {
|
|
var slideLeft = getElLeft(slide, list);
|
|
return slideLeft >= left && slideLeft + bounds(slide).width <= bounds(list).width + left;
|
|
}), 'offsetLeft');
|
|
|
|
},
|
|
|
|
updateTranslates: function() {
|
|
|
|
var actives = this.getActives();
|
|
|
|
slides(list).forEach(function (slide) {
|
|
var isActive = includes(actives, slide);
|
|
|
|
triggerUpdate$1(slide, ("itemtranslate" + (isActive ? 'in' : 'out')), {
|
|
percent: isActive ? 1 : 0,
|
|
dir: slide.offsetLeft <= next.offsetLeft ? 1 : -1
|
|
});
|
|
});
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
function getLeft(el, list, center) {
|
|
|
|
var left = getElLeft(el, list);
|
|
|
|
return center
|
|
? left - centerEl(el, list)
|
|
: Math.min(left, getMax(list));
|
|
|
|
}
|
|
|
|
function getMax(list) {
|
|
return Math.max(0, getWidth(list) - bounds(list).width);
|
|
}
|
|
|
|
function getWidth(list) {
|
|
return slides(list).reduce(function (right, el) { return bounds(el).width + right; }, 0);
|
|
}
|
|
|
|
function getMaxWidth(list) {
|
|
return slides(list).reduce(function (right, el) { return Math.max(right, bounds(el).width); }, 0);
|
|
}
|
|
|
|
function centerEl(el, list) {
|
|
return bounds(list).width / 2 - bounds(el).width / 2;
|
|
}
|
|
|
|
function getElLeft(el, list) {
|
|
return (position(el).left + (isRtl ? bounds(el).width - bounds(list).width : 0)) * (isRtl ? -1 : 1);
|
|
}
|
|
|
|
function bounds(el) {
|
|
return el.getBoundingClientRect();
|
|
}
|
|
|
|
function triggerUpdate$1(el, type, data) {
|
|
trigger(el, createEvent(type, false, false, data));
|
|
}
|
|
|
|
function slides(list) {
|
|
return toNodes(list.children);
|
|
}
|
|
|
|
var Slider$1 = {
|
|
|
|
mixins: [Class, Slider, SliderReactive],
|
|
|
|
props: {
|
|
center: Boolean,
|
|
sets: Boolean
|
|
},
|
|
|
|
data: {
|
|
center: false,
|
|
sets: false,
|
|
attrItem: 'uk-slider-item',
|
|
selList: '.uk-slider-items',
|
|
selNav: '.uk-slider-nav',
|
|
clsContainer: 'uk-slider-container',
|
|
Transitioner: Transitioner$1
|
|
},
|
|
|
|
computed: {
|
|
|
|
avgWidth: function() {
|
|
return getWidth(this.list) / this.length;
|
|
},
|
|
|
|
finite: function(ref) {
|
|
var finite = ref.finite;
|
|
|
|
return finite || getWidth(this.list) < bounds(this.list).width + getMaxWidth(this.list) + this.center;
|
|
},
|
|
|
|
maxIndex: function() {
|
|
|
|
if (!this.finite || this.center && !this.sets) {
|
|
return this.length - 1;
|
|
}
|
|
|
|
if (this.center) {
|
|
return this.sets[this.sets.length - 1];
|
|
}
|
|
|
|
css(this.slides, 'order', '');
|
|
|
|
var max = getMax(this.list);
|
|
var i = this.length;
|
|
|
|
while (i--) {
|
|
if (getElLeft(this.list.children[i], this.list) < max) {
|
|
return Math.min(i + 1, this.length - 1);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
},
|
|
|
|
sets: function(ref) {
|
|
var this$1 = this;
|
|
var sets = ref.sets;
|
|
|
|
|
|
var width = bounds(this.list).width / (this.center ? 2 : 1);
|
|
|
|
var left = 0;
|
|
var leftCenter = width;
|
|
var slideLeft = 0;
|
|
|
|
sets = sets && this.slides.reduce(function (sets, slide, i) {
|
|
|
|
var ref = bounds(slide);
|
|
var slideWidth = ref.width;
|
|
var slideRight = slideLeft + slideWidth;
|
|
|
|
if (slideRight > left) {
|
|
|
|
if (!this$1.center && i > this$1.maxIndex) {
|
|
i = this$1.maxIndex;
|
|
}
|
|
|
|
if (!includes(sets, i)) {
|
|
|
|
var cmp = this$1.slides[i + 1];
|
|
if (this$1.center && cmp && slideWidth < leftCenter - bounds(cmp).width / 2) {
|
|
leftCenter -= slideWidth;
|
|
} else {
|
|
leftCenter = width;
|
|
sets.push(i);
|
|
left = slideLeft + width + (this$1.center ? slideWidth / 2 : 0);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
slideLeft += slideWidth;
|
|
|
|
return sets;
|
|
|
|
}, []);
|
|
|
|
return !isEmpty(sets) && sets;
|
|
|
|
},
|
|
|
|
transitionOptions: function() {
|
|
return {
|
|
center: this.center,
|
|
list: this.list
|
|
};
|
|
}
|
|
|
|
},
|
|
|
|
connected: function() {
|
|
toggleClass(this.$el, this.clsContainer, !$(("." + (this.clsContainer)), this.$el));
|
|
},
|
|
|
|
update: {
|
|
|
|
write: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
$$(("[" + (this.attrItem) + "],[data-" + (this.attrItem) + "]"), this.$el).forEach(function (el) {
|
|
var index = data(el, this$1.attrItem);
|
|
this$1.maxIndex && toggleClass(el, 'uk-hidden', isNumeric(index) && (this$1.sets && !includes(this$1.sets, toFloat(index)) || index > this$1.maxIndex));
|
|
});
|
|
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
},
|
|
|
|
events: {
|
|
|
|
beforeitemshow: function(e) {
|
|
|
|
if (!this.dragging && this.sets && this.stack.length < 2 && !includes(this.sets, this.index)) {
|
|
this.index = this.getValidIndex();
|
|
}
|
|
|
|
var diff = Math.abs(
|
|
this.index
|
|
- this.prevIndex
|
|
+ (this.dir > 0 && this.index < this.prevIndex || this.dir < 0 && this.index > this.prevIndex ? (this.maxIndex + 1) * this.dir : 0)
|
|
);
|
|
|
|
if (!this.dragging && diff > 1) {
|
|
|
|
for (var i = 0; i < diff; i++) {
|
|
this.stack.splice(1, 0, this.dir > 0 ? 'next' : 'previous');
|
|
}
|
|
|
|
e.preventDefault();
|
|
return;
|
|
}
|
|
|
|
this.duration = speedUp(this.avgWidth / this.velocity)
|
|
* (bounds(
|
|
this.dir < 0 || !this.slides[this.prevIndex]
|
|
? this.slides[this.index]
|
|
: this.slides[this.prevIndex]
|
|
).width / this.avgWidth);
|
|
|
|
this.reorder();
|
|
|
|
},
|
|
|
|
itemshow: function() {
|
|
!isUndefined(this.prevIndex) && addClass(this._getTransitioner().getItemIn(), this.clsActive);
|
|
},
|
|
|
|
itemshown: function() {
|
|
var this$1 = this;
|
|
|
|
var actives = this._getTransitioner(this.index).getActives();
|
|
this.slides.forEach(function (slide) { return toggleClass(slide, this$1.clsActive, includes(actives, slide)); });
|
|
(!this.sets || includes(this.sets, toFloat(this.index))) && this.slides.forEach(function (slide) { return toggleClass(slide, this$1.clsActivated, includes(actives, slide)); });
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
reorder: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
css(this.slides, 'order', '');
|
|
|
|
if (this.finite) {
|
|
return;
|
|
}
|
|
|
|
var index = this.dir > 0 && this.slides[this.prevIndex] ? this.prevIndex : this.index;
|
|
|
|
this.slides.forEach(function (slide, i) { return css(slide, 'order', this$1.dir > 0 && i < index
|
|
? 1
|
|
: this$1.dir < 0 && i >= this$1.index
|
|
? -1
|
|
: ''
|
|
); }
|
|
);
|
|
|
|
if (!this.center) {
|
|
return;
|
|
}
|
|
|
|
var next = this.slides[index];
|
|
var width = bounds(this.list).width / 2 - bounds(next).width / 2;
|
|
var j = 0;
|
|
|
|
while (width > 0) {
|
|
var slideIndex = this.getIndex(--j + index, index);
|
|
var slide = this.slides[slideIndex];
|
|
|
|
css(slide, 'order', slideIndex > index ? -2 : -1);
|
|
width -= bounds(slide).width;
|
|
}
|
|
|
|
},
|
|
|
|
getValidIndex: function(index, prevIndex) {
|
|
if ( index === void 0 ) index = this.index;
|
|
if ( prevIndex === void 0 ) prevIndex = this.prevIndex;
|
|
|
|
|
|
index = this.getIndex(index, prevIndex);
|
|
|
|
if (!this.sets) {
|
|
return index;
|
|
}
|
|
|
|
var prev;
|
|
|
|
do {
|
|
|
|
if (includes(this.sets, index)) {
|
|
return index;
|
|
}
|
|
|
|
prev = index;
|
|
index = this.getIndex(index + this.dir, prevIndex);
|
|
|
|
} while (index !== prev);
|
|
|
|
return index;
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var SliderParallax = {
|
|
|
|
mixins: [Parallax],
|
|
|
|
data: {
|
|
selItem: '!li'
|
|
},
|
|
|
|
computed: {
|
|
|
|
item: function(ref, $el) {
|
|
var selItem = ref.selItem;
|
|
|
|
return query(selItem, $el);
|
|
}
|
|
|
|
},
|
|
|
|
events: [
|
|
|
|
{
|
|
|
|
name: 'itemshown',
|
|
|
|
self: true,
|
|
|
|
el: function() {
|
|
return this.item;
|
|
},
|
|
|
|
handler: function() {
|
|
css(this.$el, this.getCss(.5));
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'itemin itemout',
|
|
|
|
self: true,
|
|
|
|
el: function() {
|
|
return this.item;
|
|
},
|
|
|
|
handler: function(ref) {
|
|
var type = ref.type;
|
|
var ref_detail = ref.detail;
|
|
var percent = ref_detail.percent;
|
|
var duration = ref_detail.duration;
|
|
var timing = ref_detail.timing;
|
|
var dir = ref_detail.dir;
|
|
|
|
|
|
Transition.cancel(this.$el);
|
|
css(this.$el, this.getCss(getCurrent(type, dir, percent)));
|
|
|
|
Transition.start(this.$el, this.getCss(isIn(type)
|
|
? .5
|
|
: dir > 0
|
|
? 1
|
|
: 0
|
|
), duration, timing).catch(noop);
|
|
|
|
}
|
|
},
|
|
|
|
{
|
|
name: 'transitioncanceled transitionend',
|
|
|
|
self: true,
|
|
|
|
el: function() {
|
|
return this.item;
|
|
},
|
|
|
|
handler: function() {
|
|
Transition.cancel(this.$el);
|
|
}
|
|
|
|
},
|
|
|
|
{
|
|
name: 'itemtranslatein itemtranslateout',
|
|
|
|
self: true,
|
|
|
|
el: function() {
|
|
return this.item;
|
|
},
|
|
|
|
handler: function(ref) {
|
|
var type = ref.type;
|
|
var ref_detail = ref.detail;
|
|
var percent = ref_detail.percent;
|
|
var dir = ref_detail.dir;
|
|
|
|
Transition.cancel(this.$el);
|
|
css(this.$el, this.getCss(getCurrent(type, dir, percent)));
|
|
}
|
|
}
|
|
|
|
]
|
|
|
|
};
|
|
|
|
function isIn(type) {
|
|
return endsWith(type, 'in');
|
|
}
|
|
|
|
function getCurrent(type, dir, percent) {
|
|
|
|
percent /= 2;
|
|
|
|
return !isIn(type)
|
|
? dir < 0
|
|
? percent
|
|
: 1 - percent
|
|
: dir < 0
|
|
? 1 - percent
|
|
: percent;
|
|
}
|
|
|
|
var Animations$2 = assign({}, Animations, {
|
|
|
|
fade: {
|
|
|
|
show: function() {
|
|
return [
|
|
{opacity: 0, zIndex: 0},
|
|
{zIndex: -1}
|
|
];
|
|
},
|
|
|
|
percent: function(current) {
|
|
return 1 - css(current, 'opacity');
|
|
},
|
|
|
|
translate: function(percent) {
|
|
return [
|
|
{opacity: 1 - percent, zIndex: 0},
|
|
{zIndex: -1}
|
|
];
|
|
}
|
|
|
|
},
|
|
|
|
scale: {
|
|
|
|
show: function() {
|
|
return [
|
|
{opacity: 0, transform: scale3d(1 + .5), zIndex: 0},
|
|
{zIndex: -1}
|
|
];
|
|
},
|
|
|
|
percent: function(current) {
|
|
return 1 - css(current, 'opacity');
|
|
},
|
|
|
|
translate: function(percent) {
|
|
return [
|
|
{opacity: 1 - percent, transform: scale3d(1 + .5 * percent), zIndex: 0},
|
|
{zIndex: -1}
|
|
];
|
|
}
|
|
|
|
},
|
|
|
|
pull: {
|
|
|
|
show: function(dir) {
|
|
return dir < 0
|
|
? [
|
|
{transform: translate(30), zIndex: -1},
|
|
{transform: translate(), zIndex: 0}
|
|
]
|
|
: [
|
|
{transform: translate(-100), zIndex: 0},
|
|
{transform: translate(), zIndex: -1}
|
|
];
|
|
},
|
|
|
|
percent: function(current, next, dir) {
|
|
return dir < 0
|
|
? 1 - translated(next)
|
|
: translated(current);
|
|
},
|
|
|
|
translate: function(percent, dir) {
|
|
return dir < 0
|
|
? [
|
|
{transform: translate(30 * percent), zIndex: -1},
|
|
{transform: translate(-100 * (1 - percent)), zIndex: 0}
|
|
]
|
|
: [
|
|
{transform: translate(-percent * 100), zIndex: 0},
|
|
{transform: translate(30 * (1 - percent)), zIndex: -1}
|
|
];
|
|
}
|
|
|
|
},
|
|
|
|
push: {
|
|
|
|
show: function(dir) {
|
|
return dir < 0
|
|
? [
|
|
{transform: translate(100), zIndex: 0},
|
|
{transform: translate(), zIndex: -1}
|
|
]
|
|
: [
|
|
{transform: translate(-30), zIndex: -1},
|
|
{transform: translate(), zIndex: 0}
|
|
];
|
|
},
|
|
|
|
percent: function(current, next, dir) {
|
|
return dir > 0
|
|
? 1 - translated(next)
|
|
: translated(current);
|
|
},
|
|
|
|
translate: function(percent, dir) {
|
|
return dir < 0
|
|
? [
|
|
{transform: translate(percent * 100), zIndex: 0},
|
|
{transform: translate(-30 * (1 - percent)), zIndex: -1}
|
|
]
|
|
: [
|
|
{transform: translate(-30 * percent), zIndex: -1},
|
|
{transform: translate(100 * (1 - percent)), zIndex: 0}
|
|
];
|
|
}
|
|
|
|
}
|
|
|
|
});
|
|
|
|
var Slideshow$1 = {
|
|
|
|
mixins: [Class, Slideshow, SliderReactive],
|
|
|
|
props: {
|
|
ratio: String,
|
|
minHeight: Number,
|
|
maxHeight: Number
|
|
},
|
|
|
|
data: {
|
|
ratio: '16:9',
|
|
minHeight: false,
|
|
maxHeight: false,
|
|
selList: '.uk-slideshow-items',
|
|
attrItem: 'uk-slideshow-item',
|
|
selNav: '.uk-slideshow-nav',
|
|
Animations: Animations$2
|
|
},
|
|
|
|
update: {
|
|
|
|
read: function() {
|
|
|
|
var ref = this.ratio.split(':').map(Number);
|
|
var width = ref[0];
|
|
var height = ref[1];
|
|
|
|
height = height * this.list.offsetWidth / width || 0;
|
|
|
|
if (this.minHeight) {
|
|
height = Math.max(this.minHeight, height);
|
|
}
|
|
|
|
if (this.maxHeight) {
|
|
height = Math.min(this.maxHeight, height);
|
|
}
|
|
|
|
return {height: height - boxModelAdjust(this.list, 'content-box')};
|
|
},
|
|
|
|
write: function(ref) {
|
|
var height = ref.height;
|
|
|
|
css(this.list, 'minHeight', height);
|
|
},
|
|
|
|
events: ['resize']
|
|
|
|
}
|
|
|
|
};
|
|
|
|
var Sortable = {
|
|
|
|
mixins: [Class, Animate],
|
|
|
|
props: {
|
|
group: String,
|
|
threshold: Number,
|
|
clsItem: String,
|
|
clsPlaceholder: String,
|
|
clsDrag: String,
|
|
clsDragState: String,
|
|
clsBase: String,
|
|
clsNoDrag: String,
|
|
clsEmpty: String,
|
|
clsCustom: String,
|
|
handle: String
|
|
},
|
|
|
|
data: {
|
|
group: false,
|
|
threshold: 5,
|
|
clsItem: 'uk-sortable-item',
|
|
clsPlaceholder: 'uk-sortable-placeholder',
|
|
clsDrag: 'uk-sortable-drag',
|
|
clsDragState: 'uk-drag',
|
|
clsBase: 'uk-sortable',
|
|
clsNoDrag: 'uk-sortable-nodrag',
|
|
clsEmpty: 'uk-sortable-empty',
|
|
clsCustom: '',
|
|
handle: false
|
|
},
|
|
|
|
created: function() {
|
|
var this$1 = this;
|
|
|
|
['init', 'start', 'move', 'end'].forEach(function (key) {
|
|
var fn = this$1[key];
|
|
this$1[key] = function (e) {
|
|
this$1.scrollY = window.pageYOffset;
|
|
var ref = getEventPos(e, 'page');
|
|
var x = ref.x;
|
|
var y = ref.y;
|
|
this$1.pos = {x: x, y: y};
|
|
|
|
fn(e);
|
|
};
|
|
});
|
|
},
|
|
|
|
events: {
|
|
|
|
name: pointerDown,
|
|
passive: false,
|
|
handler: 'init'
|
|
|
|
},
|
|
|
|
update: {
|
|
|
|
write: function() {
|
|
|
|
if (this.clsEmpty) {
|
|
toggleClass(this.$el, this.clsEmpty, isEmpty(this.$el.children));
|
|
}
|
|
|
|
css(this.handle ? $$(this.handle, this.$el) : this.$el.children, {touchAction: 'none', userSelect: 'none'});
|
|
|
|
if (!this.drag) {
|
|
return;
|
|
}
|
|
|
|
offset(this.drag, {top: this.pos.y + this.origin.top, left: this.pos.x + this.origin.left});
|
|
|
|
var ref = offset(this.drag);
|
|
var top = ref.top;
|
|
var offsetHeight = ref.height;
|
|
var bottom = top + offsetHeight;
|
|
var scroll;
|
|
|
|
if (top > 0 && top < this.scrollY) {
|
|
scroll = this.scrollY - 5;
|
|
} else if (bottom < height(document) && bottom > height(window) + this.scrollY) {
|
|
scroll = this.scrollY + 5;
|
|
}
|
|
|
|
scroll && setTimeout(function () { return scrollTop(window, scroll); }, 5);
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
init: function(e) {
|
|
|
|
var target = e.target;
|
|
var button = e.button;
|
|
var defaultPrevented = e.defaultPrevented;
|
|
var ref = toNodes(this.$el.children).filter(function (el) { return within(target, el); });
|
|
var placeholder = ref[0];
|
|
|
|
if (!placeholder
|
|
|| defaultPrevented
|
|
|| button > 0
|
|
|| isInput(target)
|
|
|| within(target, ("." + (this.clsNoDrag)))
|
|
|| this.handle && !within(target, this.handle)
|
|
) {
|
|
return;
|
|
}
|
|
|
|
e.preventDefault();
|
|
|
|
this.touched = [this];
|
|
this.placeholder = placeholder;
|
|
this.origin = assign({target: target, index: index(placeholder)}, this.pos);
|
|
|
|
on(document, pointerMove, this.move);
|
|
on(document, pointerUp, this.end);
|
|
on(window, 'scroll', this.scroll);
|
|
|
|
if (!this.threshold) {
|
|
this.start(e);
|
|
}
|
|
|
|
},
|
|
|
|
start: function(e) {
|
|
|
|
this.drag = append(this.$container, this.placeholder.outerHTML.replace(/^<li/i, '<div').replace(/li>$/i, 'div>'));
|
|
|
|
css(this.drag, assign({
|
|
boxSizing: 'border-box',
|
|
width: this.placeholder.offsetWidth,
|
|
height: this.placeholder.offsetHeight
|
|
}, css(this.placeholder, ['paddingLeft', 'paddingRight', 'paddingTop', 'paddingBottom'])));
|
|
attr(this.drag, 'uk-no-boot', '');
|
|
addClass(this.drag, this.clsDrag, this.clsCustom);
|
|
|
|
height(this.drag.firstElementChild, height(this.placeholder.firstElementChild));
|
|
|
|
var ref = offset(this.placeholder);
|
|
var left = ref.left;
|
|
var top = ref.top;
|
|
assign(this.origin, {left: left - this.pos.x, top: top - this.pos.y});
|
|
|
|
addClass(this.placeholder, this.clsPlaceholder);
|
|
addClass(this.$el.children, this.clsItem);
|
|
addClass(document.documentElement, this.clsDragState);
|
|
|
|
trigger(this.$el, 'start', [this, this.placeholder]);
|
|
|
|
this.move(e);
|
|
},
|
|
|
|
move: function(e) {
|
|
|
|
if (!this.drag) {
|
|
|
|
if (Math.abs(this.pos.x - this.origin.x) > this.threshold || Math.abs(this.pos.y - this.origin.y) > this.threshold) {
|
|
this.start(e);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
this.$emit();
|
|
|
|
var target = e.type === 'mousemove' ? e.target : document.elementFromPoint(this.pos.x - window.pageXOffset, this.pos.y - window.pageYOffset);
|
|
|
|
var sortable = this.getSortable(target);
|
|
var previous = this.getSortable(this.placeholder);
|
|
var move = sortable !== previous;
|
|
|
|
if (!sortable || within(target, this.placeholder) || move && (!sortable.group || sortable.group !== previous.group)) {
|
|
return;
|
|
}
|
|
|
|
target = sortable.$el === target.parentNode && target || toNodes(sortable.$el.children).filter(function (element) { return within(target, element); })[0];
|
|
|
|
if (move) {
|
|
previous.remove(this.placeholder);
|
|
} else if (!target) {
|
|
return;
|
|
}
|
|
|
|
sortable.insert(this.placeholder, target);
|
|
|
|
if (!includes(this.touched, sortable)) {
|
|
this.touched.push(sortable);
|
|
}
|
|
|
|
},
|
|
|
|
end: function(e) {
|
|
|
|
off(document, pointerMove, this.move);
|
|
off(document, pointerUp, this.end);
|
|
off(window, 'scroll', this.scroll);
|
|
|
|
if (!this.drag) {
|
|
if (e.type === 'touchend') {
|
|
e.target.click();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
var sortable = this.getSortable(this.placeholder);
|
|
|
|
if (this === sortable) {
|
|
if (this.origin.index !== index(this.placeholder)) {
|
|
trigger(this.$el, 'moved', [this, this.placeholder]);
|
|
}
|
|
} else {
|
|
trigger(sortable.$el, 'added', [sortable, this.placeholder]);
|
|
trigger(this.$el, 'removed', [this, this.placeholder]);
|
|
}
|
|
|
|
trigger(this.$el, 'stop', [this, this.placeholder]);
|
|
|
|
remove(this.drag);
|
|
this.drag = null;
|
|
|
|
var classes = this.touched.map(function (sortable) { return ((sortable.clsPlaceholder) + " " + (sortable.clsItem)); }).join(' ');
|
|
this.touched.forEach(function (sortable) { return removeClass(sortable.$el.children, classes); });
|
|
|
|
removeClass(document.documentElement, this.clsDragState);
|
|
|
|
},
|
|
|
|
scroll: function() {
|
|
var scroll = window.pageYOffset;
|
|
if (scroll !== this.scrollY) {
|
|
this.pos.y += scroll - this.scrollY;
|
|
this.scrollY = scroll;
|
|
this.$emit();
|
|
}
|
|
},
|
|
|
|
insert: function(element, target) {
|
|
var this$1 = this;
|
|
|
|
|
|
addClass(this.$el.children, this.clsItem);
|
|
|
|
var insert = function () {
|
|
|
|
if (target) {
|
|
|
|
if (!within(element, this$1.$el) || isPredecessor(element, target)) {
|
|
before(target, element);
|
|
} else {
|
|
after(target, element);
|
|
}
|
|
|
|
} else {
|
|
append(this$1.$el, element);
|
|
}
|
|
|
|
};
|
|
|
|
if (this.animation) {
|
|
this.animate(insert);
|
|
} else {
|
|
insert();
|
|
}
|
|
|
|
},
|
|
|
|
remove: function(element) {
|
|
|
|
if (!within(element, this.$el)) {
|
|
return;
|
|
}
|
|
|
|
css(this.handle ? $$(this.handle, element) : element, {touchAction: '', userSelect: ''});
|
|
|
|
if (this.animation) {
|
|
this.animate(function () { return remove(element); });
|
|
} else {
|
|
remove(element);
|
|
}
|
|
|
|
},
|
|
|
|
getSortable: function(element) {
|
|
return element && (this.$getComponent(element, 'sortable') || this.getSortable(element.parentNode));
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function isPredecessor(element, target) {
|
|
return element.parentNode === target.parentNode && index(element) > index(target);
|
|
}
|
|
|
|
var obj$1;
|
|
|
|
var actives = [];
|
|
|
|
var Tooltip = {
|
|
|
|
mixins: [Container, Togglable, Position],
|
|
|
|
args: 'title',
|
|
|
|
props: {
|
|
delay: Number,
|
|
title: String
|
|
},
|
|
|
|
data: {
|
|
pos: 'top',
|
|
title: '',
|
|
delay: 0,
|
|
animation: ['uk-animation-scale-up'],
|
|
duration: 100,
|
|
cls: 'uk-active',
|
|
clsPos: 'uk-tooltip'
|
|
},
|
|
|
|
beforeConnect: function() {
|
|
this._hasTitle = hasAttr(this.$el, 'title');
|
|
attr(this.$el, {title: '', 'aria-expanded': false});
|
|
},
|
|
|
|
disconnected: function() {
|
|
this.hide();
|
|
attr(this.$el, {title: this._hasTitle ? this.title : null, 'aria-expanded': null});
|
|
},
|
|
|
|
methods: {
|
|
|
|
show: function() {
|
|
var this$1 = this;
|
|
|
|
|
|
if (this.isActive()) {
|
|
return;
|
|
}
|
|
|
|
actives.forEach(function (active) { return active.hide(); });
|
|
actives.push(this);
|
|
|
|
this._unbind = on(document, pointerUp, function (e) { return !within(e.target, this$1.$el) && this$1.hide(); });
|
|
|
|
clearTimeout(this.showTimer);
|
|
this.showTimer = setTimeout(function () {
|
|
this$1._show();
|
|
this$1.hideTimer = setInterval(function () {
|
|
|
|
if (!isVisible(this$1.$el)) {
|
|
this$1.hide();
|
|
}
|
|
|
|
}, 150);
|
|
}, this.delay);
|
|
},
|
|
|
|
hide: function() {
|
|
|
|
if (!this.isActive() || matches(this.$el, 'input') && this.$el === document.activeElement) {
|
|
return;
|
|
}
|
|
|
|
actives.splice(actives.indexOf(this), 1);
|
|
|
|
clearTimeout(this.showTimer);
|
|
clearInterval(this.hideTimer);
|
|
attr(this.$el, 'aria-expanded', false);
|
|
this.toggleElement(this.tooltip, false);
|
|
this.tooltip && remove(this.tooltip);
|
|
this.tooltip = false;
|
|
this._unbind();
|
|
|
|
},
|
|
|
|
_show: function() {
|
|
|
|
this.tooltip = append(this.container,
|
|
("<div class=\"" + (this.clsPos) + "\" aria-expanded=\"true\" aria-hidden> <div class=\"" + (this.clsPos) + "-inner\">" + (this.title) + "</div> </div>")
|
|
);
|
|
|
|
this.positionAt(this.tooltip, this.$el);
|
|
|
|
this.origin = this.getAxis() === 'y'
|
|
? ((flipPosition(this.dir)) + "-" + (this.align))
|
|
: ((this.align) + "-" + (flipPosition(this.dir)));
|
|
|
|
this.toggleElement(this.tooltip, true);
|
|
|
|
},
|
|
|
|
isActive: function() {
|
|
return includes(actives, this);
|
|
}
|
|
|
|
},
|
|
|
|
events: ( obj$1 = {
|
|
|
|
focus: 'show',
|
|
blur: 'hide'
|
|
|
|
}, obj$1[(pointerEnter + " " + pointerLeave)] = function (e) {
|
|
if (isTouch(e)) {
|
|
return;
|
|
}
|
|
e.type === pointerEnter
|
|
? this.show()
|
|
: this.hide();
|
|
}, obj$1[pointerDown] = function (e) {
|
|
if (!isTouch(e)) {
|
|
return;
|
|
}
|
|
this.isActive()
|
|
? this.hide()
|
|
: this.show();
|
|
}, obj$1 )
|
|
|
|
};
|
|
|
|
var Upload = {
|
|
|
|
props: {
|
|
allow: String,
|
|
clsDragover: String,
|
|
concurrent: Number,
|
|
maxSize: Number,
|
|
method: String,
|
|
mime: String,
|
|
msgInvalidMime: String,
|
|
msgInvalidName: String,
|
|
msgInvalidSize: String,
|
|
multiple: Boolean,
|
|
name: String,
|
|
params: Object,
|
|
type: String,
|
|
url: String
|
|
},
|
|
|
|
data: {
|
|
allow: false,
|
|
clsDragover: 'uk-dragover',
|
|
concurrent: 1,
|
|
maxSize: 0,
|
|
method: 'POST',
|
|
mime: false,
|
|
msgInvalidMime: 'Invalid File Type: %s',
|
|
msgInvalidName: 'Invalid File Name: %s',
|
|
msgInvalidSize: 'Invalid File Size: %s Kilobytes Max',
|
|
multiple: false,
|
|
name: 'files[]',
|
|
params: {},
|
|
type: '',
|
|
url: '',
|
|
abort: noop,
|
|
beforeAll: noop,
|
|
beforeSend: noop,
|
|
complete: noop,
|
|
completeAll: noop,
|
|
error: noop,
|
|
fail: noop,
|
|
load: noop,
|
|
loadEnd: noop,
|
|
loadStart: noop,
|
|
progress: noop
|
|
},
|
|
|
|
events: {
|
|
|
|
change: function(e) {
|
|
|
|
if (!matches(e.target, 'input[type="file"]')) {
|
|
return;
|
|
}
|
|
|
|
e.preventDefault();
|
|
|
|
if (e.target.files) {
|
|
this.upload(e.target.files);
|
|
}
|
|
|
|
e.target.value = '';
|
|
},
|
|
|
|
drop: function(e) {
|
|
stop(e);
|
|
|
|
var transfer = e.dataTransfer;
|
|
|
|
if (!transfer || !transfer.files) {
|
|
return;
|
|
}
|
|
|
|
removeClass(this.$el, this.clsDragover);
|
|
|
|
this.upload(transfer.files);
|
|
},
|
|
|
|
dragenter: function(e) {
|
|
stop(e);
|
|
},
|
|
|
|
dragover: function(e) {
|
|
stop(e);
|
|
addClass(this.$el, this.clsDragover);
|
|
},
|
|
|
|
dragleave: function(e) {
|
|
stop(e);
|
|
removeClass(this.$el, this.clsDragover);
|
|
}
|
|
|
|
},
|
|
|
|
methods: {
|
|
|
|
upload: function(files) {
|
|
var this$1 = this;
|
|
|
|
|
|
if (!files.length) {
|
|
return;
|
|
}
|
|
|
|
trigger(this.$el, 'upload', [files]);
|
|
|
|
for (var i = 0; i < files.length; i++) {
|
|
|
|
if (this.maxSize && this.maxSize * 1000 < files[i].size) {
|
|
this.fail(this.msgInvalidSize.replace('%s', this.maxSize));
|
|
return;
|
|
}
|
|
|
|
if (this.allow && !match$1(this.allow, files[i].name)) {
|
|
this.fail(this.msgInvalidName.replace('%s', this.allow));
|
|
return;
|
|
}
|
|
|
|
if (this.mime && !match$1(this.mime, files[i].type)) {
|
|
this.fail(this.msgInvalidMime.replace('%s', this.mime));
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
if (!this.multiple) {
|
|
files = [files[0]];
|
|
}
|
|
|
|
this.beforeAll(this, files);
|
|
|
|
var chunks = chunk(files, this.concurrent);
|
|
var upload = function (files) {
|
|
|
|
var data = new FormData();
|
|
|
|
files.forEach(function (file) { return data.append(this$1.name, file); });
|
|
|
|
for (var key in this$1.params) {
|
|
data.append(key, this$1.params[key]);
|
|
}
|
|
|
|
ajax(this$1.url, {
|
|
data: data,
|
|
method: this$1.method,
|
|
responseType: this$1.type,
|
|
beforeSend: function (env) {
|
|
|
|
var xhr = env.xhr;
|
|
xhr.upload && on(xhr.upload, 'progress', this$1.progress);
|
|
['loadStart', 'load', 'loadEnd', 'abort'].forEach(function (type) { return on(xhr, type.toLowerCase(), this$1[type]); }
|
|
);
|
|
|
|
this$1.beforeSend(env);
|
|
|
|
}
|
|
}).then(
|
|
function (xhr) {
|
|
|
|
this$1.complete(xhr);
|
|
|
|
if (chunks.length) {
|
|
upload(chunks.shift());
|
|
} else {
|
|
this$1.completeAll(xhr);
|
|
}
|
|
|
|
},
|
|
function (e) { return this$1.error(e); }
|
|
);
|
|
|
|
};
|
|
|
|
upload(chunks.shift());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
function match$1(pattern, path) {
|
|
return path.match(new RegExp(("^" + (pattern.replace(/\//g, '\\/').replace(/\*\*/g, '(\\/[^\\/]+)*').replace(/\*/g, '[^\\/]+').replace(/((?!\\))\?/g, '$1.')) + "$"), 'i'));
|
|
}
|
|
|
|
function chunk(files, size) {
|
|
var chunks = [];
|
|
for (var i = 0; i < files.length; i += size) {
|
|
var chunk = [];
|
|
for (var j = 0; j < size; j++) {
|
|
chunk.push(files[i + j]);
|
|
}
|
|
chunks.push(chunk);
|
|
}
|
|
return chunks;
|
|
}
|
|
|
|
function stop(e) {
|
|
e.preventDefault();
|
|
e.stopPropagation();
|
|
}
|
|
|
|
UIkit.component('countdown', Countdown);
|
|
UIkit.component('filter', Filter);
|
|
UIkit.component('lightbox', Lightbox);
|
|
UIkit.component('lightboxPanel', lightboxPanel);
|
|
UIkit.component('notification', Notification);
|
|
UIkit.component('parallax', Parallax$1);
|
|
UIkit.component('slider', Slider$1);
|
|
UIkit.component('sliderParallax', SliderParallax);
|
|
UIkit.component('slideshow', Slideshow$1);
|
|
UIkit.component('slideshowParallax', SliderParallax);
|
|
UIkit.component('sortable', Sortable);
|
|
UIkit.component('tooltip', Tooltip);
|
|
UIkit.component('upload', Upload);
|
|
|
|
{
|
|
boot(UIkit);
|
|
}
|
|
|
|
return UIkit;
|
|
|
|
}));
|
|
});
|
|
|
|
/* src\common\Modal.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$f = "src\\common\\Modal.svelte";
|
|
|
|
function create_fragment$e(ctx) {
|
|
var div1, div0, current;
|
|
|
|
const default_slot_1 = ctx.$$slots.default;
|
|
const default_slot = create_slot(default_slot_1, ctx, null);
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
|
|
if (default_slot) default_slot.c();
|
|
|
|
attr(div0, "class", "uk-modal-dialog uk-modal-body");
|
|
attr(div0, "uk-overflow-auto", "");
|
|
add_location(div0, file$f, 27, 4, 490);
|
|
attr(div1, "uk-modal", "");
|
|
add_location(div1, file$f, 26, 0, 449);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
if (default_slot) default_slot.l(div0_nodes);
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
append(div1, div0);
|
|
|
|
if (default_slot) {
|
|
default_slot.m(div0, null);
|
|
}
|
|
|
|
ctx.div1_binding(div1);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (default_slot && default_slot.p && changed.$$scope) {
|
|
default_slot.p(get_slot_changes(default_slot_1, ctx, changed, null), get_slot_context(default_slot_1, ctx, null));
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(default_slot, local);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(default_slot, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
if (default_slot) default_slot.d(detaching);
|
|
ctx.div1_binding(null);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$e($$self, $$props, $$invalidate) {
|
|
let { isOpen = false, onClosed = () => {} } = $$props;
|
|
|
|
let ukModal;
|
|
let listenerAdded = false;
|
|
|
|
const writable_props = ['isOpen', 'onClosed'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Modal> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
let { $$slots = {}, $$scope } = $$props;
|
|
|
|
function div1_binding($$value) {
|
|
binding_callbacks[$$value ? 'unshift' : 'push'](() => {
|
|
$$invalidate('ukModal', ukModal = $$value);
|
|
});
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('isOpen' in $$props) $$invalidate('isOpen', isOpen = $$props.isOpen);
|
|
if ('onClosed' in $$props) $$invalidate('onClosed', onClosed = $$props.onClosed);
|
|
if ('$$scope' in $$props) $$invalidate('$$scope', $$scope = $$props.$$scope);
|
|
};
|
|
|
|
$$self.$$.update = ($$dirty = { ukModal: 1, listenerAdded: 1, onClosed: 1, isOpen: 1 }) => {
|
|
if ($$dirty.ukModal || $$dirty.listenerAdded || $$dirty.onClosed) { if(ukModal && !listenerAdded) {
|
|
$$invalidate('listenerAdded', listenerAdded = true);
|
|
ukModal.addEventListener("hide", onClosed);
|
|
} }
|
|
if ($$dirty.ukModal || $$dirty.isOpen) { {
|
|
if(ukModal) {
|
|
if(isOpen) {
|
|
uikit.modal(ukModal).show();
|
|
} else {
|
|
uikit.modal(ukModal).hide();
|
|
}
|
|
}
|
|
} }
|
|
};
|
|
|
|
return {
|
|
isOpen,
|
|
onClosed,
|
|
ukModal,
|
|
div1_binding,
|
|
$$slots,
|
|
$$scope
|
|
};
|
|
}
|
|
|
|
class Modal extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$e, create_fragment$e, safe_not_equal, ["isOpen", "onClosed"]);
|
|
}
|
|
|
|
get isOpen() {
|
|
throw new Error("<Modal>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set isOpen(value) {
|
|
throw new Error("<Modal>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onClosed() {
|
|
throw new Error("<Modal>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onClosed(value) {
|
|
throw new Error("<Modal>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\database\RecordView.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$g = "src\\database\\RecordView.svelte";
|
|
|
|
function get_each_context$4(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.index = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
function get_each_context_1$1(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.field = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (89:4) {#if !record.isSingle}
|
|
function create_if_block_3$1(ctx) {
|
|
var updating_text, t, updating_text_1, current;
|
|
|
|
function textbox0_text_binding(value) {
|
|
ctx.textbox0_text_binding.call(null, value);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox0_props = { label: "Collection Name" };
|
|
if (ctx.record.collectionName !== void 0) {
|
|
textbox0_props.text = ctx.record.collectionName;
|
|
}
|
|
var textbox0 = new Textbox({ props: textbox0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox0, 'text', textbox0_text_binding));
|
|
|
|
function textbox1_text_binding(value_1) {
|
|
ctx.textbox1_text_binding.call(null, value_1);
|
|
updating_text_1 = true;
|
|
add_flush_callback(() => updating_text_1 = false);
|
|
}
|
|
|
|
let textbox1_props = { label: "Shard Factor" };
|
|
if (ctx.record.allidsShardFactor !== void 0) {
|
|
textbox1_props.text = ctx.record.allidsShardFactor;
|
|
}
|
|
var textbox1 = new Textbox({ props: textbox1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox1, 'text', textbox1_text_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
textbox0.$$.fragment.c();
|
|
t = space();
|
|
textbox1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(textbox0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(textbox1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var textbox0_changes = {};
|
|
if (!updating_text && changed.record) {
|
|
textbox0_changes.text = ctx.record.collectionName;
|
|
}
|
|
textbox0.$set(textbox0_changes);
|
|
|
|
var textbox1_changes = {};
|
|
if (!updating_text_1 && changed.record) {
|
|
textbox1_changes.text = ctx.record.allidsShardFactor;
|
|
}
|
|
textbox1.$set(textbox1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(textbox0.$$.fragment, local);
|
|
|
|
transition_in(textbox1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(textbox0.$$.fragment, local);
|
|
transition_out(textbox1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(textbox0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(textbox1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (125:4) {:else}
|
|
function create_else_block_1(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("(no fields added)");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
p: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (98:4) {#if record.fields.length > 0}
|
|
function create_if_block_2$1(ctx) {
|
|
var table, thead, tr, th0, t1, th1, t3, th2, t5, th3, t6, tbody;
|
|
|
|
var each_value_1 = ctx.record.fields;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value_1.length; i += 1) {
|
|
each_blocks[i] = create_each_block_1$1(get_each_context_1$1(ctx, each_value_1, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
table = element("table");
|
|
thead = element("thead");
|
|
tr = element("tr");
|
|
th0 = element("th");
|
|
th0.textContent = "Name";
|
|
t1 = space();
|
|
th1 = element("th");
|
|
th1.textContent = "Type";
|
|
t3 = space();
|
|
th2 = element("th");
|
|
th2.textContent = "Options";
|
|
t5 = space();
|
|
th3 = element("th");
|
|
t6 = space();
|
|
tbody = element("tbody");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(th0, "class", "svelte-gq7l8x");
|
|
add_location(th0, file$g, 101, 16, 2903);
|
|
attr(th1, "class", "svelte-gq7l8x");
|
|
add_location(th1, file$g, 102, 16, 2934);
|
|
attr(th2, "class", "svelte-gq7l8x");
|
|
add_location(th2, file$g, 103, 16, 2965);
|
|
attr(th3, "class", "svelte-gq7l8x");
|
|
add_location(th3, file$g, 104, 16, 2999);
|
|
attr(tr, "class", "svelte-gq7l8x");
|
|
add_location(tr, file$g, 100, 12, 2881);
|
|
attr(thead, "class", "svelte-gq7l8x");
|
|
add_location(thead, file$g, 99, 8, 2860);
|
|
attr(tbody, "class", "svelte-gq7l8x");
|
|
add_location(tbody, file$g, 107, 8, 3055);
|
|
attr(table, "class", "fields-table uk-table svelte-gq7l8x");
|
|
add_location(table, file$g, 98, 4, 2813);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, table, anchor);
|
|
append(table, thead);
|
|
append(thead, tr);
|
|
append(tr, th0);
|
|
append(tr, t1);
|
|
append(tr, th1);
|
|
append(tr, t3);
|
|
append(tr, th2);
|
|
append(tr, t5);
|
|
append(tr, th3);
|
|
append(table, t6);
|
|
append(table, tbody);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.getIcon || changed.getTypeOptions || changed.record) {
|
|
each_value_1 = ctx.record.fields;
|
|
|
|
for (var i = 0; i < each_value_1.length; i += 1) {
|
|
const child_ctx = get_each_context_1$1(ctx, each_value_1, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block_1$1(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value_1.length;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(table);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (109:12) {#each record.fields as field}
|
|
function create_each_block_1$1(ctx) {
|
|
var tr, td0, div0, t0_value = ctx.field.label, t0, t1, div1, t2_value = ctx.field.name, t2, t3, td1, t4_value = ctx.field.type, t4, t5, td2, raw0_value = ctx.getTypeOptions(ctx.field.typeOptions), t6, td3, span0, raw1_value = getIcon("edit"), t7, span1, raw2_value = getIcon("trash"), t8, dispose;
|
|
|
|
function click_handler() {
|
|
return ctx.click_handler(ctx);
|
|
}
|
|
|
|
function click_handler_1() {
|
|
return ctx.click_handler_1(ctx);
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
tr = element("tr");
|
|
td0 = element("td");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
div1 = element("div");
|
|
t2 = text(t2_value);
|
|
t3 = space();
|
|
td1 = element("td");
|
|
t4 = text(t4_value);
|
|
t5 = space();
|
|
td2 = element("td");
|
|
t6 = space();
|
|
td3 = element("td");
|
|
span0 = element("span");
|
|
t7 = space();
|
|
span1 = element("span");
|
|
t8 = space();
|
|
add_location(div0, file$g, 111, 20, 3169);
|
|
set_style(div1, "font-size", "0.7em");
|
|
set_style(div1, "color", "var(--slate)");
|
|
add_location(div1, file$g, 112, 20, 3215);
|
|
attr(td0, "class", "svelte-gq7l8x");
|
|
add_location(td0, file$g, 110, 16, 3142);
|
|
attr(td1, "class", "svelte-gq7l8x");
|
|
add_location(td1, file$g, 114, 16, 3325);
|
|
attr(td2, "class", "svelte-gq7l8x");
|
|
add_location(td2, file$g, 115, 16, 3365);
|
|
attr(span0, "class", "edit-button svelte-gq7l8x");
|
|
add_location(span0, file$g, 117, 20, 3460);
|
|
attr(span1, "class", "edit-button svelte-gq7l8x");
|
|
add_location(span1, file$g, 118, 20, 3572);
|
|
attr(td3, "class", "svelte-gq7l8x");
|
|
add_location(td3, file$g, 116, 16, 3434);
|
|
attr(tr, "class", "svelte-gq7l8x");
|
|
add_location(tr, file$g, 109, 12, 3120);
|
|
|
|
dispose = [
|
|
listen(span0, "click", click_handler),
|
|
listen(span1, "click", click_handler_1)
|
|
];
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, tr, anchor);
|
|
append(tr, td0);
|
|
append(td0, div0);
|
|
append(div0, t0);
|
|
append(td0, t1);
|
|
append(td0, div1);
|
|
append(div1, t2);
|
|
append(tr, t3);
|
|
append(tr, td1);
|
|
append(td1, t4);
|
|
append(tr, t5);
|
|
append(tr, td2);
|
|
td2.innerHTML = raw0_value;
|
|
append(tr, t6);
|
|
append(tr, td3);
|
|
append(td3, span0);
|
|
span0.innerHTML = raw1_value;
|
|
append(td3, t7);
|
|
append(td3, span1);
|
|
span1.innerHTML = raw2_value;
|
|
append(tr, t8);
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.record) && t0_value !== (t0_value = ctx.field.label)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if ((changed.record) && t2_value !== (t2_value = ctx.field.name)) {
|
|
set_data(t2, t2_value);
|
|
}
|
|
|
|
if ((changed.record) && t4_value !== (t4_value = ctx.field.type)) {
|
|
set_data(t4, t4_value);
|
|
}
|
|
|
|
if ((changed.record) && raw0_value !== (raw0_value = ctx.getTypeOptions(ctx.field.typeOptions))) {
|
|
td2.innerHTML = raw0_value;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(tr);
|
|
}
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (129:4) {#if editingField}
|
|
function create_if_block_1$1(ctx) {
|
|
var updating_isOpen, current;
|
|
|
|
function modal_isOpen_binding(value) {
|
|
ctx.modal_isOpen_binding.call(null, value);
|
|
updating_isOpen = true;
|
|
add_flush_callback(() => updating_isOpen = false);
|
|
}
|
|
|
|
let modal_props = {
|
|
$$slots: { default: [create_default_slot$1] },
|
|
$$scope: { ctx }
|
|
};
|
|
if (ctx.editingField !== void 0) {
|
|
modal_props.isOpen = ctx.editingField;
|
|
}
|
|
var modal = new Modal({ props: modal_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(modal, 'isOpen', modal_isOpen_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
modal.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(modal, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var modal_changes = {};
|
|
if (changed.$$scope || changed.fieldToEdit || changed.onFinishedFieldEdit || changed.record || changed.$database) modal_changes.$$scope = { changed, ctx };
|
|
if (!updating_isOpen && changed.editingField) {
|
|
modal_changes.isOpen = ctx.editingField;
|
|
}
|
|
modal.$set(modal_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(modal.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(modal.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(modal, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (130:4) <Modal bind:isOpen={editingField}>
|
|
function create_default_slot$1(ctx) {
|
|
var current;
|
|
|
|
var fieldview = new FieldView({
|
|
props: {
|
|
field: ctx.fieldToEdit,
|
|
onFinished: ctx.onFinishedFieldEdit,
|
|
allFields: ctx.record.fields,
|
|
database: ctx.$database
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
fieldview.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(fieldview, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var fieldview_changes = {};
|
|
if (changed.fieldToEdit) fieldview_changes.field = ctx.fieldToEdit;
|
|
if (changed.onFinishedFieldEdit) fieldview_changes.onFinished = ctx.onFinishedFieldEdit;
|
|
if (changed.record) fieldview_changes.allFields = ctx.record.fields;
|
|
if (changed.$database) fieldview_changes.database = ctx.$database;
|
|
fieldview.$set(fieldview_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(fieldview.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(fieldview.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(fieldview, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (165:4) {:else}
|
|
function create_else_block$2(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("(no indexes added)");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (158:8) {#if index.filter}
|
|
function create_if_block$4(ctx) {
|
|
var div, span, t1, code, t2_value = ctx.index.filter, t2;
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
span = element("span");
|
|
span.textContent = "filter:";
|
|
t1 = space();
|
|
code = element("code");
|
|
t2 = text(t2_value);
|
|
attr(span, "class", "index-label svelte-gq7l8x");
|
|
add_location(span, file$g, 159, 12, 4932);
|
|
attr(code, "class", "index-mapfilter svelte-gq7l8x");
|
|
add_location(code, file$g, 160, 12, 4986);
|
|
attr(div, "class", "index-field-row svelte-gq7l8x");
|
|
add_location(div, file$g, 158, 8, 4889);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, span);
|
|
append(div, t1);
|
|
append(div, code);
|
|
append(code, t2);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.record) && t2_value !== (t2_value = ctx.index.filter)) {
|
|
set_data(t2, t2_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (142:4) {#each record.indexes as index}
|
|
function create_each_block$4(ctx) {
|
|
var div3, div0, t0_value = ctx.index.name, t0, t1, span0, raw_value = getIcon("edit"), t2, div1, span1, t4, span2, t5_value = ctx.getIndexAllowedRecords(ctx.index), t5, t6, span3, t8, span4, t9_value = ctx.index.indexType, t9, t10, div2, span5, t12, code, t13_value = ctx.index.map, t13, t14, t15, dispose;
|
|
|
|
function click_handler_2() {
|
|
return ctx.click_handler_2(ctx);
|
|
}
|
|
|
|
var if_block = (ctx.index.filter) && create_if_block$4(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
div3 = element("div");
|
|
div0 = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
span0 = element("span");
|
|
t2 = space();
|
|
div1 = element("div");
|
|
span1 = element("span");
|
|
span1.textContent = "records indexed:";
|
|
t4 = space();
|
|
span2 = element("span");
|
|
t5 = text(t5_value);
|
|
t6 = space();
|
|
span3 = element("span");
|
|
span3.textContent = "type:";
|
|
t8 = space();
|
|
span4 = element("span");
|
|
t9 = text(t9_value);
|
|
t10 = space();
|
|
div2 = element("div");
|
|
span5 = element("span");
|
|
span5.textContent = "map:";
|
|
t12 = space();
|
|
code = element("code");
|
|
t13 = text(t13_value);
|
|
t14 = space();
|
|
if (if_block) if_block.c();
|
|
t15 = space();
|
|
set_style(span0, "margin-left", "7px");
|
|
add_location(span0, file$g, 145, 12, 4271);
|
|
attr(div0, "class", "index-name svelte-gq7l8x");
|
|
add_location(div0, file$g, 143, 8, 4207);
|
|
attr(span1, "class", "index-label svelte-gq7l8x");
|
|
add_location(span1, file$g, 148, 12, 4435);
|
|
add_location(span2, file$g, 149, 12, 4500);
|
|
attr(span3, "class", "index-label svelte-gq7l8x");
|
|
set_style(span3, "margin-left", "15px");
|
|
add_location(span3, file$g, 150, 12, 4558);
|
|
add_location(span4, file$g, 151, 12, 4637);
|
|
attr(div1, "class", "index-field-row svelte-gq7l8x");
|
|
add_location(div1, file$g, 147, 8, 4392);
|
|
attr(span5, "class", "index-label svelte-gq7l8x");
|
|
add_location(span5, file$g, 154, 12, 4736);
|
|
attr(code, "class", "index-mapfilter svelte-gq7l8x");
|
|
add_location(code, file$g, 155, 12, 4787);
|
|
attr(div2, "class", "index-field-row svelte-gq7l8x");
|
|
add_location(div2, file$g, 153, 8, 4693);
|
|
attr(div3, "class", "index-container svelte-gq7l8x");
|
|
add_location(div3, file$g, 142, 4, 4168);
|
|
dispose = listen(span0, "click", click_handler_2);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div3, anchor);
|
|
append(div3, div0);
|
|
append(div0, t0);
|
|
append(div0, t1);
|
|
append(div0, span0);
|
|
span0.innerHTML = raw_value;
|
|
append(div3, t2);
|
|
append(div3, div1);
|
|
append(div1, span1);
|
|
append(div1, t4);
|
|
append(div1, span2);
|
|
append(span2, t5);
|
|
append(div1, t6);
|
|
append(div1, span3);
|
|
append(div1, t8);
|
|
append(div1, span4);
|
|
append(span4, t9);
|
|
append(div3, t10);
|
|
append(div3, div2);
|
|
append(div2, span5);
|
|
append(div2, t12);
|
|
append(div2, code);
|
|
append(code, t13);
|
|
append(div3, t14);
|
|
if (if_block) if_block.m(div3, null);
|
|
append(div3, t15);
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.record) && t0_value !== (t0_value = ctx.index.name)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if ((changed.getIndexAllowedRecords || changed.record) && t5_value !== (t5_value = ctx.getIndexAllowedRecords(ctx.index))) {
|
|
set_data(t5, t5_value);
|
|
}
|
|
|
|
if ((changed.record) && t9_value !== (t9_value = ctx.index.indexType)) {
|
|
set_data(t9, t9_value);
|
|
}
|
|
|
|
if ((changed.record) && t13_value !== (t13_value = ctx.index.map)) {
|
|
set_data(t13, t13_value);
|
|
}
|
|
|
|
if (ctx.index.filter) {
|
|
if (if_block) {
|
|
if_block.p(changed, ctx);
|
|
} else {
|
|
if_block = create_if_block$4(ctx);
|
|
if_block.c();
|
|
if_block.m(div3, t15);
|
|
}
|
|
} else if (if_block) {
|
|
if_block.d(1);
|
|
if_block = null;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div3);
|
|
}
|
|
|
|
if (if_block) if_block.d();
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$f(ctx) {
|
|
var div1, updating_text, t0, div0, t1_value = ctx.record.nodeKey(), t1, t2, t3, h40, t4, span, raw_value = getIcon("plus"), t5, t6, t7, h41, t9, current, dispose;
|
|
|
|
function textbox_text_binding(value) {
|
|
ctx.textbox_text_binding.call(null, value);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox_props = { label: "Name" };
|
|
if (ctx.record.name !== void 0) {
|
|
textbox_props.text = ctx.record.name;
|
|
}
|
|
var textbox = new Textbox({ props: textbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox, 'text', textbox_text_binding));
|
|
|
|
var if_block0 = (!ctx.record.isSingle) && create_if_block_3$1(ctx);
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.record.fields.length > 0) return create_if_block_2$1;
|
|
return create_else_block_1;
|
|
}
|
|
|
|
var current_block_type = select_block_type(ctx);
|
|
var if_block1 = current_block_type(ctx);
|
|
|
|
var if_block2 = (ctx.editingField) && create_if_block_1$1(ctx);
|
|
|
|
var each_value = ctx.record.indexes;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$4(get_each_context$4(ctx, each_value, i));
|
|
}
|
|
|
|
var each_1_else = null;
|
|
|
|
if (!each_value.length) {
|
|
each_1_else = create_else_block$2();
|
|
each_1_else.c();
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
textbox.$$.fragment.c();
|
|
t0 = space();
|
|
div0 = element("div");
|
|
t1 = text(t1_value);
|
|
t2 = space();
|
|
if (if_block0) if_block0.c();
|
|
t3 = space();
|
|
h40 = element("h4");
|
|
t4 = text("Fields ");
|
|
span = element("span");
|
|
t5 = space();
|
|
if_block1.c();
|
|
t6 = space();
|
|
if (if_block2) if_block2.c();
|
|
t7 = space();
|
|
h41 = element("h4");
|
|
h41.textContent = "Indexes";
|
|
t9 = space();
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
add_location(div0, file$g, 87, 4, 2430);
|
|
attr(span, "class", "add-field-button svelte-gq7l8x");
|
|
add_location(span, file$g, 94, 15, 2677);
|
|
add_location(h40, file$g, 93, 4, 2656);
|
|
add_location(h41, file$g, 137, 4, 4090);
|
|
attr(div1, "class", "root svelte-gq7l8x");
|
|
add_location(div1, file$g, 84, 0, 2350);
|
|
dispose = listen(span, "click", ctx.newField);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
mount_component(textbox, div1, null);
|
|
append(div1, t0);
|
|
append(div1, div0);
|
|
append(div0, t1);
|
|
append(div1, t2);
|
|
if (if_block0) if_block0.m(div1, null);
|
|
append(div1, t3);
|
|
append(div1, h40);
|
|
append(h40, t4);
|
|
append(h40, span);
|
|
span.innerHTML = raw_value;
|
|
append(div1, t5);
|
|
if_block1.m(div1, null);
|
|
append(div1, t6);
|
|
if (if_block2) if_block2.m(div1, null);
|
|
append(div1, t7);
|
|
append(div1, h41);
|
|
append(div1, t9);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
|
|
if (each_1_else) {
|
|
each_1_else.m(div1, null);
|
|
}
|
|
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var textbox_changes = {};
|
|
if (!updating_text && changed.record) {
|
|
textbox_changes.text = ctx.record.name;
|
|
}
|
|
textbox.$set(textbox_changes);
|
|
|
|
if ((!current || changed.record) && t1_value !== (t1_value = ctx.record.nodeKey())) {
|
|
set_data(t1, t1_value);
|
|
}
|
|
|
|
if (!ctx.record.isSingle) {
|
|
if (if_block0) {
|
|
if_block0.p(changed, ctx);
|
|
transition_in(if_block0, 1);
|
|
} else {
|
|
if_block0 = create_if_block_3$1(ctx);
|
|
if_block0.c();
|
|
transition_in(if_block0, 1);
|
|
if_block0.m(div1, t3);
|
|
}
|
|
} else if (if_block0) {
|
|
group_outros();
|
|
transition_out(if_block0, 1, 1, () => {
|
|
if_block0 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
|
|
if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block1) {
|
|
if_block1.p(changed, ctx);
|
|
} else {
|
|
if_block1.d(1);
|
|
if_block1 = current_block_type(ctx);
|
|
if (if_block1) {
|
|
if_block1.c();
|
|
if_block1.m(div1, t6);
|
|
}
|
|
}
|
|
|
|
if (ctx.editingField) {
|
|
if (if_block2) {
|
|
if_block2.p(changed, ctx);
|
|
transition_in(if_block2, 1);
|
|
} else {
|
|
if_block2 = create_if_block_1$1(ctx);
|
|
if_block2.c();
|
|
transition_in(if_block2, 1);
|
|
if_block2.m(div1, t7);
|
|
}
|
|
} else if (if_block2) {
|
|
group_outros();
|
|
transition_out(if_block2, 1, 1, () => {
|
|
if_block2 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
|
|
if (changed.record || changed.getIndexAllowedRecords || changed.getIcon) {
|
|
each_value = ctx.record.indexes;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$4(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$4(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
|
|
if (each_value.length) {
|
|
if (each_1_else) {
|
|
each_1_else.d(1);
|
|
each_1_else = null;
|
|
}
|
|
} else if (!each_1_else) {
|
|
each_1_else = create_else_block$2();
|
|
each_1_else.c();
|
|
each_1_else.m(div1, null);
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(textbox.$$.fragment, local);
|
|
|
|
transition_in(if_block0);
|
|
transition_in(if_block2);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(textbox.$$.fragment, local);
|
|
transition_out(if_block0);
|
|
transition_out(if_block2);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
destroy_component(textbox);
|
|
|
|
if (if_block0) if_block0.d();
|
|
if_block1.d();
|
|
if (if_block2) if_block2.d();
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
if (each_1_else) each_1_else.d();
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$f($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
let record;
|
|
let getIndexAllowedRecords;
|
|
let editingField = false;
|
|
let fieldToEdit;
|
|
let newField;
|
|
let editField;
|
|
let deleteField;
|
|
let onFinishedFieldEdit;
|
|
let editIndex;
|
|
|
|
database.subscribe($database => {
|
|
$$invalidate('record', record = $database.currentNode);
|
|
const flattened = hierarchy.getFlattenedHierarchy($database.hierarchy);
|
|
$$invalidate('getIndexAllowedRecords', getIndexAllowedRecords = index =>
|
|
chain(index.allowedRecordNodeIds, [
|
|
fp.filter(id => fp.some(n => n.nodeId === id)(flattened)),
|
|
fp.map(id => fp.find(n => n.nodeId === id)
|
|
(flattened).name),
|
|
fp.join(", ")
|
|
]));
|
|
|
|
$$invalidate('newField', newField = () => {
|
|
$$invalidate('fieldToEdit', fieldToEdit = templateApi($database.hierarchy).getNewField("string"));
|
|
$$invalidate('editingField', editingField = true);
|
|
});
|
|
|
|
$$invalidate('onFinishedFieldEdit', onFinishedFieldEdit = (field) => {
|
|
if(field) {
|
|
database.saveField(field);
|
|
}
|
|
$$invalidate('editingField', editingField = false);
|
|
});
|
|
|
|
$$invalidate('editField', editField = (field) => {
|
|
$$invalidate('fieldToEdit', fieldToEdit = field);
|
|
$$invalidate('editingField', editingField = true);
|
|
});
|
|
|
|
$$invalidate('deleteField', deleteField = (field) => {
|
|
database.deleteField(field);
|
|
});
|
|
|
|
$$invalidate('editIndex', editIndex = index => {
|
|
database.selectExistingNode(index.nodeId);
|
|
});
|
|
|
|
});
|
|
|
|
let getTypeOptionsValueText = value => {
|
|
if(value === Number.MAX_SAFE_INTEGER
|
|
|| value === Number.MIN_SAFE_INTEGER
|
|
|| new Date(value).getTime() === new Date(8640000000000000).getTime()
|
|
|| new Date(value).getTime() === new Date(-8640000000000000).getTime()) return "(any)";
|
|
|
|
if(value === null) return "(not set)";
|
|
return value;
|
|
};
|
|
|
|
let getTypeOptions = typeOptions =>
|
|
chain(typeOptions, [
|
|
fp.keys,
|
|
fp.map(k => `<span style="color:var(--slate)">${k}: </span>${getTypeOptionsValueText(typeOptions[k])}`),
|
|
fp.join("<br>")
|
|
]);
|
|
|
|
function textbox_text_binding(value) {
|
|
record.name = value;
|
|
$$invalidate('record', record);
|
|
}
|
|
|
|
function textbox0_text_binding(value) {
|
|
record.collectionName = value;
|
|
$$invalidate('record', record);
|
|
}
|
|
|
|
function textbox1_text_binding(value_1) {
|
|
record.allidsShardFactor = value_1;
|
|
$$invalidate('record', record);
|
|
}
|
|
|
|
function click_handler({ field }) {
|
|
return editField(field);
|
|
}
|
|
|
|
function click_handler_1({ field }) {
|
|
return deleteField(field);
|
|
}
|
|
|
|
function modal_isOpen_binding(value) {
|
|
editingField = value;
|
|
$$invalidate('editingField', editingField);
|
|
}
|
|
|
|
function click_handler_2({ index }) {
|
|
return editIndex(index);
|
|
}
|
|
|
|
return {
|
|
record,
|
|
getIndexAllowedRecords,
|
|
editingField,
|
|
fieldToEdit,
|
|
newField,
|
|
editField,
|
|
deleteField,
|
|
onFinishedFieldEdit,
|
|
editIndex,
|
|
getTypeOptions,
|
|
$database,
|
|
textbox_text_binding,
|
|
textbox0_text_binding,
|
|
textbox1_text_binding,
|
|
click_handler,
|
|
click_handler_1,
|
|
modal_isOpen_binding,
|
|
click_handler_2
|
|
};
|
|
}
|
|
|
|
class RecordView extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$f, create_fragment$f, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
/* src\common\CodeArea.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$h = "src\\common\\CodeArea.svelte";
|
|
|
|
function create_fragment$g(ctx) {
|
|
var div, t0, t1, textarea, dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
t0 = text(ctx.label);
|
|
t1 = space();
|
|
textarea = element("textarea");
|
|
add_location(div, file$h, 6, 0, 102);
|
|
attr(textarea, "class", "svelte-1ooq0hh");
|
|
add_location(textarea, file$h, 7, 0, 122);
|
|
dispose = listen(textarea, "input", ctx.textarea_input_handler);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, t0);
|
|
insert(target, t1, anchor);
|
|
insert(target, textarea, anchor);
|
|
|
|
textarea.value = ctx.text;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.label) {
|
|
set_data(t0, ctx.label);
|
|
}
|
|
|
|
if (changed.text) textarea.value = ctx.text;
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
detach(t1);
|
|
detach(textarea);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$g($$self, $$props, $$invalidate) {
|
|
// todo: use https://ace.c9.io
|
|
let { text = "", label = "" } = $$props;
|
|
|
|
const writable_props = ['text', 'label'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<CodeArea> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function textarea_input_handler() {
|
|
text = this.value;
|
|
$$invalidate('text', text);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('text' in $$props) $$invalidate('text', text = $$props.text);
|
|
if ('label' in $$props) $$invalidate('label', label = $$props.label);
|
|
};
|
|
|
|
return { text, label, textarea_input_handler };
|
|
}
|
|
|
|
class CodeArea extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$g, create_fragment$g, safe_not_equal, ["text", "label"]);
|
|
}
|
|
|
|
get text() {
|
|
throw new Error("<CodeArea>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set text(value) {
|
|
throw new Error("<CodeArea>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get label() {
|
|
throw new Error("<CodeArea>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set label(value) {
|
|
throw new Error("<CodeArea>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\database\IndexView.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$i = "src\\database\\IndexView.svelte";
|
|
|
|
function get_each_context$5(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.rec = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (45:8) {#each indexableRecords as rec}
|
|
function create_each_block$5(ctx) {
|
|
var input, input_checked_value, t0, span, t1_value = ctx.rec.node.name, t1, dispose;
|
|
|
|
function change_handler() {
|
|
return ctx.change_handler(ctx);
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
input = element("input");
|
|
t0 = space();
|
|
span = element("span");
|
|
t1 = text(t1_value);
|
|
attr(input, "type", "checkbox");
|
|
input.checked = input_checked_value = ctx.rec.isallowed;
|
|
add_location(input, file$i, 45, 8, 1400);
|
|
attr(span, "class", "svelte-1fkfoam");
|
|
add_location(span, file$i, 46, 8, 1501);
|
|
dispose = listen(input, "change", change_handler);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, input, anchor);
|
|
insert(target, t0, anchor);
|
|
insert(target, span, anchor);
|
|
append(span, t1);
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.indexableRecords) && input_checked_value !== (input_checked_value = ctx.rec.isallowed)) {
|
|
input.checked = input_checked_value;
|
|
}
|
|
|
|
if ((changed.indexableRecords) && t1_value !== (t1_value = ctx.rec.node.name)) {
|
|
set_data(t1, t1_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(input);
|
|
detach(t0);
|
|
detach(span);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$h(ctx) {
|
|
var div2, updating_text, t0, div1, div0, t2, t3, updating_selected, t4, updating_text_1, t5, updating_text_2, t6, updating_text_3, current;
|
|
|
|
function textbox_text_binding(value) {
|
|
ctx.textbox_text_binding.call(null, value);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox_props = { label: "Name" };
|
|
if (ctx.index.name !== void 0) {
|
|
textbox_props.text = ctx.index.name;
|
|
}
|
|
var textbox = new Textbox({ props: textbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox, 'text', textbox_text_binding));
|
|
|
|
var each_value = ctx.indexableRecords;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$5(get_each_context$5(ctx, each_value, i));
|
|
}
|
|
|
|
function dropdown_selected_binding(value_1) {
|
|
ctx.dropdown_selected_binding.call(null, value_1);
|
|
updating_selected = true;
|
|
add_flush_callback(() => updating_selected = false);
|
|
}
|
|
|
|
let dropdown_props = {
|
|
label: "Index Type",
|
|
options: ["ancestor", "reference"]
|
|
};
|
|
if (ctx.index.indexType !== void 0) {
|
|
dropdown_props.selected = ctx.index.indexType;
|
|
}
|
|
var dropdown = new Dropdown({ props: dropdown_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(dropdown, 'selected', dropdown_selected_binding));
|
|
|
|
function codearea0_text_binding(value_2) {
|
|
ctx.codearea0_text_binding.call(null, value_2);
|
|
updating_text_1 = true;
|
|
add_flush_callback(() => updating_text_1 = false);
|
|
}
|
|
|
|
let codearea0_props = { label: "Map (javascript)" };
|
|
if (ctx.index.map !== void 0) {
|
|
codearea0_props.text = ctx.index.map;
|
|
}
|
|
var codearea0 = new CodeArea({ props: codearea0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(codearea0, 'text', codearea0_text_binding));
|
|
|
|
function codearea1_text_binding(value_3) {
|
|
ctx.codearea1_text_binding.call(null, value_3);
|
|
updating_text_2 = true;
|
|
add_flush_callback(() => updating_text_2 = false);
|
|
}
|
|
|
|
let codearea1_props = { label: "Filter (javascript expression)" };
|
|
if (ctx.index.filter !== void 0) {
|
|
codearea1_props.text = ctx.index.filter;
|
|
}
|
|
var codearea1 = new CodeArea({ props: codearea1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(codearea1, 'text', codearea1_text_binding));
|
|
|
|
function codearea2_text_binding(value_4) {
|
|
ctx.codearea2_text_binding.call(null, value_4);
|
|
updating_text_3 = true;
|
|
add_flush_callback(() => updating_text_3 = false);
|
|
}
|
|
|
|
let codearea2_props = {
|
|
label: "Shard Name (javascript expression)"
|
|
};
|
|
if (ctx.index.getShardName !== void 0) {
|
|
codearea2_props.text = ctx.index.getShardName;
|
|
}
|
|
var codearea2 = new CodeArea({ props: codearea2_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(codearea2, 'text', codearea2_text_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
div2 = element("div");
|
|
textbox.$$.fragment.c();
|
|
t0 = space();
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
div0.textContent = "Records to Index";
|
|
t2 = space();
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
|
|
t3 = space();
|
|
dropdown.$$.fragment.c();
|
|
t4 = space();
|
|
codearea0.$$.fragment.c();
|
|
t5 = space();
|
|
codearea1.$$.fragment.c();
|
|
t6 = space();
|
|
codearea2.$$.fragment.c();
|
|
add_location(div0, file$i, 43, 8, 1322);
|
|
attr(div1, "class", "allowed-records svelte-1fkfoam");
|
|
add_location(div1, file$i, 42, 4, 1283);
|
|
attr(div2, "class", "root svelte-1fkfoam");
|
|
add_location(div2, file$i, 39, 0, 1201);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div2, anchor);
|
|
mount_component(textbox, div2, null);
|
|
append(div2, t0);
|
|
append(div2, div1);
|
|
append(div1, div0);
|
|
append(div1, t2);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
|
|
append(div2, t3);
|
|
mount_component(dropdown, div2, null);
|
|
append(div2, t4);
|
|
mount_component(codearea0, div2, null);
|
|
append(div2, t5);
|
|
mount_component(codearea1, div2, null);
|
|
append(div2, t6);
|
|
mount_component(codearea2, div2, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var textbox_changes = {};
|
|
if (!updating_text && changed.index) {
|
|
textbox_changes.text = ctx.index.name;
|
|
}
|
|
textbox.$set(textbox_changes);
|
|
|
|
if (changed.indexableRecords) {
|
|
each_value = ctx.indexableRecords;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$5(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$5(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
|
|
var dropdown_changes = {};
|
|
if (!updating_selected && changed.index) {
|
|
dropdown_changes.selected = ctx.index.indexType;
|
|
}
|
|
dropdown.$set(dropdown_changes);
|
|
|
|
var codearea0_changes = {};
|
|
if (!updating_text_1 && changed.index) {
|
|
codearea0_changes.text = ctx.index.map;
|
|
}
|
|
codearea0.$set(codearea0_changes);
|
|
|
|
var codearea1_changes = {};
|
|
if (!updating_text_2 && changed.index) {
|
|
codearea1_changes.text = ctx.index.filter;
|
|
}
|
|
codearea1.$set(codearea1_changes);
|
|
|
|
var codearea2_changes = {};
|
|
if (!updating_text_3 && changed.index) {
|
|
codearea2_changes.text = ctx.index.getShardName;
|
|
}
|
|
codearea2.$set(codearea2_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(textbox.$$.fragment, local);
|
|
|
|
transition_in(dropdown.$$.fragment, local);
|
|
|
|
transition_in(codearea0.$$.fragment, local);
|
|
|
|
transition_in(codearea1.$$.fragment, local);
|
|
|
|
transition_in(codearea2.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(textbox.$$.fragment, local);
|
|
transition_out(dropdown.$$.fragment, local);
|
|
transition_out(codearea0.$$.fragment, local);
|
|
transition_out(codearea1.$$.fragment, local);
|
|
transition_out(codearea2.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div2);
|
|
}
|
|
|
|
destroy_component(textbox);
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
destroy_component(dropdown);
|
|
|
|
destroy_component(codearea0);
|
|
|
|
destroy_component(codearea1);
|
|
|
|
destroy_component(codearea2);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$h($$self, $$props, $$invalidate) {
|
|
|
|
|
|
const chain = index.$;
|
|
|
|
let index$1;
|
|
let indexableRecords = [];
|
|
|
|
database.subscribe($database => {
|
|
$$invalidate('index', index$1 = $database.currentNode);
|
|
$$invalidate('indexableRecords', indexableRecords = chain($database.hierarchy,[
|
|
hierarchy.getFlattenedHierarchy,
|
|
fp.filter(hierarchy.isDecendant(index$1.parent())),
|
|
fp.filter(hierarchy.isRecord),
|
|
fp.map(n => ({
|
|
node:n,
|
|
isallowed: fp.some(id => n.nodeId === id)(index$1.allowedRecordNodeIds)
|
|
}))
|
|
]));
|
|
});
|
|
|
|
const toggleAllowedRecord = record => {
|
|
if(record.isallowed) {
|
|
index$1.allowedRecordNodeIds = fp.filter(id => id !== record.node.nodeId)
|
|
(index$1.allowedRecordNodeIds); $$invalidate('index', index$1);
|
|
} else {
|
|
index$1.allowedRecordNodeIds.push(record.node.nodeId);
|
|
}
|
|
};
|
|
|
|
function textbox_text_binding(value) {
|
|
index$1.name = value;
|
|
$$invalidate('index', index$1);
|
|
}
|
|
|
|
function change_handler({ rec }) {
|
|
return toggleAllowedRecord(rec);
|
|
}
|
|
|
|
function dropdown_selected_binding(value_1) {
|
|
index$1.indexType = value_1;
|
|
$$invalidate('index', index$1);
|
|
}
|
|
|
|
function codearea0_text_binding(value_2) {
|
|
index$1.map = value_2;
|
|
$$invalidate('index', index$1);
|
|
}
|
|
|
|
function codearea1_text_binding(value_3) {
|
|
index$1.filter = value_3;
|
|
$$invalidate('index', index$1);
|
|
}
|
|
|
|
function codearea2_text_binding(value_4) {
|
|
index$1.getShardName = value_4;
|
|
$$invalidate('index', index$1);
|
|
}
|
|
|
|
return {
|
|
index: index$1,
|
|
indexableRecords,
|
|
toggleAllowedRecord,
|
|
textbox_text_binding,
|
|
change_handler,
|
|
dropdown_selected_binding,
|
|
codearea0_text_binding,
|
|
codearea1_text_binding,
|
|
codearea2_text_binding
|
|
};
|
|
}
|
|
|
|
class IndexView extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$h, create_fragment$h, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
/* src\database\ActionsHeader.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$j = "src\\database\\ActionsHeader.svelte";
|
|
|
|
// (27:12) {:else}
|
|
function create_else_block$3(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Update");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (25:12) {#if $database.currentNodeIsNew}
|
|
function create_if_block_2$2(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Create");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (24:8) <Button color="secondary" grouped on:click={database.saveCurrentNode}>
|
|
function create_default_slot_5(ctx) {
|
|
var if_block_anchor;
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.$database.currentNodeIsNew) return create_if_block_2$2;
|
|
return create_else_block$3;
|
|
}
|
|
|
|
var current_block_type = select_block_type(ctx);
|
|
var if_block = current_block_type(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (current_block_type !== (current_block_type = select_block_type(ctx))) {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(if_block_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (32:8) {#if !$database.currentNodeIsNew}
|
|
function create_if_block_1$2(ctx) {
|
|
var current;
|
|
|
|
var button = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_4] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button.$on("click", ctx.openConfirmDelete);
|
|
|
|
return {
|
|
c: function create() {
|
|
button.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (33:8) <Button color="secondary" grouped on:click={openConfirmDelete}>
|
|
function create_default_slot_4(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Delete");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (23:4) <ButtonGroup>
|
|
function create_default_slot_3(ctx) {
|
|
var t, if_block_anchor, current;
|
|
|
|
var button = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_5] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button.$on("click", database.saveCurrentNode);
|
|
|
|
var if_block = (!ctx.$database.currentNodeIsNew) && create_if_block_1$2(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
button.$$.fragment.c();
|
|
t = space();
|
|
if (if_block) if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button, target, anchor);
|
|
insert(target, t, anchor);
|
|
if (if_block) if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var button_changes = {};
|
|
if (changed.$$scope || changed.$database) button_changes.$$scope = { changed, ctx };
|
|
button.$set(button_changes);
|
|
|
|
if (!ctx.$database.currentNodeIsNew) {
|
|
if (!if_block) {
|
|
if_block = create_if_block_1$2(ctx);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
} else {
|
|
transition_in(if_block, 1);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button.$$.fragment, local);
|
|
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button.$$.fragment, local);
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
if (if_block) if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(if_block_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (39:4) {#if !!$database.errors && $database.errors.length > 0}
|
|
function create_if_block$5(ctx) {
|
|
var div, current;
|
|
|
|
var errorsbox = new ErrorsBox({
|
|
props: { errors: ctx.$database.errors },
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
errorsbox.$$.fragment.c();
|
|
set_style(div, "width", "500px");
|
|
add_location(div, file$j, 39, 4, 1032);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(errorsbox, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var errorsbox_changes = {};
|
|
if (changed.$database) errorsbox_changes.errors = ctx.$database.errors;
|
|
errorsbox.$set(errorsbox_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(errorsbox.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(errorsbox.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(errorsbox);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (48:12) <Button color="primary" on:click={deleteCurrentNode}>
|
|
function create_default_slot_2$1(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Yes");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (49:12) <Button color="secondary" on:click={() => confirmDelete = false}>
|
|
function create_default_slot_1$1(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("No");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (45:4) <Modal bind:isOpen={confirmDelete}>
|
|
function create_default_slot$2(ctx) {
|
|
var div0, t0, t1_value = ctx.$database.currentNode.name, t1, t2, t3, div1, t4, current;
|
|
|
|
var button0 = new Button({
|
|
props: {
|
|
color: "primary",
|
|
$$slots: { default: [create_default_slot_2$1] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button0.$on("click", ctx.deleteCurrentNode);
|
|
|
|
var button1 = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
$$slots: { default: [create_default_slot_1$1] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button1.$on("click", ctx.click_handler);
|
|
|
|
return {
|
|
c: function create() {
|
|
div0 = element("div");
|
|
t0 = text("Are you sure you want to delete ");
|
|
t1 = text(t1_value);
|
|
t2 = text(" ?");
|
|
t3 = space();
|
|
div1 = element("div");
|
|
button0.$$.fragment.c();
|
|
t4 = space();
|
|
button1.$$.fragment.c();
|
|
set_style(div0, "margin", "10px 0px 20px 0px");
|
|
add_location(div0, file$j, 45, 8, 1186);
|
|
set_style(div1, "float", "right");
|
|
add_location(div1, file$j, 46, 8, 1303);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div0, anchor);
|
|
append(div0, t0);
|
|
append(div0, t1);
|
|
append(div0, t2);
|
|
insert(target, t3, anchor);
|
|
insert(target, div1, anchor);
|
|
mount_component(button0, div1, null);
|
|
append(div1, t4);
|
|
mount_component(button1, div1, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((!current || changed.$database) && t1_value !== (t1_value = ctx.$database.currentNode.name)) {
|
|
set_data(t1, t1_value);
|
|
}
|
|
|
|
var button0_changes = {};
|
|
if (changed.$$scope) button0_changes.$$scope = { changed, ctx };
|
|
button0.$set(button0_changes);
|
|
|
|
var button1_changes = {};
|
|
if (changed.$$scope) button1_changes.$$scope = { changed, ctx };
|
|
button1.$set(button1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button0.$$.fragment, local);
|
|
|
|
transition_in(button1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button0.$$.fragment, local);
|
|
transition_out(button1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div0);
|
|
detach(t3);
|
|
detach(div1);
|
|
}
|
|
|
|
destroy_component(button0);
|
|
|
|
destroy_component(button1);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$i(ctx) {
|
|
var div, t0, t1, updating_isOpen, current;
|
|
|
|
var buttongroup = new ButtonGroup({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_3] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
var if_block = (!!ctx.$database.errors && ctx.$database.errors.length > 0) && create_if_block$5(ctx);
|
|
|
|
function modal_isOpen_binding(value) {
|
|
ctx.modal_isOpen_binding.call(null, value);
|
|
updating_isOpen = true;
|
|
add_flush_callback(() => updating_isOpen = false);
|
|
}
|
|
|
|
let modal_props = {
|
|
$$slots: { default: [create_default_slot$2] },
|
|
$$scope: { ctx }
|
|
};
|
|
if (ctx.confirmDelete !== void 0) {
|
|
modal_props.isOpen = ctx.confirmDelete;
|
|
}
|
|
var modal = new Modal({ props: modal_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(modal, 'isOpen', modal_isOpen_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
buttongroup.$$.fragment.c();
|
|
t0 = space();
|
|
if (if_block) if_block.c();
|
|
t1 = space();
|
|
modal.$$.fragment.c();
|
|
attr(div, "class", "root svelte-160njkp");
|
|
set_style(div, "left", ctx.left);
|
|
add_location(div, file$j, 20, 0, 486);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(buttongroup, div, null);
|
|
append(div, t0);
|
|
if (if_block) if_block.m(div, null);
|
|
append(div, t1);
|
|
mount_component(modal, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var buttongroup_changes = {};
|
|
if (changed.$$scope || changed.$database) buttongroup_changes.$$scope = { changed, ctx };
|
|
buttongroup.$set(buttongroup_changes);
|
|
|
|
if (!!ctx.$database.errors && ctx.$database.errors.length > 0) {
|
|
if (if_block) {
|
|
if_block.p(changed, ctx);
|
|
transition_in(if_block, 1);
|
|
} else {
|
|
if_block = create_if_block$5(ctx);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(div, t1);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
|
|
var modal_changes = {};
|
|
if (changed.$$scope || changed.$database) modal_changes.$$scope = { changed, ctx };
|
|
if (!updating_isOpen && changed.confirmDelete) {
|
|
modal_changes.isOpen = ctx.confirmDelete;
|
|
}
|
|
modal.$set(modal_changes);
|
|
|
|
if (!current || changed.left) {
|
|
set_style(div, "left", ctx.left);
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(buttongroup.$$.fragment, local);
|
|
|
|
transition_in(if_block);
|
|
|
|
transition_in(modal.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(buttongroup.$$.fragment, local);
|
|
transition_out(if_block);
|
|
transition_out(modal.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(buttongroup);
|
|
|
|
if (if_block) if_block.d();
|
|
|
|
destroy_component(modal);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$i($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
let { left } = $$props;
|
|
let confirmDelete = false;
|
|
const openConfirmDelete = () => {
|
|
$$invalidate('confirmDelete', confirmDelete = true);
|
|
};
|
|
|
|
const deleteCurrentNode = () => {
|
|
$$invalidate('confirmDelete', confirmDelete = false);
|
|
database.deleteCurrentNode();
|
|
};
|
|
|
|
const writable_props = ['left'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<ActionsHeader> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function click_handler() {
|
|
const $$result = confirmDelete = false;
|
|
$$invalidate('confirmDelete', confirmDelete);
|
|
return $$result;
|
|
}
|
|
|
|
function modal_isOpen_binding(value) {
|
|
confirmDelete = value;
|
|
$$invalidate('confirmDelete', confirmDelete);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('left' in $$props) $$invalidate('left', left = $$props.left);
|
|
};
|
|
|
|
return {
|
|
left,
|
|
confirmDelete,
|
|
openConfirmDelete,
|
|
deleteCurrentNode,
|
|
$database,
|
|
click_handler,
|
|
modal_isOpen_binding
|
|
};
|
|
}
|
|
|
|
class ActionsHeader extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$i, create_fragment$i, safe_not_equal, ["left"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.left === undefined && !('left' in props)) {
|
|
console.warn("<ActionsHeader> was created without expected prop 'left'");
|
|
}
|
|
}
|
|
|
|
get left() {
|
|
throw new Error("<ActionsHeader>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set left(value) {
|
|
throw new Error("<ActionsHeader>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\common\DropdownButton.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$k = "src\\common\\DropdownButton.svelte";
|
|
|
|
function get_each_context$6(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.action = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (17:8) {#each actions as action}
|
|
function create_each_block$6(ctx) {
|
|
var div, t0_value = ctx.action.label, t0, t1, dispose;
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
attr(div, "class", "action-row svelte-179p8ge");
|
|
add_location(div, file$k, 17, 8, 586);
|
|
dispose = listen(div, "click", ctx.action.onclick);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
append(div, t0);
|
|
append(div, t1);
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.actions) && t0_value !== (t0_value = ctx.action.label)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$j(ctx) {
|
|
var div2, raw_value = getIcon(ctx.iconName), raw_after, t0, div0, t1, div1, dispose;
|
|
|
|
var each_value = ctx.actions;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$6(get_each_context$6(ctx, each_value, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
div2 = element("div");
|
|
raw_after = element('noscript');
|
|
t0 = space();
|
|
div0 = element("div");
|
|
t1 = space();
|
|
div1 = element("div");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
attr(div0, "class", "dropdown-background svelte-179p8ge");
|
|
set_style(div0, "display", (ctx.isDroppedDown ? 'block' : 'none'));
|
|
add_location(div0, file$k, 13, 4, 298);
|
|
attr(div1, "class", "dropdown-content svelte-179p8ge");
|
|
set_style(div1, "display", (ctx.isDroppedDown ? 'inline-block' : 'none'));
|
|
add_location(div1, file$k, 15, 4, 452);
|
|
attr(div2, "class", "root svelte-179p8ge");
|
|
add_location(div2, file$k, 10, 0, 189);
|
|
|
|
dispose = [
|
|
listen(div0, "click", stop_propagation(ctx.click_handler)),
|
|
listen(div2, "click", ctx.click_handler_1)
|
|
];
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div2, anchor);
|
|
append(div2, raw_after);
|
|
raw_after.insertAdjacentHTML("beforebegin", raw_value);
|
|
append(div2, t0);
|
|
append(div2, div0);
|
|
append(div2, t1);
|
|
append(div2, div1);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if ((changed.iconName) && raw_value !== (raw_value = getIcon(ctx.iconName))) {
|
|
detach_before(raw_after);
|
|
raw_after.insertAdjacentHTML("beforebegin", raw_value);
|
|
}
|
|
|
|
if (changed.isDroppedDown) {
|
|
set_style(div0, "display", (ctx.isDroppedDown ? 'block' : 'none'));
|
|
}
|
|
|
|
if (changed.actions) {
|
|
each_value = ctx.actions;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$6(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$6(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
|
|
if (changed.isDroppedDown) {
|
|
set_style(div1, "display", (ctx.isDroppedDown ? 'inline-block' : 'none'));
|
|
}
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div2);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$j($$self, $$props, $$invalidate) {
|
|
let { iconName, actions = [] } = $$props; // [ {label: "Action Name", onclick: () => {...} } ]
|
|
let isDroppedDown = false;
|
|
|
|
const writable_props = ['iconName', 'actions'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<DropdownButton> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function click_handler() {
|
|
const $$result = isDroppedDown = false;
|
|
$$invalidate('isDroppedDown', isDroppedDown);
|
|
return $$result;
|
|
}
|
|
|
|
function click_handler_1() {
|
|
const $$result = isDroppedDown = !isDroppedDown;
|
|
$$invalidate('isDroppedDown', isDroppedDown);
|
|
return $$result;
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('iconName' in $$props) $$invalidate('iconName', iconName = $$props.iconName);
|
|
if ('actions' in $$props) $$invalidate('actions', actions = $$props.actions);
|
|
};
|
|
|
|
return {
|
|
iconName,
|
|
actions,
|
|
isDroppedDown,
|
|
click_handler,
|
|
click_handler_1
|
|
};
|
|
}
|
|
|
|
class DropdownButton extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$j, create_fragment$j, safe_not_equal, ["iconName", "actions"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.iconName === undefined && !('iconName' in props)) {
|
|
console.warn("<DropdownButton> was created without expected prop 'iconName'");
|
|
}
|
|
}
|
|
|
|
get iconName() {
|
|
throw new Error("<DropdownButton>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set iconName(value) {
|
|
throw new Error("<DropdownButton>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get actions() {
|
|
throw new Error("<DropdownButton>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set actions(value) {
|
|
throw new Error("<DropdownButton>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\database\DatabaseRoot.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$l = "src\\database\\DatabaseRoot.svelte";
|
|
|
|
function get_each_context$7(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.index = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
function get_each_context_1$2(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.record = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (55:8) {#each $database.hierarchy.children as record}
|
|
function create_each_block_1$2(ctx) {
|
|
var current;
|
|
|
|
var hierarchyrow = new HierarchyRow({
|
|
props: { node: ctx.record },
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
hierarchyrow.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(hierarchyrow, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var hierarchyrow_changes = {};
|
|
if (changed.$database) hierarchyrow_changes.node = ctx.record;
|
|
hierarchyrow.$set(hierarchyrow_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(hierarchyrow.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(hierarchyrow.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(hierarchyrow, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (63:8) {#each $database.hierarchy.indexes as index}
|
|
function create_each_block$7(ctx) {
|
|
var current;
|
|
|
|
var hierarchyrow = new HierarchyRow({
|
|
props: { node: ctx.index },
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
hierarchyrow.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(hierarchyrow, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var hierarchyrow_changes = {};
|
|
if (changed.$database) hierarchyrow_changes.node = ctx.index;
|
|
hierarchyrow.$set(hierarchyrow_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(hierarchyrow.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(hierarchyrow.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(hierarchyrow, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (69:12) {#if $database.currentNode}
|
|
function create_if_block_2$3(ctx) {
|
|
var current;
|
|
|
|
var actionsheader = new ActionsHeader({
|
|
props: { left: hierarchyWidth },
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
actionsheader.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(actionsheader, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var actionsheader_changes = {};
|
|
if (changed.hierarchyWidth) actionsheader_changes.left = hierarchyWidth;
|
|
actionsheader.$set(actionsheader_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(actionsheader.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(actionsheader.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(actionsheader, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (78:12) {:else}
|
|
function create_else_block$4(ctx) {
|
|
var current;
|
|
|
|
var indexview = new IndexView({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
indexview.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(indexview, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(indexview.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(indexview.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(indexview, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (76:62)
|
|
function create_if_block_1$3(ctx) {
|
|
var current;
|
|
|
|
var recordview = new RecordView({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
recordview.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(recordview, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(recordview.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(recordview.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(recordview, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (74:12) {#if !$database.currentNode}
|
|
function create_if_block$6(ctx) {
|
|
var h1;
|
|
|
|
return {
|
|
c: function create() {
|
|
h1 = element("h1");
|
|
h1.textContent = ":)";
|
|
set_style(h1, "margin-left", "100px");
|
|
add_location(h1, file$l, 74, 12, 2417);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, h1, anchor);
|
|
},
|
|
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(h1);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$k(ctx) {
|
|
var div8, div4, div1, div0, t1, t2, t3, div3, div2, t5, t6, t7, div7, div5, t8, div6, current_block_type_index, if_block1, current;
|
|
|
|
var dropdownbutton0 = new DropdownButton({
|
|
props: { iconName: "plus", actions: ctx.newRecordActions },
|
|
$$inline: true
|
|
});
|
|
|
|
var each_value_1 = ctx.$database.hierarchy.children;
|
|
|
|
var each_blocks_1 = [];
|
|
|
|
for (var i = 0; i < each_value_1.length; i += 1) {
|
|
each_blocks_1[i] = create_each_block_1$2(get_each_context_1$2(ctx, each_value_1, i));
|
|
}
|
|
|
|
const out = i => transition_out(each_blocks_1[i], 1, 1, () => {
|
|
each_blocks_1[i] = null;
|
|
});
|
|
|
|
var dropdownbutton1 = new DropdownButton({
|
|
props: { iconName: "plus", actions: ctx.newIndexActions },
|
|
$$inline: true
|
|
});
|
|
|
|
var each_value = ctx.$database.hierarchy.indexes;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$7(get_each_context$7(ctx, each_value, i));
|
|
}
|
|
|
|
const out_1 = i => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
|
|
var if_block0 = (ctx.$database.currentNode) && create_if_block_2$3();
|
|
|
|
var if_block_creators = [
|
|
create_if_block$6,
|
|
create_if_block_1$3,
|
|
create_else_block$4
|
|
];
|
|
|
|
var if_blocks = [];
|
|
|
|
function select_block_type(ctx) {
|
|
if (!ctx.$database.currentNode) return 0;
|
|
if (ctx.$database.currentNode.type === "record") return 1;
|
|
return 2;
|
|
}
|
|
|
|
current_block_type_index = select_block_type(ctx);
|
|
if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
div8 = element("div");
|
|
div4 = element("div");
|
|
div1 = element("div");
|
|
div0 = element("div");
|
|
div0.textContent = "Records";
|
|
t1 = space();
|
|
dropdownbutton0.$$.fragment.c();
|
|
t2 = space();
|
|
|
|
for (var i = 0; i < each_blocks_1.length; i += 1) {
|
|
each_blocks_1[i].c();
|
|
}
|
|
|
|
t3 = space();
|
|
div3 = element("div");
|
|
div2 = element("div");
|
|
div2.textContent = "Indexes";
|
|
t5 = space();
|
|
dropdownbutton1.$$.fragment.c();
|
|
t6 = space();
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
|
|
t7 = space();
|
|
div7 = element("div");
|
|
div5 = element("div");
|
|
if (if_block0) if_block0.c();
|
|
t8 = space();
|
|
div6 = element("div");
|
|
if_block1.c();
|
|
attr(div0, "class", "hierarchy-title svelte-z7gm0t");
|
|
add_location(div0, file$l, 51, 12, 1544);
|
|
attr(div1, "class", "hierarchy-title-row svelte-z7gm0t");
|
|
add_location(div1, file$l, 50, 8, 1497);
|
|
attr(div2, "class", "hierarchy-title svelte-z7gm0t");
|
|
add_location(div2, file$l, 59, 12, 1874);
|
|
attr(div3, "class", "hierarchy-title-row svelte-z7gm0t");
|
|
set_style(div3, "margin-top", "20px");
|
|
add_location(div3, file$l, 58, 8, 1802);
|
|
attr(div4, "class", "hierarchy svelte-z7gm0t");
|
|
set_style(div4, "width", hierarchyWidth);
|
|
add_location(div4, file$l, 49, 4, 1432);
|
|
attr(div5, "class", "actions-header svelte-z7gm0t");
|
|
add_location(div5, file$l, 67, 8, 2172);
|
|
attr(div6, "class", "node-view svelte-z7gm0t");
|
|
add_location(div6, file$l, 72, 8, 2338);
|
|
attr(div7, "class", "node-container svelte-z7gm0t");
|
|
add_location(div7, file$l, 66, 4, 2134);
|
|
attr(div8, "class", "root svelte-z7gm0t");
|
|
add_location(div8, file$l, 48, 0, 1408);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div8, anchor);
|
|
append(div8, div4);
|
|
append(div4, div1);
|
|
append(div1, div0);
|
|
append(div1, t1);
|
|
mount_component(dropdownbutton0, div1, null);
|
|
append(div4, t2);
|
|
|
|
for (var i = 0; i < each_blocks_1.length; i += 1) {
|
|
each_blocks_1[i].m(div4, null);
|
|
}
|
|
|
|
append(div4, t3);
|
|
append(div4, div3);
|
|
append(div3, div2);
|
|
append(div3, t5);
|
|
mount_component(dropdownbutton1, div3, null);
|
|
append(div4, t6);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div4, null);
|
|
}
|
|
|
|
append(div8, t7);
|
|
append(div8, div7);
|
|
append(div7, div5);
|
|
if (if_block0) if_block0.m(div5, null);
|
|
append(div7, t8);
|
|
append(div7, div6);
|
|
if_blocks[current_block_type_index].m(div6, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var dropdownbutton0_changes = {};
|
|
if (changed.newRecordActions) dropdownbutton0_changes.actions = ctx.newRecordActions;
|
|
dropdownbutton0.$set(dropdownbutton0_changes);
|
|
|
|
if (changed.$database) {
|
|
each_value_1 = ctx.$database.hierarchy.children;
|
|
|
|
for (var i = 0; i < each_value_1.length; i += 1) {
|
|
const child_ctx = get_each_context_1$2(ctx, each_value_1, i);
|
|
|
|
if (each_blocks_1[i]) {
|
|
each_blocks_1[i].p(changed, child_ctx);
|
|
transition_in(each_blocks_1[i], 1);
|
|
} else {
|
|
each_blocks_1[i] = create_each_block_1$2(child_ctx);
|
|
each_blocks_1[i].c();
|
|
transition_in(each_blocks_1[i], 1);
|
|
each_blocks_1[i].m(div4, t3);
|
|
}
|
|
}
|
|
|
|
group_outros();
|
|
for (i = each_value_1.length; i < each_blocks_1.length; i += 1) out(i);
|
|
check_outros();
|
|
}
|
|
|
|
var dropdownbutton1_changes = {};
|
|
if (changed.newIndexActions) dropdownbutton1_changes.actions = ctx.newIndexActions;
|
|
dropdownbutton1.$set(dropdownbutton1_changes);
|
|
|
|
if (changed.$database) {
|
|
each_value = ctx.$database.hierarchy.indexes;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$7(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block$7(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(div4, null);
|
|
}
|
|
}
|
|
|
|
group_outros();
|
|
for (i = each_value.length; i < each_blocks.length; i += 1) out_1(i);
|
|
check_outros();
|
|
}
|
|
|
|
if (!current || changed.hierarchyWidth) {
|
|
set_style(div4, "width", hierarchyWidth);
|
|
}
|
|
|
|
if (ctx.$database.currentNode) {
|
|
if (if_block0) {
|
|
if_block0.p(changed, ctx);
|
|
transition_in(if_block0, 1);
|
|
} else {
|
|
if_block0 = create_if_block_2$3();
|
|
if_block0.c();
|
|
transition_in(if_block0, 1);
|
|
if_block0.m(div5, null);
|
|
}
|
|
} else if (if_block0) {
|
|
group_outros();
|
|
transition_out(if_block0, 1, 1, () => {
|
|
if_block0 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
|
|
var previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type(ctx);
|
|
if (current_block_type_index !== previous_block_index) {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
|
|
if_block1 = if_blocks[current_block_type_index];
|
|
if (!if_block1) {
|
|
if_block1 = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
if_block1.c();
|
|
}
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(div6, null);
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(dropdownbutton0.$$.fragment, local);
|
|
|
|
for (var i = 0; i < each_value_1.length; i += 1) transition_in(each_blocks_1[i]);
|
|
|
|
transition_in(dropdownbutton1.$$.fragment, local);
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) transition_in(each_blocks[i]);
|
|
|
|
transition_in(if_block0);
|
|
transition_in(if_block1);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(dropdownbutton0.$$.fragment, local);
|
|
|
|
each_blocks_1 = each_blocks_1.filter(Boolean);
|
|
for (let i = 0; i < each_blocks_1.length; i += 1) transition_out(each_blocks_1[i]);
|
|
|
|
transition_out(dropdownbutton1.$$.fragment, local);
|
|
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) transition_out(each_blocks[i]);
|
|
|
|
transition_out(if_block0);
|
|
transition_out(if_block1);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div8);
|
|
}
|
|
|
|
destroy_component(dropdownbutton0);
|
|
|
|
destroy_each(each_blocks_1, detaching);
|
|
|
|
destroy_component(dropdownbutton1);
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
if (if_block0) if_block0.d();
|
|
if_blocks[current_block_type_index].d();
|
|
}
|
|
};
|
|
}
|
|
|
|
const hierarchyWidth = "200px";
|
|
|
|
function instance$k($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
const defaultNewIndexActions = [{
|
|
label:"New Root Index",
|
|
onclick: database.newRootIndex
|
|
}];
|
|
|
|
const defaultNewRecordActions = [{
|
|
label:"New Root Record",
|
|
onclick: database.newRootRecord
|
|
}];
|
|
|
|
let newIndexActions = defaultNewIndexActions;
|
|
let newRecordActions = defaultNewRecordActions;
|
|
|
|
database.subscribe(db => {
|
|
if(!db.currentNode || hierarchy.isIndex(db.currentNode)) {
|
|
$$invalidate('newRecordActions', newRecordActions = defaultNewRecordActions);
|
|
$$invalidate('newIndexActions', newIndexActions = defaultNewIndexActions);
|
|
} else {
|
|
$$invalidate('newRecordActions', newRecordActions = [
|
|
...defaultNewRecordActions,
|
|
{label: `New Child Record of ${db.currentNode.name}`,
|
|
onclick: database.newChildRecord}
|
|
]);
|
|
|
|
$$invalidate('newIndexActions', newIndexActions = [
|
|
...defaultNewIndexActions,
|
|
{label: `New Index on ${db.currentNode.name}`,
|
|
onclick: database.newChildIndex}
|
|
]);
|
|
}
|
|
});
|
|
|
|
return {
|
|
newIndexActions,
|
|
newRecordActions,
|
|
$database
|
|
};
|
|
}
|
|
|
|
class DatabaseRoot extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$k, create_fragment$k, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
/* src\userInterface\UserInterfaceRoot.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$m = "src\\userInterface\\UserInterfaceRoot.svelte";
|
|
|
|
function create_fragment$l(ctx) {
|
|
var div2, div0, t, div1;
|
|
|
|
return {
|
|
c: function create() {
|
|
div2 = element("div");
|
|
div0 = element("div");
|
|
t = space();
|
|
div1 = element("div");
|
|
attr(div0, "class", "ui-nav svelte-1bhe8g7");
|
|
add_location(div0, file$m, 8, 4, 112);
|
|
attr(div1, "class", "component-preview svelte-1bhe8g7");
|
|
add_location(div1, file$m, 12, 4, 158);
|
|
attr(div2, "class", "root svelte-1bhe8g7");
|
|
add_location(div2, file$m, 6, 0, 82);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div2, anchor);
|
|
append(div2, div0);
|
|
append(div2, t);
|
|
append(div2, div1);
|
|
},
|
|
|
|
p: noop,
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div2);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
class UserInterfaceRoot extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, null, create_fragment$l, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
/* src\actionsAndTriggers\ActionView.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$n = "src\\actionsAndTriggers\\ActionView.svelte";
|
|
|
|
function get_each_context$8(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.option = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (83:12) <Button color="primary-outline uk-width-1-4" on:click={addNewOption}>
|
|
function create_default_slot_3$1(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Add");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (86:12) {#each initialOptions as option}
|
|
function create_each_block$8(ctx) {
|
|
var span1, t0_value = ctx.option.key, t0, t1, t2_value = ctx.option.value, t2, t3, span0, raw_value = getIcon("trash-2"), dispose;
|
|
|
|
function click_handler() {
|
|
return ctx.click_handler(ctx);
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
span1 = element("span");
|
|
t0 = text(t0_value);
|
|
t1 = text(" : ");
|
|
t2 = text(t2_value);
|
|
t3 = space();
|
|
span0 = element("span");
|
|
set_style(span0, "font-size", "10pt");
|
|
set_style(span0, "cursor", "pointer");
|
|
add_location(span0, file$n, 86, 73, 2561);
|
|
attr(span1, "class", "option-container svelte-emcy8y");
|
|
add_location(span1, file$n, 86, 12, 2500);
|
|
dispose = listen(span0, "click", click_handler);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, span1, anchor);
|
|
append(span1, t0);
|
|
append(span1, t1);
|
|
append(span1, t2);
|
|
append(span1, t3);
|
|
append(span1, span0);
|
|
span0.innerHTML = raw_value;
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.initialOptions) && t0_value !== (t0_value = ctx.option.key)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if ((changed.initialOptions) && t2_value !== (t2_value = ctx.option.value)) {
|
|
set_data(t2, t2_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(span1);
|
|
}
|
|
|
|
dispose();
|
|
}
|
|
};
|
|
}
|
|
|
|
// (93:8) <Button color="primary" grouped on:click={save}>
|
|
function create_default_slot_2$2(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Save");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (94:8) <Button color="secondary" grouped on:click={cancel}>
|
|
function create_default_slot_1$2(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Cancel");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (92:4) <ButtonGroup>
|
|
function create_default_slot$3(ctx) {
|
|
var t, current;
|
|
|
|
var button0 = new Button({
|
|
props: {
|
|
color: "primary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_2$2] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button0.$on("click", ctx.save);
|
|
|
|
var button1 = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_1$2] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button1.$on("click", ctx.cancel);
|
|
|
|
return {
|
|
c: function create() {
|
|
button0.$$.fragment.c();
|
|
t = space();
|
|
button1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(button1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var button0_changes = {};
|
|
if (changed.$$scope) button0_changes.$$scope = { changed, ctx };
|
|
button0.$set(button0_changes);
|
|
|
|
var button1_changes = {};
|
|
if (changed.$$scope) button1_changes.$$scope = { changed, ctx };
|
|
button1.$set(button1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button0.$$.fragment, local);
|
|
|
|
transition_in(button1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button0.$$.fragment, local);
|
|
transition_out(button1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(button1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$m(ctx) {
|
|
var div3, t0, updating_text, t1, updating_text_1, t2, updating_text_2, t3, div2, label, t5, div0, input0, t6, input1, t7, t8, div1, t9, current, dispose;
|
|
|
|
var errorsbox = new ErrorsBox({
|
|
props: { errors: ctx.errors },
|
|
$$inline: true
|
|
});
|
|
|
|
function textbox0_text_binding(value) {
|
|
ctx.textbox0_text_binding.call(null, value);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox0_props = { label: "Name" };
|
|
if (ctx.clonedAction.name !== void 0) {
|
|
textbox0_props.text = ctx.clonedAction.name;
|
|
}
|
|
var textbox0 = new Textbox({ props: textbox0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox0, 'text', textbox0_text_binding));
|
|
|
|
function textbox1_text_binding(value_1) {
|
|
ctx.textbox1_text_binding.call(null, value_1);
|
|
updating_text_1 = true;
|
|
add_flush_callback(() => updating_text_1 = false);
|
|
}
|
|
|
|
let textbox1_props = { label: "Behaviour Source" };
|
|
if (ctx.clonedAction.behaviourSource !== void 0) {
|
|
textbox1_props.text = ctx.clonedAction.behaviourSource;
|
|
}
|
|
var textbox1 = new Textbox({ props: textbox1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox1, 'text', textbox1_text_binding));
|
|
|
|
function textbox2_text_binding(value_2) {
|
|
ctx.textbox2_text_binding.call(null, value_2);
|
|
updating_text_2 = true;
|
|
add_flush_callback(() => updating_text_2 = false);
|
|
}
|
|
|
|
let textbox2_props = { label: "Behaviour" };
|
|
if (ctx.clonedAction.behaviourName !== void 0) {
|
|
textbox2_props.text = ctx.clonedAction.behaviourName;
|
|
}
|
|
var textbox2 = new Textbox({ props: textbox2_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox2, 'text', textbox2_text_binding));
|
|
|
|
var button = new Button({
|
|
props: {
|
|
color: "primary-outline uk-width-1-4",
|
|
$$slots: { default: [create_default_slot_3$1] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button.$on("click", ctx.addNewOption);
|
|
|
|
var each_value = ctx.initialOptions;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$8(get_each_context$8(ctx, each_value, i));
|
|
}
|
|
|
|
var buttongroup = new ButtonGroup({
|
|
props: {
|
|
$$slots: { default: [create_default_slot$3] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
div3 = element("div");
|
|
errorsbox.$$.fragment.c();
|
|
t0 = space();
|
|
textbox0.$$.fragment.c();
|
|
t1 = space();
|
|
textbox1.$$.fragment.c();
|
|
t2 = space();
|
|
textbox2.$$.fragment.c();
|
|
t3 = space();
|
|
div2 = element("div");
|
|
label = element("label");
|
|
label.textContent = "Default Options";
|
|
t5 = space();
|
|
div0 = element("div");
|
|
input0 = element("input");
|
|
t6 = space();
|
|
input1 = element("input");
|
|
t7 = space();
|
|
button.$$.fragment.c();
|
|
t8 = space();
|
|
div1 = element("div");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
|
|
t9 = space();
|
|
buttongroup.$$.fragment.c();
|
|
attr(label, "class", "uk-form-label");
|
|
add_location(label, file$n, 78, 8, 1992);
|
|
attr(input0, "class", "uk-input uk-width-1-4");
|
|
attr(input0, "placeholder", "key");
|
|
add_location(input0, file$n, 80, 12, 2103);
|
|
attr(input1, "class", "uk-input uk-width-1-4");
|
|
attr(input1, "placeholder", "value");
|
|
add_location(input1, file$n, 81, 12, 2201);
|
|
attr(div0, "class", "uk-grid-small");
|
|
attr(div0, "uk-grid", "");
|
|
add_location(div0, file$n, 79, 8, 2054);
|
|
set_style(div1, "margin-top", "10px");
|
|
add_location(div1, file$n, 84, 8, 2410);
|
|
attr(div2, "class", " uk-form-stacked");
|
|
set_style(div2, "margin-bottom", "20px");
|
|
add_location(div2, file$n, 77, 4, 1924);
|
|
attr(div3, "class", "root svelte-emcy8y");
|
|
add_location(div3, file$n, 68, 0, 1647);
|
|
|
|
dispose = [
|
|
listen(input0, "input", ctx.input0_input_handler),
|
|
listen(input1, "input", ctx.input1_input_handler)
|
|
];
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div3, anchor);
|
|
mount_component(errorsbox, div3, null);
|
|
append(div3, t0);
|
|
mount_component(textbox0, div3, null);
|
|
append(div3, t1);
|
|
mount_component(textbox1, div3, null);
|
|
append(div3, t2);
|
|
mount_component(textbox2, div3, null);
|
|
append(div3, t3);
|
|
append(div3, div2);
|
|
append(div2, label);
|
|
append(div2, t5);
|
|
append(div2, div0);
|
|
append(div0, input0);
|
|
|
|
input0.value = ctx.optKey;
|
|
|
|
append(div0, t6);
|
|
append(div0, input1);
|
|
|
|
input1.value = ctx.optValue;
|
|
|
|
append(div0, t7);
|
|
mount_component(button, div0, null);
|
|
append(div2, t8);
|
|
append(div2, div1);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
|
|
append(div3, t9);
|
|
mount_component(buttongroup, div3, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var errorsbox_changes = {};
|
|
if (changed.errors) errorsbox_changes.errors = ctx.errors;
|
|
errorsbox.$set(errorsbox_changes);
|
|
|
|
var textbox0_changes = {};
|
|
if (!updating_text && changed.clonedAction) {
|
|
textbox0_changes.text = ctx.clonedAction.name;
|
|
}
|
|
textbox0.$set(textbox0_changes);
|
|
|
|
var textbox1_changes = {};
|
|
if (!updating_text_1 && changed.clonedAction) {
|
|
textbox1_changes.text = ctx.clonedAction.behaviourSource;
|
|
}
|
|
textbox1.$set(textbox1_changes);
|
|
|
|
var textbox2_changes = {};
|
|
if (!updating_text_2 && changed.clonedAction) {
|
|
textbox2_changes.text = ctx.clonedAction.behaviourName;
|
|
}
|
|
textbox2.$set(textbox2_changes);
|
|
|
|
if (changed.optKey && (input0.value !== ctx.optKey)) input0.value = ctx.optKey;
|
|
if (changed.optValue && (input1.value !== ctx.optValue)) input1.value = ctx.optValue;
|
|
|
|
var button_changes = {};
|
|
if (changed.$$scope) button_changes.$$scope = { changed, ctx };
|
|
button.$set(button_changes);
|
|
|
|
if (changed.getIcon || changed.initialOptions) {
|
|
each_value = ctx.initialOptions;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$8(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$8(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(div1, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
|
|
var buttongroup_changes = {};
|
|
if (changed.$$scope) buttongroup_changes.$$scope = { changed, ctx };
|
|
buttongroup.$set(buttongroup_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(errorsbox.$$.fragment, local);
|
|
|
|
transition_in(textbox0.$$.fragment, local);
|
|
|
|
transition_in(textbox1.$$.fragment, local);
|
|
|
|
transition_in(textbox2.$$.fragment, local);
|
|
|
|
transition_in(button.$$.fragment, local);
|
|
|
|
transition_in(buttongroup.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(errorsbox.$$.fragment, local);
|
|
transition_out(textbox0.$$.fragment, local);
|
|
transition_out(textbox1.$$.fragment, local);
|
|
transition_out(textbox2.$$.fragment, local);
|
|
transition_out(button.$$.fragment, local);
|
|
transition_out(buttongroup.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div3);
|
|
}
|
|
|
|
destroy_component(errorsbox);
|
|
|
|
destroy_component(textbox0);
|
|
|
|
destroy_component(textbox1);
|
|
|
|
destroy_component(textbox2);
|
|
|
|
destroy_component(button);
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
destroy_component(buttongroup);
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$l($$self, $$props, $$invalidate) {
|
|
|
|
|
|
let { action, onFinished = (action) => {} } = $$props;
|
|
let { allActions, isNew = true } = $$props;
|
|
|
|
let optKey = "";
|
|
let optValue = "";
|
|
|
|
let clonedAction = fp.cloneDeep(action);
|
|
let initialOptions = chain(action.initialOptions, [
|
|
fp.keys,
|
|
fp.map(k => ({key:k, value:action.initialOptions[k]}))
|
|
]);
|
|
let errors = [];
|
|
|
|
const addNewOption = () => {
|
|
|
|
if(optKey && optValue && fp.isUndefined(clonedAction.initialOptions[optKey])) {
|
|
clonedAction.initialOptions[optKey] = optValue; $$invalidate('clonedAction', clonedAction);
|
|
$$invalidate('initialOptions', initialOptions = [...initialOptions, {
|
|
key:optKey, value: optValue
|
|
}]);
|
|
$$invalidate('optKey', optKey = "");
|
|
$$invalidate('optValue', optValue = "");
|
|
}
|
|
};
|
|
|
|
const removeOption = (opt) => {
|
|
if(opt) {
|
|
delete clonedAction.initialOptions[opt.key];
|
|
$$invalidate('initialOptions', initialOptions = chain(initialOptions, [
|
|
fp.filter(o => o.key !== opt.key)
|
|
]));
|
|
}
|
|
};
|
|
|
|
const save = () => {
|
|
|
|
const newActionsList = [
|
|
...chain(allActions ,[fp.filter(a => a !== action)]),
|
|
clonedAction];
|
|
|
|
$$invalidate('errors', errors = chain(newActionsList ,[
|
|
validateActions$1,
|
|
fp.map(e => e.error)
|
|
]));
|
|
|
|
if(errors.length === 0)
|
|
onFinished(clonedAction);
|
|
};
|
|
|
|
const cancel = () => {
|
|
onFinished();
|
|
};
|
|
|
|
const writable_props = ['action', 'onFinished', 'allActions', 'isNew'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<ActionView> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function textbox0_text_binding(value) {
|
|
clonedAction.name = value;
|
|
$$invalidate('clonedAction', clonedAction);
|
|
}
|
|
|
|
function textbox1_text_binding(value_1) {
|
|
clonedAction.behaviourSource = value_1;
|
|
$$invalidate('clonedAction', clonedAction);
|
|
}
|
|
|
|
function textbox2_text_binding(value_2) {
|
|
clonedAction.behaviourName = value_2;
|
|
$$invalidate('clonedAction', clonedAction);
|
|
}
|
|
|
|
function input0_input_handler() {
|
|
optKey = this.value;
|
|
$$invalidate('optKey', optKey);
|
|
}
|
|
|
|
function input1_input_handler() {
|
|
optValue = this.value;
|
|
$$invalidate('optValue', optValue);
|
|
}
|
|
|
|
function click_handler({ option }) {
|
|
return removeOption(option);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('action' in $$props) $$invalidate('action', action = $$props.action);
|
|
if ('onFinished' in $$props) $$invalidate('onFinished', onFinished = $$props.onFinished);
|
|
if ('allActions' in $$props) $$invalidate('allActions', allActions = $$props.allActions);
|
|
if ('isNew' in $$props) $$invalidate('isNew', isNew = $$props.isNew);
|
|
};
|
|
|
|
return {
|
|
action,
|
|
onFinished,
|
|
allActions,
|
|
isNew,
|
|
optKey,
|
|
optValue,
|
|
clonedAction,
|
|
initialOptions,
|
|
errors,
|
|
addNewOption,
|
|
removeOption,
|
|
save,
|
|
cancel,
|
|
textbox0_text_binding,
|
|
textbox1_text_binding,
|
|
textbox2_text_binding,
|
|
input0_input_handler,
|
|
input1_input_handler,
|
|
click_handler
|
|
};
|
|
}
|
|
|
|
class ActionView extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$l, create_fragment$m, safe_not_equal, ["action", "onFinished", "allActions", "isNew"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.action === undefined && !('action' in props)) {
|
|
console.warn("<ActionView> was created without expected prop 'action'");
|
|
}
|
|
if (ctx.allActions === undefined && !('allActions' in props)) {
|
|
console.warn("<ActionView> was created without expected prop 'allActions'");
|
|
}
|
|
}
|
|
|
|
get action() {
|
|
throw new Error("<ActionView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set action(value) {
|
|
throw new Error("<ActionView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onFinished() {
|
|
throw new Error("<ActionView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onFinished(value) {
|
|
throw new Error("<ActionView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get allActions() {
|
|
throw new Error("<ActionView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set allActions(value) {
|
|
throw new Error("<ActionView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get isNew() {
|
|
throw new Error("<ActionView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set isNew(value) {
|
|
throw new Error("<ActionView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\actionsAndTriggers\Actions.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$o = "src\\actionsAndTriggers\\Actions.svelte";
|
|
|
|
function get_each_context$9(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.action = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (68:0) {:else}
|
|
function create_else_block$5(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("(no actions added)");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
p: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (42:0) {#if $database.actions}
|
|
function create_if_block_1$4(ctx) {
|
|
var table, thead, tr, th0, t1, th1, t3, th2, t5, th3, t7, th4, t8, tbody;
|
|
|
|
var each_value = ctx.$database.actions;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$9(get_each_context$9(ctx, each_value, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
table = element("table");
|
|
thead = element("thead");
|
|
tr = element("tr");
|
|
th0 = element("th");
|
|
th0.textContent = "Description";
|
|
t1 = space();
|
|
th1 = element("th");
|
|
th1.textContent = "Behaviour Source";
|
|
t3 = space();
|
|
th2 = element("th");
|
|
th2.textContent = "Behaviour Name";
|
|
t5 = space();
|
|
th3 = element("th");
|
|
th3.textContent = "Default Options";
|
|
t7 = space();
|
|
th4 = element("th");
|
|
t8 = space();
|
|
tbody = element("tbody");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
add_location(th0, file$o, 45, 12, 1199);
|
|
add_location(th1, file$o, 46, 12, 1233);
|
|
add_location(th2, file$o, 47, 12, 1272);
|
|
add_location(th3, file$o, 48, 12, 1309);
|
|
add_location(th4, file$o, 49, 12, 1347);
|
|
add_location(tr, file$o, 44, 8, 1181);
|
|
add_location(thead, file$o, 43, 4, 1164);
|
|
add_location(tbody, file$o, 52, 4, 1391);
|
|
attr(table, "class", "fields-table uk-table uk-table-small");
|
|
add_location(table, file$o, 42, 0, 1106);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, table, anchor);
|
|
append(table, thead);
|
|
append(thead, tr);
|
|
append(tr, th0);
|
|
append(tr, t1);
|
|
append(tr, th1);
|
|
append(tr, t3);
|
|
append(tr, th2);
|
|
append(tr, t5);
|
|
append(tr, th3);
|
|
append(tr, t7);
|
|
append(tr, th4);
|
|
append(table, t8);
|
|
append(table, tbody);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.getIcon || changed.getDefaultOptionsHtml || changed.$database) {
|
|
each_value = ctx.$database.actions;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$9(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$9(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(table);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (54:8) {#each $database.actions as action}
|
|
function create_each_block$9(ctx) {
|
|
var tr, td0, t0_value = ctx.action.name, t0, t1, td1, t2_value = ctx.action.behaviourSource, t2, t3, td2, t4_value = ctx.action.behaviourName, t4, t5, td3, raw0_value = ctx.getDefaultOptionsHtml(ctx.action.initialOptions), t6, td4, span0, raw1_value = getIcon("edit"), t7, span1, raw2_value = getIcon("trash"), t8, dispose;
|
|
|
|
function click_handler() {
|
|
return ctx.click_handler(ctx);
|
|
}
|
|
|
|
function click_handler_1() {
|
|
return ctx.click_handler_1(ctx);
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
tr = element("tr");
|
|
td0 = element("td");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
td1 = element("td");
|
|
t2 = text(t2_value);
|
|
t3 = space();
|
|
td2 = element("td");
|
|
t4 = text(t4_value);
|
|
t5 = space();
|
|
td3 = element("td");
|
|
t6 = space();
|
|
td4 = element("td");
|
|
span0 = element("span");
|
|
t7 = space();
|
|
span1 = element("span");
|
|
t8 = space();
|
|
add_location(td0, file$o, 55, 12, 1471);
|
|
add_location(td1, file$o, 56, 12, 1508);
|
|
add_location(td2, file$o, 57, 12, 1556);
|
|
add_location(td3, file$o, 58, 12, 1602);
|
|
add_location(span0, file$o, 60, 16, 1720);
|
|
add_location(span1, file$o, 61, 16, 1812);
|
|
attr(td4, "class", "edit-button svelte-12jzg4k");
|
|
add_location(td4, file$o, 59, 12, 1678);
|
|
attr(tr, "class", "svelte-12jzg4k");
|
|
add_location(tr, file$o, 54, 8, 1453);
|
|
|
|
dispose = [
|
|
listen(span0, "click", click_handler),
|
|
listen(span1, "click", click_handler_1)
|
|
];
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, tr, anchor);
|
|
append(tr, td0);
|
|
append(td0, t0);
|
|
append(tr, t1);
|
|
append(tr, td1);
|
|
append(td1, t2);
|
|
append(tr, t3);
|
|
append(tr, td2);
|
|
append(td2, t4);
|
|
append(tr, t5);
|
|
append(tr, td3);
|
|
td3.innerHTML = raw0_value;
|
|
append(tr, t6);
|
|
append(tr, td4);
|
|
append(td4, span0);
|
|
span0.innerHTML = raw1_value;
|
|
append(td4, t7);
|
|
append(td4, span1);
|
|
span1.innerHTML = raw2_value;
|
|
append(tr, t8);
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.$database) && t0_value !== (t0_value = ctx.action.name)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if ((changed.$database) && t2_value !== (t2_value = ctx.action.behaviourSource)) {
|
|
set_data(t2, t2_value);
|
|
}
|
|
|
|
if ((changed.$database) && t4_value !== (t4_value = ctx.action.behaviourName)) {
|
|
set_data(t4, t4_value);
|
|
}
|
|
|
|
if ((changed.$database) && raw0_value !== (raw0_value = ctx.getDefaultOptionsHtml(ctx.action.initialOptions))) {
|
|
td3.innerHTML = raw0_value;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(tr);
|
|
}
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (74:4) {#if isEditing}
|
|
function create_if_block$7(ctx) {
|
|
var current;
|
|
|
|
var actionview = new ActionView({
|
|
props: {
|
|
action: ctx.editingAction,
|
|
allActions: ctx.$database.actions,
|
|
onFinished: ctx.actionEditingFinished,
|
|
isNew: ctx.editingActionIsNew
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
actionview.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(actionview, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var actionview_changes = {};
|
|
if (changed.editingAction) actionview_changes.action = ctx.editingAction;
|
|
if (changed.$database) actionview_changes.allActions = ctx.$database.actions;
|
|
if (changed.actionEditingFinished) actionview_changes.onFinished = ctx.actionEditingFinished;
|
|
if (changed.editingActionIsNew) actionview_changes.isNew = ctx.editingActionIsNew;
|
|
actionview.$set(actionview_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(actionview.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(actionview.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(actionview, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (73:0) <Modal bind:isOpen={isEditing}>
|
|
function create_default_slot$4(ctx) {
|
|
var if_block_anchor, current;
|
|
|
|
var if_block = (ctx.isEditing) && create_if_block$7(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
if (if_block) if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
if (if_block) if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (ctx.isEditing) {
|
|
if (if_block) {
|
|
if_block.p(changed, ctx);
|
|
transition_in(if_block, 1);
|
|
} else {
|
|
if_block = create_if_block$7(ctx);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (if_block) if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(if_block_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$n(ctx) {
|
|
var h3, t1, t2, updating_isOpen, current;
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.$database.actions) return create_if_block_1$4;
|
|
return create_else_block$5;
|
|
}
|
|
|
|
var current_block_type = select_block_type(ctx);
|
|
var if_block = current_block_type(ctx);
|
|
|
|
function modal_isOpen_binding(value) {
|
|
ctx.modal_isOpen_binding.call(null, value);
|
|
updating_isOpen = true;
|
|
add_flush_callback(() => updating_isOpen = false);
|
|
}
|
|
|
|
let modal_props = {
|
|
$$slots: { default: [create_default_slot$4] },
|
|
$$scope: { ctx }
|
|
};
|
|
if (ctx.isEditing !== void 0) {
|
|
modal_props.isOpen = ctx.isEditing;
|
|
}
|
|
var modal = new Modal({ props: modal_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(modal, 'isOpen', modal_isOpen_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
h3 = element("h3");
|
|
h3.textContent = "Actions";
|
|
t1 = space();
|
|
if_block.c();
|
|
t2 = space();
|
|
modal.$$.fragment.c();
|
|
add_location(h3, file$o, 39, 0, 1061);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, h3, anchor);
|
|
insert(target, t1, anchor);
|
|
if_block.m(target, anchor);
|
|
insert(target, t2, anchor);
|
|
mount_component(modal, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
|
|
if_block.p(changed, ctx);
|
|
} else {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(t2.parentNode, t2);
|
|
}
|
|
}
|
|
|
|
var modal_changes = {};
|
|
if (changed.$$scope || changed.isEditing || changed.editingAction || changed.$database || changed.editingActionIsNew) modal_changes.$$scope = { changed, ctx };
|
|
if (!updating_isOpen && changed.isEditing) {
|
|
modal_changes.isOpen = ctx.isEditing;
|
|
}
|
|
modal.$set(modal_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(modal.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(modal.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(h3);
|
|
detach(t1);
|
|
}
|
|
|
|
if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(t2);
|
|
}
|
|
|
|
destroy_component(modal, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$m($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
let { editingActionIsNew = false, editingAction = null, onActionEdit = (action) => {} } = $$props;
|
|
let { onActionDelete = (action) => {} } = $$props;
|
|
let { onActionSave = (action) => {} } = $$props;
|
|
let { onActionCancel = () => {} } = $$props;
|
|
|
|
let getDefaultOptionsHtml = defaultOptions =>
|
|
chain(defaultOptions, [
|
|
fp.keys,
|
|
fp.map(k => `<span style="color:var(--slate)">${k}: </span>${JSON.stringify(defaultOptions[k])}`),
|
|
fp.join("<br>")
|
|
]);
|
|
|
|
|
|
let actionEditingFinished = (action) => {
|
|
|
|
if(action) {
|
|
onActionSave(action);
|
|
} else {
|
|
onActionCancel();
|
|
}
|
|
};
|
|
|
|
const writable_props = ['editingActionIsNew', 'editingAction', 'onActionEdit', 'onActionDelete', 'onActionSave', 'onActionCancel'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Actions> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function click_handler({ action }) {
|
|
return onActionEdit(action);
|
|
}
|
|
|
|
function click_handler_1({ action }) {
|
|
return onActionDelete(action);
|
|
}
|
|
|
|
function modal_isOpen_binding(value) {
|
|
isEditing = value;
|
|
$$invalidate('isEditing', isEditing), $$invalidate('editingAction', editingAction);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('editingActionIsNew' in $$props) $$invalidate('editingActionIsNew', editingActionIsNew = $$props.editingActionIsNew);
|
|
if ('editingAction' in $$props) $$invalidate('editingAction', editingAction = $$props.editingAction);
|
|
if ('onActionEdit' in $$props) $$invalidate('onActionEdit', onActionEdit = $$props.onActionEdit);
|
|
if ('onActionDelete' in $$props) $$invalidate('onActionDelete', onActionDelete = $$props.onActionDelete);
|
|
if ('onActionSave' in $$props) $$invalidate('onActionSave', onActionSave = $$props.onActionSave);
|
|
if ('onActionCancel' in $$props) $$invalidate('onActionCancel', onActionCancel = $$props.onActionCancel);
|
|
};
|
|
|
|
let isEditing;
|
|
|
|
$$self.$$.update = ($$dirty = { editingAction: 1 }) => {
|
|
if ($$dirty.editingAction) { $$invalidate('isEditing', isEditing = (editingAction !== null)); }
|
|
};
|
|
|
|
return {
|
|
editingActionIsNew,
|
|
editingAction,
|
|
onActionEdit,
|
|
onActionDelete,
|
|
onActionSave,
|
|
onActionCancel,
|
|
getDefaultOptionsHtml,
|
|
actionEditingFinished,
|
|
isEditing,
|
|
$database,
|
|
click_handler,
|
|
click_handler_1,
|
|
modal_isOpen_binding
|
|
};
|
|
}
|
|
|
|
class Actions extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$m, create_fragment$n, safe_not_equal, ["editingActionIsNew", "editingAction", "onActionEdit", "onActionDelete", "onActionSave", "onActionCancel"]);
|
|
}
|
|
|
|
get editingActionIsNew() {
|
|
throw new Error("<Actions>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set editingActionIsNew(value) {
|
|
throw new Error("<Actions>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get editingAction() {
|
|
throw new Error("<Actions>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set editingAction(value) {
|
|
throw new Error("<Actions>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onActionEdit() {
|
|
throw new Error("<Actions>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onActionEdit(value) {
|
|
throw new Error("<Actions>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onActionDelete() {
|
|
throw new Error("<Actions>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onActionDelete(value) {
|
|
throw new Error("<Actions>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onActionSave() {
|
|
throw new Error("<Actions>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onActionSave(value) {
|
|
throw new Error("<Actions>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onActionCancel() {
|
|
throw new Error("<Actions>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onActionCancel(value) {
|
|
throw new Error("<Actions>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\actionsAndTriggers\TriggerView.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$p = "src\\actionsAndTriggers\\TriggerView.svelte";
|
|
|
|
// (56:8) <Button grouped on:click={save}>
|
|
function create_default_slot_2$3(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Save");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (57:8) <Button grouped on:click={cancel}>
|
|
function create_default_slot_1$3(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Cancel");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (55:4) <ButtonGroup>
|
|
function create_default_slot$5(ctx) {
|
|
var t, current;
|
|
|
|
var button0 = new Button({
|
|
props: {
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_2$3] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button0.$on("click", ctx.save);
|
|
|
|
var button1 = new Button({
|
|
props: {
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_1$3] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button1.$on("click", ctx.cancel);
|
|
|
|
return {
|
|
c: function create() {
|
|
button0.$$.fragment.c();
|
|
t = space();
|
|
button1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(button1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var button0_changes = {};
|
|
if (changed.$$scope) button0_changes.$$scope = { changed, ctx };
|
|
button0.$set(button0_changes);
|
|
|
|
var button1_changes = {};
|
|
if (changed.$$scope) button1_changes.$$scope = { changed, ctx };
|
|
button1.$set(button1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button0.$$.fragment, local);
|
|
|
|
transition_in(button1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button0.$$.fragment, local);
|
|
transition_out(button1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(button1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$o(ctx) {
|
|
var div, t0, updating_selected, t1, updating_selected_1, t2, updating_text, t3, updating_text_1, t4, current;
|
|
|
|
var errorsbox = new ErrorsBox({
|
|
props: {
|
|
errors: ctx.errors,
|
|
style: "margin-bottom:20px"
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
function dropdown0_selected_binding(value) {
|
|
ctx.dropdown0_selected_binding.call(null, value);
|
|
updating_selected = true;
|
|
add_flush_callback(() => updating_selected = false);
|
|
}
|
|
|
|
let dropdown0_props = { label: "Event", options: ["",...events$1] };
|
|
if (ctx.clonedTrigger.eventName !== void 0) {
|
|
dropdown0_props.selected = ctx.clonedTrigger.eventName;
|
|
}
|
|
var dropdown0 = new Dropdown({ props: dropdown0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(dropdown0, 'selected', dropdown0_selected_binding));
|
|
|
|
function dropdown1_selected_binding(value_1) {
|
|
ctx.dropdown1_selected_binding.call(null, value_1);
|
|
updating_selected_1 = true;
|
|
add_flush_callback(() => updating_selected_1 = false);
|
|
}
|
|
|
|
let dropdown1_props = { label: "Action", options: ["",...ctx.actionNames] };
|
|
if (ctx.clonedTrigger.actionName !== void 0) {
|
|
dropdown1_props.selected = ctx.clonedTrigger.actionName;
|
|
}
|
|
var dropdown1 = new Dropdown({ props: dropdown1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(dropdown1, 'selected', dropdown1_selected_binding));
|
|
|
|
function codearea0_text_binding(value_2) {
|
|
ctx.codearea0_text_binding.call(null, value_2);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let codearea0_props = { label: "Condition (javascript)" };
|
|
if (ctx.clonedTrigger.condition !== void 0) {
|
|
codearea0_props.text = ctx.clonedTrigger.condition;
|
|
}
|
|
var codearea0 = new CodeArea({ props: codearea0_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(codearea0, 'text', codearea0_text_binding));
|
|
|
|
function codearea1_text_binding(value_3) {
|
|
ctx.codearea1_text_binding.call(null, value_3);
|
|
updating_text_1 = true;
|
|
add_flush_callback(() => updating_text_1 = false);
|
|
}
|
|
|
|
let codearea1_props = {
|
|
label: "Action Options Creator (javascript)"
|
|
};
|
|
if (ctx.clonedTrigger.optionsCreator !== void 0) {
|
|
codearea1_props.text = ctx.clonedTrigger.optionsCreator;
|
|
}
|
|
var codearea1 = new CodeArea({ props: codearea1_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(codearea1, 'text', codearea1_text_binding));
|
|
|
|
var buttongroup = new ButtonGroup({
|
|
props: {
|
|
$$slots: { default: [create_default_slot$5] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
errorsbox.$$.fragment.c();
|
|
t0 = space();
|
|
dropdown0.$$.fragment.c();
|
|
t1 = space();
|
|
dropdown1.$$.fragment.c();
|
|
t2 = space();
|
|
codearea0.$$.fragment.c();
|
|
t3 = space();
|
|
codearea1.$$.fragment.c();
|
|
t4 = space();
|
|
buttongroup.$$.fragment.c();
|
|
add_location(div, file$p, 39, 0, 1184);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(errorsbox, div, null);
|
|
append(div, t0);
|
|
mount_component(dropdown0, div, null);
|
|
append(div, t1);
|
|
mount_component(dropdown1, div, null);
|
|
append(div, t2);
|
|
mount_component(codearea0, div, null);
|
|
append(div, t3);
|
|
mount_component(codearea1, div, null);
|
|
append(div, t4);
|
|
mount_component(buttongroup, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var errorsbox_changes = {};
|
|
if (changed.errors) errorsbox_changes.errors = ctx.errors;
|
|
errorsbox.$set(errorsbox_changes);
|
|
|
|
var dropdown0_changes = {};
|
|
if (changed.events) dropdown0_changes.options = ["",...events$1];
|
|
if (!updating_selected && changed.clonedTrigger) {
|
|
dropdown0_changes.selected = ctx.clonedTrigger.eventName;
|
|
}
|
|
dropdown0.$set(dropdown0_changes);
|
|
|
|
var dropdown1_changes = {};
|
|
if (changed.actionNames) dropdown1_changes.options = ["",...ctx.actionNames];
|
|
if (!updating_selected_1 && changed.clonedTrigger) {
|
|
dropdown1_changes.selected = ctx.clonedTrigger.actionName;
|
|
}
|
|
dropdown1.$set(dropdown1_changes);
|
|
|
|
var codearea0_changes = {};
|
|
if (!updating_text && changed.clonedTrigger) {
|
|
codearea0_changes.text = ctx.clonedTrigger.condition;
|
|
}
|
|
codearea0.$set(codearea0_changes);
|
|
|
|
var codearea1_changes = {};
|
|
if (!updating_text_1 && changed.clonedTrigger) {
|
|
codearea1_changes.text = ctx.clonedTrigger.optionsCreator;
|
|
}
|
|
codearea1.$set(codearea1_changes);
|
|
|
|
var buttongroup_changes = {};
|
|
if (changed.$$scope) buttongroup_changes.$$scope = { changed, ctx };
|
|
buttongroup.$set(buttongroup_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(errorsbox.$$.fragment, local);
|
|
|
|
transition_in(dropdown0.$$.fragment, local);
|
|
|
|
transition_in(dropdown1.$$.fragment, local);
|
|
|
|
transition_in(codearea0.$$.fragment, local);
|
|
|
|
transition_in(codearea1.$$.fragment, local);
|
|
|
|
transition_in(buttongroup.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(errorsbox.$$.fragment, local);
|
|
transition_out(dropdown0.$$.fragment, local);
|
|
transition_out(dropdown1.$$.fragment, local);
|
|
transition_out(codearea0.$$.fragment, local);
|
|
transition_out(codearea1.$$.fragment, local);
|
|
transition_out(buttongroup.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(errorsbox);
|
|
|
|
destroy_component(dropdown0);
|
|
|
|
destroy_component(dropdown1);
|
|
|
|
destroy_component(codearea0);
|
|
|
|
destroy_component(codearea1);
|
|
|
|
destroy_component(buttongroup);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$n($$self, $$props, $$invalidate) {
|
|
|
|
|
|
let { trigger, onFinished = (action) => {} } = $$props;
|
|
let { allTriggers, allActions, isNew = true } = $$props;
|
|
|
|
let clonedTrigger = fp.cloneDeep(trigger);
|
|
let errors = [];
|
|
|
|
let cancel = () => onFinished();
|
|
let save = () => {
|
|
const newTriggersList = [
|
|
...chain(allTriggers ,[fp.filter(t => t !== trigger)]),
|
|
clonedTrigger];
|
|
|
|
$$invalidate('errors', errors = validateTriggers$1(newTriggersList, allActions));
|
|
|
|
const test = fp.map(t =>(!t.actionName || fp.some(a => a.name === t.actionName)(allActions)))(newTriggersList);
|
|
|
|
if(errors.length === 0)
|
|
onFinished(clonedTrigger);
|
|
};
|
|
|
|
const writable_props = ['trigger', 'onFinished', 'allTriggers', 'allActions', 'isNew'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<TriggerView> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function dropdown0_selected_binding(value) {
|
|
clonedTrigger.eventName = value;
|
|
$$invalidate('clonedTrigger', clonedTrigger);
|
|
}
|
|
|
|
function dropdown1_selected_binding(value_1) {
|
|
clonedTrigger.actionName = value_1;
|
|
$$invalidate('clonedTrigger', clonedTrigger);
|
|
}
|
|
|
|
function codearea0_text_binding(value_2) {
|
|
clonedTrigger.condition = value_2;
|
|
$$invalidate('clonedTrigger', clonedTrigger);
|
|
}
|
|
|
|
function codearea1_text_binding(value_3) {
|
|
clonedTrigger.optionsCreator = value_3;
|
|
$$invalidate('clonedTrigger', clonedTrigger);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('trigger' in $$props) $$invalidate('trigger', trigger = $$props.trigger);
|
|
if ('onFinished' in $$props) $$invalidate('onFinished', onFinished = $$props.onFinished);
|
|
if ('allTriggers' in $$props) $$invalidate('allTriggers', allTriggers = $$props.allTriggers);
|
|
if ('allActions' in $$props) $$invalidate('allActions', allActions = $$props.allActions);
|
|
if ('isNew' in $$props) $$invalidate('isNew', isNew = $$props.isNew);
|
|
};
|
|
|
|
let actionNames;
|
|
|
|
$$self.$$.update = ($$dirty = { allActions: 1 }) => {
|
|
if ($$dirty.allActions) { $$invalidate('actionNames', actionNames = fp.map(a => a.name)(allActions)); }
|
|
};
|
|
|
|
return {
|
|
trigger,
|
|
onFinished,
|
|
allTriggers,
|
|
allActions,
|
|
isNew,
|
|
clonedTrigger,
|
|
errors,
|
|
cancel,
|
|
save,
|
|
actionNames,
|
|
dropdown0_selected_binding,
|
|
dropdown1_selected_binding,
|
|
codearea0_text_binding,
|
|
codearea1_text_binding
|
|
};
|
|
}
|
|
|
|
class TriggerView extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$n, create_fragment$o, safe_not_equal, ["trigger", "onFinished", "allTriggers", "allActions", "isNew"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.trigger === undefined && !('trigger' in props)) {
|
|
console.warn("<TriggerView> was created without expected prop 'trigger'");
|
|
}
|
|
if (ctx.allTriggers === undefined && !('allTriggers' in props)) {
|
|
console.warn("<TriggerView> was created without expected prop 'allTriggers'");
|
|
}
|
|
if (ctx.allActions === undefined && !('allActions' in props)) {
|
|
console.warn("<TriggerView> was created without expected prop 'allActions'");
|
|
}
|
|
}
|
|
|
|
get trigger() {
|
|
throw new Error("<TriggerView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set trigger(value) {
|
|
throw new Error("<TriggerView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onFinished() {
|
|
throw new Error("<TriggerView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onFinished(value) {
|
|
throw new Error("<TriggerView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get allTriggers() {
|
|
throw new Error("<TriggerView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set allTriggers(value) {
|
|
throw new Error("<TriggerView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get allActions() {
|
|
throw new Error("<TriggerView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set allActions(value) {
|
|
throw new Error("<TriggerView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get isNew() {
|
|
throw new Error("<TriggerView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set isNew(value) {
|
|
throw new Error("<TriggerView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\actionsAndTriggers\Triggers.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$q = "src\\actionsAndTriggers\\Triggers.svelte";
|
|
|
|
function get_each_context$a(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.trigger = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (58:0) {:else}
|
|
function create_else_block$6(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("(no triggers added)");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
p: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (32:0) {#if $database.triggers}
|
|
function create_if_block_1$5(ctx) {
|
|
var table, thead, tr, th0, t1, th1, t3, th2, t5, th3, t7, th4, t8, tbody;
|
|
|
|
var each_value = ctx.$database.triggers;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$a(get_each_context$a(ctx, each_value, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
table = element("table");
|
|
thead = element("thead");
|
|
tr = element("tr");
|
|
th0 = element("th");
|
|
th0.textContent = "Event";
|
|
t1 = space();
|
|
th1 = element("th");
|
|
th1.textContent = "Action";
|
|
t3 = space();
|
|
th2 = element("th");
|
|
th2.textContent = "Condition";
|
|
t5 = space();
|
|
th3 = element("th");
|
|
th3.textContent = "Create Options";
|
|
t7 = space();
|
|
th4 = element("th");
|
|
t8 = space();
|
|
tbody = element("tbody");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
add_location(th0, file$q, 35, 12, 848);
|
|
add_location(th1, file$q, 36, 12, 876);
|
|
add_location(th2, file$q, 37, 12, 905);
|
|
add_location(th3, file$q, 38, 12, 937);
|
|
add_location(th4, file$q, 39, 12, 974);
|
|
add_location(tr, file$q, 34, 8, 830);
|
|
add_location(thead, file$q, 33, 4, 813);
|
|
add_location(tbody, file$q, 42, 4, 1018);
|
|
attr(table, "class", "fields-table uk-table uk-table-small");
|
|
add_location(table, file$q, 32, 0, 755);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, table, anchor);
|
|
append(table, thead);
|
|
append(thead, tr);
|
|
append(tr, th0);
|
|
append(tr, t1);
|
|
append(tr, th1);
|
|
append(tr, t3);
|
|
append(tr, th2);
|
|
append(tr, t5);
|
|
append(tr, th3);
|
|
append(tr, t7);
|
|
append(tr, th4);
|
|
append(table, t8);
|
|
append(table, tbody);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.getIcon || changed.$database) {
|
|
each_value = ctx.$database.triggers;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$a(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$a(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(table);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (44:8) {#each $database.triggers as trigger}
|
|
function create_each_block$a(ctx) {
|
|
var tr, td0, t0_value = ctx.trigger.eventName, t0, t1, td1, t2_value = ctx.trigger.actionName, t2, t3, td2, t4_value = ctx.trigger.condition, t4, t5, td3, t6_value = ctx.trigger.optionsCreator, t6, t7, td4, span0, raw0_value = getIcon("edit"), t8, span1, raw1_value = getIcon("trash"), t9, dispose;
|
|
|
|
function click_handler() {
|
|
return ctx.click_handler(ctx);
|
|
}
|
|
|
|
function click_handler_1() {
|
|
return ctx.click_handler_1(ctx);
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
tr = element("tr");
|
|
td0 = element("td");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
td1 = element("td");
|
|
t2 = text(t2_value);
|
|
t3 = space();
|
|
td2 = element("td");
|
|
t4 = text(t4_value);
|
|
t5 = space();
|
|
td3 = element("td");
|
|
t6 = text(t6_value);
|
|
t7 = space();
|
|
td4 = element("td");
|
|
span0 = element("span");
|
|
t8 = space();
|
|
span1 = element("span");
|
|
t9 = space();
|
|
add_location(td0, file$q, 45, 12, 1100);
|
|
add_location(td1, file$q, 46, 12, 1143);
|
|
add_location(td2, file$q, 47, 12, 1187);
|
|
add_location(td3, file$q, 48, 12, 1230);
|
|
add_location(span0, file$q, 50, 16, 1320);
|
|
add_location(span1, file$q, 51, 16, 1414);
|
|
attr(td4, "class", "edit-button svelte-1le5bpl");
|
|
add_location(td4, file$q, 49, 12, 1278);
|
|
attr(tr, "class", "svelte-1le5bpl");
|
|
add_location(tr, file$q, 44, 8, 1082);
|
|
|
|
dispose = [
|
|
listen(span0, "click", click_handler),
|
|
listen(span1, "click", click_handler_1)
|
|
];
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, tr, anchor);
|
|
append(tr, td0);
|
|
append(td0, t0);
|
|
append(tr, t1);
|
|
append(tr, td1);
|
|
append(td1, t2);
|
|
append(tr, t3);
|
|
append(tr, td2);
|
|
append(td2, t4);
|
|
append(tr, t5);
|
|
append(tr, td3);
|
|
append(td3, t6);
|
|
append(tr, t7);
|
|
append(tr, td4);
|
|
append(td4, span0);
|
|
span0.innerHTML = raw0_value;
|
|
append(td4, t8);
|
|
append(td4, span1);
|
|
span1.innerHTML = raw1_value;
|
|
append(tr, t9);
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.$database) && t0_value !== (t0_value = ctx.trigger.eventName)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if ((changed.$database) && t2_value !== (t2_value = ctx.trigger.actionName)) {
|
|
set_data(t2, t2_value);
|
|
}
|
|
|
|
if ((changed.$database) && t4_value !== (t4_value = ctx.trigger.condition)) {
|
|
set_data(t4, t4_value);
|
|
}
|
|
|
|
if ((changed.$database) && t6_value !== (t6_value = ctx.trigger.optionsCreator)) {
|
|
set_data(t6, t6_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(tr);
|
|
}
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (64:4) {#if isEditing}
|
|
function create_if_block$8(ctx) {
|
|
var current;
|
|
|
|
var triggerview = new TriggerView({
|
|
props: {
|
|
trigger: ctx.editingTrigger,
|
|
allActions: ctx.$database.actions,
|
|
allTriggers: ctx.$database.triggers,
|
|
onFinished: ctx.triggerEditingFinished,
|
|
isNew: ctx.editingTriggerIsNew
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
triggerview.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(triggerview, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var triggerview_changes = {};
|
|
if (changed.editingTrigger) triggerview_changes.trigger = ctx.editingTrigger;
|
|
if (changed.$database) triggerview_changes.allActions = ctx.$database.actions;
|
|
if (changed.$database) triggerview_changes.allTriggers = ctx.$database.triggers;
|
|
if (changed.triggerEditingFinished) triggerview_changes.onFinished = ctx.triggerEditingFinished;
|
|
if (changed.editingTriggerIsNew) triggerview_changes.isNew = ctx.editingTriggerIsNew;
|
|
triggerview.$set(triggerview_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(triggerview.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(triggerview.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(triggerview, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (63:0) <Modal bind:isOpen={isEditing}>
|
|
function create_default_slot$6(ctx) {
|
|
var if_block_anchor, current;
|
|
|
|
var if_block = (ctx.isEditing) && create_if_block$8(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
if (if_block) if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
if (if_block) if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (ctx.isEditing) {
|
|
if (if_block) {
|
|
if_block.p(changed, ctx);
|
|
transition_in(if_block, 1);
|
|
} else {
|
|
if_block = create_if_block$8(ctx);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (if_block) if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(if_block_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$p(ctx) {
|
|
var h3, t1, t2, updating_isOpen, current;
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.$database.triggers) return create_if_block_1$5;
|
|
return create_else_block$6;
|
|
}
|
|
|
|
var current_block_type = select_block_type(ctx);
|
|
var if_block = current_block_type(ctx);
|
|
|
|
function modal_isOpen_binding(value) {
|
|
ctx.modal_isOpen_binding.call(null, value);
|
|
updating_isOpen = true;
|
|
add_flush_callback(() => updating_isOpen = false);
|
|
}
|
|
|
|
let modal_props = {
|
|
$$slots: { default: [create_default_slot$6] },
|
|
$$scope: { ctx }
|
|
};
|
|
if (ctx.isEditing !== void 0) {
|
|
modal_props.isOpen = ctx.isEditing;
|
|
}
|
|
var modal = new Modal({ props: modal_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(modal, 'isOpen', modal_isOpen_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
h3 = element("h3");
|
|
h3.textContent = "Triggers";
|
|
t1 = space();
|
|
if_block.c();
|
|
t2 = space();
|
|
modal.$$.fragment.c();
|
|
add_location(h3, file$q, 29, 0, 708);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, h3, anchor);
|
|
insert(target, t1, anchor);
|
|
if_block.m(target, anchor);
|
|
insert(target, t2, anchor);
|
|
mount_component(modal, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
|
|
if_block.p(changed, ctx);
|
|
} else {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(t2.parentNode, t2);
|
|
}
|
|
}
|
|
|
|
var modal_changes = {};
|
|
if (changed.$$scope || changed.isEditing || changed.editingTrigger || changed.$database || changed.editingTriggerIsNew) modal_changes.$$scope = { changed, ctx };
|
|
if (!updating_isOpen && changed.isEditing) {
|
|
modal_changes.isOpen = ctx.isEditing;
|
|
}
|
|
modal.$set(modal_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(modal.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(modal.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(h3);
|
|
detach(t1);
|
|
}
|
|
|
|
if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(t2);
|
|
}
|
|
|
|
destroy_component(modal, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$o($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
|
|
let { editingTrigger = null, editingTriggerIsNew = true, onTriggerEdit = (trigger) => {} } = $$props;
|
|
let { onTriggerDelete = (trigger) => {} } = $$props;
|
|
let { onTriggerSave = (trigger) => {} } = $$props;
|
|
let { onTriggerCancel = () => {} } = $$props;
|
|
|
|
let triggerEditingFinished = (trigger) => {
|
|
|
|
if(trigger) {
|
|
onTriggerSave(trigger);
|
|
} else {
|
|
onTriggerCancel();
|
|
}
|
|
};
|
|
|
|
const writable_props = ['editingTrigger', 'editingTriggerIsNew', 'onTriggerEdit', 'onTriggerDelete', 'onTriggerSave', 'onTriggerCancel'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<Triggers> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function click_handler({ trigger }) {
|
|
return onTriggerEdit(trigger);
|
|
}
|
|
|
|
function click_handler_1({ trigger }) {
|
|
return onTriggerDelete(trigger);
|
|
}
|
|
|
|
function modal_isOpen_binding(value) {
|
|
isEditing = value;
|
|
$$invalidate('isEditing', isEditing), $$invalidate('editingTrigger', editingTrigger);
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('editingTrigger' in $$props) $$invalidate('editingTrigger', editingTrigger = $$props.editingTrigger);
|
|
if ('editingTriggerIsNew' in $$props) $$invalidate('editingTriggerIsNew', editingTriggerIsNew = $$props.editingTriggerIsNew);
|
|
if ('onTriggerEdit' in $$props) $$invalidate('onTriggerEdit', onTriggerEdit = $$props.onTriggerEdit);
|
|
if ('onTriggerDelete' in $$props) $$invalidate('onTriggerDelete', onTriggerDelete = $$props.onTriggerDelete);
|
|
if ('onTriggerSave' in $$props) $$invalidate('onTriggerSave', onTriggerSave = $$props.onTriggerSave);
|
|
if ('onTriggerCancel' in $$props) $$invalidate('onTriggerCancel', onTriggerCancel = $$props.onTriggerCancel);
|
|
};
|
|
|
|
let isEditing;
|
|
|
|
$$self.$$.update = ($$dirty = { editingTrigger: 1 }) => {
|
|
if ($$dirty.editingTrigger) { $$invalidate('isEditing', isEditing = (editingTrigger !== null)); }
|
|
};
|
|
|
|
return {
|
|
editingTrigger,
|
|
editingTriggerIsNew,
|
|
onTriggerEdit,
|
|
onTriggerDelete,
|
|
onTriggerSave,
|
|
onTriggerCancel,
|
|
triggerEditingFinished,
|
|
isEditing,
|
|
$database,
|
|
click_handler,
|
|
click_handler_1,
|
|
modal_isOpen_binding
|
|
};
|
|
}
|
|
|
|
class Triggers extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$o, create_fragment$p, safe_not_equal, ["editingTrigger", "editingTriggerIsNew", "onTriggerEdit", "onTriggerDelete", "onTriggerSave", "onTriggerCancel"]);
|
|
}
|
|
|
|
get editingTrigger() {
|
|
throw new Error("<Triggers>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set editingTrigger(value) {
|
|
throw new Error("<Triggers>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get editingTriggerIsNew() {
|
|
throw new Error("<Triggers>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set editingTriggerIsNew(value) {
|
|
throw new Error("<Triggers>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onTriggerEdit() {
|
|
throw new Error("<Triggers>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onTriggerEdit(value) {
|
|
throw new Error("<Triggers>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onTriggerDelete() {
|
|
throw new Error("<Triggers>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onTriggerDelete(value) {
|
|
throw new Error("<Triggers>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onTriggerSave() {
|
|
throw new Error("<Triggers>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onTriggerSave(value) {
|
|
throw new Error("<Triggers>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onTriggerCancel() {
|
|
throw new Error("<Triggers>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onTriggerCancel(value) {
|
|
throw new Error("<Triggers>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\actionsAndTriggers\ActionsAndTriggersRoot.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$r = "src\\actionsAndTriggers\\ActionsAndTriggersRoot.svelte";
|
|
|
|
// (90:4) <Button color="secondary" grouped on:click={newAction}>
|
|
function create_default_slot_2$4(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Create New Action");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (93:4) <Button color="secondary" grouped on:click={newTrigger}>
|
|
function create_default_slot_1$4(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Create New Trigger");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (89:0) <ButtonGroup>
|
|
function create_default_slot$7(ctx) {
|
|
var t, current;
|
|
|
|
var button0 = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_2$4] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button0.$on("click", ctx.newAction);
|
|
|
|
var button1 = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_1$4] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button1.$on("click", ctx.newTrigger);
|
|
|
|
return {
|
|
c: function create() {
|
|
button0.$$.fragment.c();
|
|
t = space();
|
|
button1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(button1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var button0_changes = {};
|
|
if (changed.$$scope) button0_changes.$$scope = { changed, ctx };
|
|
button0.$set(button0_changes);
|
|
|
|
var button1_changes = {};
|
|
if (changed.$$scope) button1_changes.$$scope = { changed, ctx };
|
|
button1.$set(button1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button0.$$.fragment, local);
|
|
|
|
transition_in(button1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button0.$$.fragment, local);
|
|
transition_out(button1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(button1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$q(ctx) {
|
|
var div, t0, t1, current;
|
|
|
|
var buttongroup = new ButtonGroup({
|
|
props: {
|
|
$$slots: { default: [create_default_slot$7] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
var actions = new Actions({
|
|
props: {
|
|
editingActionIsNew: ctx.editingActionIsNew,
|
|
editingAction: ctx.editingAction,
|
|
onActionEdit: ctx.onActionEdit,
|
|
onActionDelete: ctx.onActionDelete,
|
|
onActionSave: ctx.onActionSave,
|
|
onActionCancel: ctx.onActionCancel
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
var triggers = new Triggers({
|
|
props: {
|
|
editingTriggerIsNew: ctx.editingTriggerIsNew,
|
|
editingTrigger: ctx.editingTrigger,
|
|
onTriggerEdit: ctx.onTriggerEdit,
|
|
onTriggerDelete: ctx.onTriggerDelete,
|
|
onTriggerSave: ctx.onTriggerSave,
|
|
onTriggerCancel: ctx.onTriggerCancel
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
buttongroup.$$.fragment.c();
|
|
t0 = space();
|
|
actions.$$.fragment.c();
|
|
t1 = space();
|
|
triggers.$$.fragment.c();
|
|
attr(div, "class", "root svelte-1y6dy5x");
|
|
add_location(div, file$r, 86, 0, 1895);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(buttongroup, div, null);
|
|
append(div, t0);
|
|
mount_component(actions, div, null);
|
|
append(div, t1);
|
|
mount_component(triggers, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var buttongroup_changes = {};
|
|
if (changed.$$scope) buttongroup_changes.$$scope = { changed, ctx };
|
|
buttongroup.$set(buttongroup_changes);
|
|
|
|
var actions_changes = {};
|
|
if (changed.editingActionIsNew) actions_changes.editingActionIsNew = ctx.editingActionIsNew;
|
|
if (changed.editingAction) actions_changes.editingAction = ctx.editingAction;
|
|
if (changed.onActionEdit) actions_changes.onActionEdit = ctx.onActionEdit;
|
|
if (changed.onActionDelete) actions_changes.onActionDelete = ctx.onActionDelete;
|
|
if (changed.onActionSave) actions_changes.onActionSave = ctx.onActionSave;
|
|
if (changed.onActionCancel) actions_changes.onActionCancel = ctx.onActionCancel;
|
|
actions.$set(actions_changes);
|
|
|
|
var triggers_changes = {};
|
|
if (changed.editingTriggerIsNew) triggers_changes.editingTriggerIsNew = ctx.editingTriggerIsNew;
|
|
if (changed.editingTrigger) triggers_changes.editingTrigger = ctx.editingTrigger;
|
|
if (changed.onTriggerEdit) triggers_changes.onTriggerEdit = ctx.onTriggerEdit;
|
|
if (changed.onTriggerDelete) triggers_changes.onTriggerDelete = ctx.onTriggerDelete;
|
|
if (changed.onTriggerSave) triggers_changes.onTriggerSave = ctx.onTriggerSave;
|
|
if (changed.onTriggerCancel) triggers_changes.onTriggerCancel = ctx.onTriggerCancel;
|
|
triggers.$set(triggers_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(buttongroup.$$.fragment, local);
|
|
|
|
transition_in(actions.$$.fragment, local);
|
|
|
|
transition_in(triggers.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(buttongroup.$$.fragment, local);
|
|
transition_out(actions.$$.fragment, local);
|
|
transition_out(triggers.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(buttongroup);
|
|
|
|
destroy_component(actions);
|
|
|
|
destroy_component(triggers);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$p($$self, $$props, $$invalidate) {
|
|
|
|
|
|
let editingAction = null;
|
|
let editingActionIsNew = true;
|
|
let editingTrigger = null;
|
|
let editingTriggerIsNew = true;
|
|
|
|
let onActionEdit = (action) => {
|
|
$$invalidate('editingAction', editingAction = action);
|
|
$$invalidate('editingActionIsNew', editingActionIsNew = false);
|
|
};
|
|
|
|
let newAction = () => {
|
|
$$invalidate('editingAction', editingAction = getNewAction());
|
|
$$invalidate('editingActionIsNew', editingActionIsNew = true);
|
|
};
|
|
|
|
let onActionDelete = (action) => {
|
|
database.deleteAction(action);
|
|
};
|
|
|
|
let newTrigger = () => {
|
|
$$invalidate('editingTrigger', editingTrigger = getNewTrigger());
|
|
$$invalidate('editingTriggerIsNew', editingTriggerIsNew = true);
|
|
};
|
|
|
|
let onActionSave = action => {
|
|
database.saveAction(
|
|
action,
|
|
editingActionIsNew,
|
|
editingAction);
|
|
|
|
$$invalidate('editingAction', editingAction = null);
|
|
};
|
|
|
|
let onActionCancel = () => {
|
|
$$invalidate('editingAction', editingAction = null);
|
|
};
|
|
|
|
let onTriggerSave = trigger => {
|
|
database.saveTrigger(
|
|
trigger,
|
|
editingTriggerIsNew,
|
|
editingTrigger);
|
|
|
|
$$invalidate('editingTrigger', editingTrigger = null);
|
|
};
|
|
|
|
let onTriggerCancel = () => {
|
|
$$invalidate('editingTrigger', editingTrigger = null);
|
|
};
|
|
|
|
let onTriggerEdit = (trigger) => {
|
|
$$invalidate('editingTrigger', editingTrigger = trigger);
|
|
$$invalidate('editingTriggerIsNew', editingTriggerIsNew = false);
|
|
};
|
|
|
|
|
|
let onTriggerDelete = (trigger) => {
|
|
database.deleteTrigger(trigger);
|
|
};
|
|
|
|
return {
|
|
editingAction,
|
|
editingActionIsNew,
|
|
editingTrigger,
|
|
editingTriggerIsNew,
|
|
onActionEdit,
|
|
newAction,
|
|
onActionDelete,
|
|
newTrigger,
|
|
onActionSave,
|
|
onActionCancel,
|
|
onTriggerSave,
|
|
onTriggerCancel,
|
|
onTriggerEdit,
|
|
onTriggerDelete
|
|
};
|
|
}
|
|
|
|
class ActionsAndTriggersRoot extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$p, create_fragment$q, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
/* src\accessLevels\AccessLevelView.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$s = "src\\accessLevels\\AccessLevelView.svelte";
|
|
|
|
function get_each_context$b(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.permission = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (77:4) {#each permissionMatrix as permission}
|
|
function create_each_block$b(ctx) {
|
|
var div, current;
|
|
|
|
var checkbox = new Checkbox({
|
|
props: {
|
|
label: ctx.getPermissionName(ctx.permission.permission),
|
|
checked: ctx.permission.hasPermission
|
|
},
|
|
$$inline: true
|
|
});
|
|
checkbox.$on("change", ctx.permissionChanged(ctx.permission.permission));
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
checkbox.$$.fragment.c();
|
|
add_location(div, file$s, 77, 4, 1870);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(checkbox, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var checkbox_changes = {};
|
|
if (changed.getPermissionName || changed.permissionMatrix) checkbox_changes.label = ctx.getPermissionName(ctx.permission.permission);
|
|
if (changed.permissionMatrix) checkbox_changes.checked = ctx.permission.hasPermission;
|
|
checkbox.$set(checkbox_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(checkbox.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(checkbox.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(checkbox);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (87:8) <Button color="primary" grouped on:click={save}>
|
|
function create_default_slot_2$5(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Save");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (88:8) <Button color="secondary" grouped on:click={() => onFinished()}>
|
|
function create_default_slot_1$5(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Cancel");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (86:4) <ButtonGroup style="margin-top: 10px">
|
|
function create_default_slot$8(ctx) {
|
|
var t, current;
|
|
|
|
var button0 = new Button({
|
|
props: {
|
|
color: "primary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_2$5] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button0.$on("click", ctx.save);
|
|
|
|
var button1 = new Button({
|
|
props: {
|
|
color: "secondary",
|
|
grouped: true,
|
|
$$slots: { default: [create_default_slot_1$5] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button1.$on("click", ctx.click_handler);
|
|
|
|
return {
|
|
c: function create() {
|
|
button0.$$.fragment.c();
|
|
t = space();
|
|
button1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button0, target, anchor);
|
|
insert(target, t, anchor);
|
|
mount_component(button1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var button0_changes = {};
|
|
if (changed.$$scope) button0_changes.$$scope = { changed, ctx };
|
|
button0.$set(button0_changes);
|
|
|
|
var button1_changes = {};
|
|
if (changed.$$scope) button1_changes.$$scope = { changed, ctx };
|
|
button1.$set(button1_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button0.$$.fragment, local);
|
|
|
|
transition_in(button1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button0.$$.fragment, local);
|
|
transition_out(button1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button0, detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
destroy_component(button1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$r(ctx) {
|
|
var div, t0, updating_text, t1, t2, current;
|
|
|
|
var errorsbox = new ErrorsBox({
|
|
props: { errors: ctx.errors },
|
|
$$inline: true
|
|
});
|
|
|
|
function textbox_text_binding(value) {
|
|
ctx.textbox_text_binding.call(null, value);
|
|
updating_text = true;
|
|
add_flush_callback(() => updating_text = false);
|
|
}
|
|
|
|
let textbox_props = { label: "Name" };
|
|
if (ctx.clonedLevel.name !== void 0) {
|
|
textbox_props.text = ctx.clonedLevel.name;
|
|
}
|
|
var textbox = new Textbox({ props: textbox_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(textbox, 'text', textbox_text_binding));
|
|
|
|
var each_value = ctx.permissionMatrix;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$b(get_each_context$b(ctx, each_value, i));
|
|
}
|
|
|
|
const out = i => transition_out(each_blocks[i], 1, 1, () => {
|
|
each_blocks[i] = null;
|
|
});
|
|
|
|
var buttongroup = new ButtonGroup({
|
|
props: {
|
|
style: "margin-top: 10px",
|
|
$$slots: { default: [create_default_slot$8] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
errorsbox.$$.fragment.c();
|
|
t0 = space();
|
|
textbox.$$.fragment.c();
|
|
t1 = space();
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
|
|
t2 = space();
|
|
buttongroup.$$.fragment.c();
|
|
add_location(div, file$s, 70, 0, 1722);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(errorsbox, div, null);
|
|
append(div, t0);
|
|
mount_component(textbox, div, null);
|
|
append(div, t1);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(div, null);
|
|
}
|
|
|
|
append(div, t2);
|
|
mount_component(buttongroup, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var errorsbox_changes = {};
|
|
if (changed.errors) errorsbox_changes.errors = ctx.errors;
|
|
errorsbox.$set(errorsbox_changes);
|
|
|
|
var textbox_changes = {};
|
|
if (!updating_text && changed.clonedLevel) {
|
|
textbox_changes.text = ctx.clonedLevel.name;
|
|
}
|
|
textbox.$set(textbox_changes);
|
|
|
|
if (changed.getPermissionName || changed.permissionMatrix) {
|
|
each_value = ctx.permissionMatrix;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$b(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
transition_in(each_blocks[i], 1);
|
|
} else {
|
|
each_blocks[i] = create_each_block$b(child_ctx);
|
|
each_blocks[i].c();
|
|
transition_in(each_blocks[i], 1);
|
|
each_blocks[i].m(div, t2);
|
|
}
|
|
}
|
|
|
|
group_outros();
|
|
for (i = each_value.length; i < each_blocks.length; i += 1) out(i);
|
|
check_outros();
|
|
}
|
|
|
|
var buttongroup_changes = {};
|
|
if (changed.$$scope) buttongroup_changes.$$scope = { changed, ctx };
|
|
buttongroup.$set(buttongroup_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(errorsbox.$$.fragment, local);
|
|
|
|
transition_in(textbox.$$.fragment, local);
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) transition_in(each_blocks[i]);
|
|
|
|
transition_in(buttongroup.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(errorsbox.$$.fragment, local);
|
|
transition_out(textbox.$$.fragment, local);
|
|
|
|
each_blocks = each_blocks.filter(Boolean);
|
|
for (let i = 0; i < each_blocks.length; i += 1) transition_out(each_blocks[i]);
|
|
|
|
transition_out(buttongroup.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(errorsbox);
|
|
|
|
destroy_component(textbox);
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
|
|
destroy_component(buttongroup);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$q($$self, $$props, $$invalidate) {
|
|
|
|
|
|
let { level, allPermissions, onFinished, isNew, allLevels, hierarchy, actions } = $$props;
|
|
|
|
let errors = [];
|
|
let clonedLevel = fp.cloneDeep(level);
|
|
|
|
const matchPermissions = (p1, p2) =>
|
|
p1.type === p2.type
|
|
&&
|
|
((!p2.nodeKey && !p1.nodeKey)
|
|
|| p2.nodeKey === p1.nodeKey);
|
|
|
|
const hasPermission = hasPerm =>
|
|
fp.some(p => matchPermissions(p, hasPerm))
|
|
(clonedLevel.permissions);
|
|
|
|
const getPermissionName = perm =>
|
|
perm.nodeKey
|
|
? `${perm.type} - ${perm.nodeKey}`
|
|
: perm.type;
|
|
|
|
const save = () => {
|
|
|
|
const newLevels =
|
|
isNew
|
|
? [...allLevels, clonedLevel]
|
|
: [...fp.filter(l => l.name !== level.name)(allLevels), clonedLevel];
|
|
|
|
$$invalidate('errors', errors = validateAccessLevels$1(
|
|
hierarchy,
|
|
actions,
|
|
newLevels
|
|
));
|
|
|
|
if(errors.length > 0) return;
|
|
|
|
onFinished(clonedLevel);
|
|
};
|
|
|
|
const permissionChanged = perm => ev => {
|
|
const hasPermission = ev.target.checked;
|
|
|
|
if(hasPermission) {
|
|
clonedLevel.permissions.push(perm);
|
|
} else {
|
|
clonedLevel.permissions = fp.filter(p => !matchPermissions(p, perm)); $$invalidate('clonedLevel', clonedLevel);
|
|
}
|
|
};
|
|
|
|
const writable_props = ['level', 'allPermissions', 'onFinished', 'isNew', 'allLevels', 'hierarchy', 'actions'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<AccessLevelView> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
function textbox_text_binding(value) {
|
|
clonedLevel.name = value;
|
|
$$invalidate('clonedLevel', clonedLevel);
|
|
}
|
|
|
|
function click_handler() {
|
|
return onFinished();
|
|
}
|
|
|
|
$$self.$set = $$props => {
|
|
if ('level' in $$props) $$invalidate('level', level = $$props.level);
|
|
if ('allPermissions' in $$props) $$invalidate('allPermissions', allPermissions = $$props.allPermissions);
|
|
if ('onFinished' in $$props) $$invalidate('onFinished', onFinished = $$props.onFinished);
|
|
if ('isNew' in $$props) $$invalidate('isNew', isNew = $$props.isNew);
|
|
if ('allLevels' in $$props) $$invalidate('allLevels', allLevels = $$props.allLevels);
|
|
if ('hierarchy' in $$props) $$invalidate('hierarchy', hierarchy = $$props.hierarchy);
|
|
if ('actions' in $$props) $$invalidate('actions', actions = $$props.actions);
|
|
};
|
|
|
|
let permissionMatrix;
|
|
|
|
$$self.$$.update = ($$dirty = { allPermissions: 1 }) => {
|
|
if ($$dirty.allPermissions) { $$invalidate('permissionMatrix', permissionMatrix =
|
|
fp.map(p => ({permission:p, hasPermission: hasPermission(p)}))
|
|
(allPermissions)); }
|
|
};
|
|
|
|
return {
|
|
level,
|
|
allPermissions,
|
|
onFinished,
|
|
isNew,
|
|
allLevels,
|
|
hierarchy,
|
|
actions,
|
|
errors,
|
|
clonedLevel,
|
|
getPermissionName,
|
|
save,
|
|
permissionChanged,
|
|
permissionMatrix,
|
|
textbox_text_binding,
|
|
click_handler
|
|
};
|
|
}
|
|
|
|
class AccessLevelView extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$q, create_fragment$r, safe_not_equal, ["level", "allPermissions", "onFinished", "isNew", "allLevels", "hierarchy", "actions"]);
|
|
|
|
const { ctx } = this.$$;
|
|
const props = options.props || {};
|
|
if (ctx.level === undefined && !('level' in props)) {
|
|
console.warn("<AccessLevelView> was created without expected prop 'level'");
|
|
}
|
|
if (ctx.allPermissions === undefined && !('allPermissions' in props)) {
|
|
console.warn("<AccessLevelView> was created without expected prop 'allPermissions'");
|
|
}
|
|
if (ctx.onFinished === undefined && !('onFinished' in props)) {
|
|
console.warn("<AccessLevelView> was created without expected prop 'onFinished'");
|
|
}
|
|
if (ctx.isNew === undefined && !('isNew' in props)) {
|
|
console.warn("<AccessLevelView> was created without expected prop 'isNew'");
|
|
}
|
|
if (ctx.allLevels === undefined && !('allLevels' in props)) {
|
|
console.warn("<AccessLevelView> was created without expected prop 'allLevels'");
|
|
}
|
|
if (ctx.hierarchy === undefined && !('hierarchy' in props)) {
|
|
console.warn("<AccessLevelView> was created without expected prop 'hierarchy'");
|
|
}
|
|
if (ctx.actions === undefined && !('actions' in props)) {
|
|
console.warn("<AccessLevelView> was created without expected prop 'actions'");
|
|
}
|
|
}
|
|
|
|
get level() {
|
|
throw new Error("<AccessLevelView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set level(value) {
|
|
throw new Error("<AccessLevelView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get allPermissions() {
|
|
throw new Error("<AccessLevelView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set allPermissions(value) {
|
|
throw new Error("<AccessLevelView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get onFinished() {
|
|
throw new Error("<AccessLevelView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set onFinished(value) {
|
|
throw new Error("<AccessLevelView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get isNew() {
|
|
throw new Error("<AccessLevelView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set isNew(value) {
|
|
throw new Error("<AccessLevelView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get allLevels() {
|
|
throw new Error("<AccessLevelView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set allLevels(value) {
|
|
throw new Error("<AccessLevelView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get hierarchy() {
|
|
throw new Error("<AccessLevelView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set hierarchy(value) {
|
|
throw new Error("<AccessLevelView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
get actions() {
|
|
throw new Error("<AccessLevelView>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set actions(value) {
|
|
throw new Error("<AccessLevelView>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\accessLevels\AccessLevelsRoot.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$t = "src\\accessLevels\\AccessLevelsRoot.svelte";
|
|
|
|
function get_each_context$c(ctx, list, i) {
|
|
const child_ctx = Object.create(ctx);
|
|
child_ctx.level = list[i];
|
|
return child_ctx;
|
|
}
|
|
|
|
// (55:4) <Button grouped color="secondary" on:click={createNewLevel}>
|
|
function create_default_slot_2$6(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("Create New Access Level");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (54:0) <ButtonGroup>
|
|
function create_default_slot_1$6(ctx) {
|
|
var current;
|
|
|
|
var button = new Button({
|
|
props: {
|
|
grouped: true,
|
|
color: "secondary",
|
|
$$slots: { default: [create_default_slot_2$6] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
button.$on("click", ctx.createNewLevel);
|
|
|
|
return {
|
|
c: function create() {
|
|
button.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(button, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var button_changes = {};
|
|
if (changed.$$scope) button_changes.$$scope = { changed, ctx };
|
|
button.$set(button_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(button.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(button.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(button, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (80:0) {:else}
|
|
function create_else_block$7(ctx) {
|
|
var t;
|
|
|
|
return {
|
|
c: function create() {
|
|
t = text("(no actions added)");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, t, anchor);
|
|
},
|
|
|
|
p: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (58:0) {#if $database.accessLevels}
|
|
function create_if_block_1$6(ctx) {
|
|
var table, thead, tr, th0, t1, th1, t3, th2, t4, tbody;
|
|
|
|
var each_value = ctx.$database.accessLevels;
|
|
|
|
var each_blocks = [];
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
each_blocks[i] = create_each_block$c(get_each_context$c(ctx, each_value, i));
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
table = element("table");
|
|
thead = element("thead");
|
|
tr = element("tr");
|
|
th0 = element("th");
|
|
th0.textContent = "Name";
|
|
t1 = space();
|
|
th1 = element("th");
|
|
th1.textContent = "Permissions";
|
|
t3 = space();
|
|
th2 = element("th");
|
|
t4 = space();
|
|
tbody = element("tbody");
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].c();
|
|
}
|
|
add_location(th0, file$t, 61, 12, 1510);
|
|
add_location(th1, file$t, 62, 12, 1537);
|
|
add_location(th2, file$t, 63, 12, 1571);
|
|
add_location(tr, file$t, 60, 8, 1492);
|
|
add_location(thead, file$t, 59, 4, 1475);
|
|
add_location(tbody, file$t, 66, 4, 1615);
|
|
attr(table, "class", "fields-table uk-table uk-table-small");
|
|
add_location(table, file$t, 58, 0, 1417);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, table, anchor);
|
|
append(table, thead);
|
|
append(thead, tr);
|
|
append(tr, th0);
|
|
append(tr, t1);
|
|
append(tr, th1);
|
|
append(tr, t3);
|
|
append(tr, th2);
|
|
append(table, t4);
|
|
append(table, tbody);
|
|
|
|
for (var i = 0; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (changed.getIcon || changed.getPermissionsString || changed.$database) {
|
|
each_value = ctx.$database.accessLevels;
|
|
|
|
for (var i = 0; i < each_value.length; i += 1) {
|
|
const child_ctx = get_each_context$c(ctx, each_value, i);
|
|
|
|
if (each_blocks[i]) {
|
|
each_blocks[i].p(changed, child_ctx);
|
|
} else {
|
|
each_blocks[i] = create_each_block$c(child_ctx);
|
|
each_blocks[i].c();
|
|
each_blocks[i].m(tbody, null);
|
|
}
|
|
}
|
|
|
|
for (; i < each_blocks.length; i += 1) {
|
|
each_blocks[i].d(1);
|
|
}
|
|
each_blocks.length = each_value.length;
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(table);
|
|
}
|
|
|
|
destroy_each(each_blocks, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (68:8) {#each $database.accessLevels as level}
|
|
function create_each_block$c(ctx) {
|
|
var tr, td0, t0_value = ctx.level.name, t0, t1, td1, t2_value = ctx.getPermissionsString(ctx.level.permissions), t2, t3, td2, span0, raw0_value = getIcon("edit"), t4, span1, raw1_value = getIcon("trash"), t5, dispose;
|
|
|
|
function click_handler() {
|
|
return ctx.click_handler(ctx);
|
|
}
|
|
|
|
function click_handler_1() {
|
|
return ctx.click_handler_1(ctx);
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
tr = element("tr");
|
|
td0 = element("td");
|
|
t0 = text(t0_value);
|
|
t1 = space();
|
|
td1 = element("td");
|
|
t2 = text(t2_value);
|
|
t3 = space();
|
|
td2 = element("td");
|
|
span0 = element("span");
|
|
t4 = space();
|
|
span1 = element("span");
|
|
t5 = space();
|
|
add_location(td0, file$t, 69, 12, 1699);
|
|
add_location(td1, file$t, 70, 12, 1735);
|
|
add_location(span0, file$t, 72, 16, 1842);
|
|
add_location(span1, file$t, 73, 16, 1932);
|
|
attr(td2, "class", "edit-button svelte-1be865r");
|
|
add_location(td2, file$t, 71, 12, 1800);
|
|
attr(tr, "class", "svelte-1be865r");
|
|
add_location(tr, file$t, 68, 8, 1681);
|
|
|
|
dispose = [
|
|
listen(span0, "click", click_handler),
|
|
listen(span1, "click", click_handler_1)
|
|
];
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, tr, anchor);
|
|
append(tr, td0);
|
|
append(td0, t0);
|
|
append(tr, t1);
|
|
append(tr, td1);
|
|
append(td1, t2);
|
|
append(tr, t3);
|
|
append(tr, td2);
|
|
append(td2, span0);
|
|
span0.innerHTML = raw0_value;
|
|
append(td2, t4);
|
|
append(td2, span1);
|
|
span1.innerHTML = raw1_value;
|
|
append(tr, t5);
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
if ((changed.$database) && t0_value !== (t0_value = ctx.level.name)) {
|
|
set_data(t0, t0_value);
|
|
}
|
|
|
|
if ((changed.$database) && t2_value !== (t2_value = ctx.getPermissionsString(ctx.level.permissions))) {
|
|
set_data(t2, t2_value);
|
|
}
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(tr);
|
|
}
|
|
|
|
run_all(dispose);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (86:4) {#if isEditing}
|
|
function create_if_block$9(ctx) {
|
|
var current;
|
|
|
|
var accesslevelview = new AccessLevelView({
|
|
props: {
|
|
level: ctx.editingLevel,
|
|
allPermissions: ctx.allPermissions,
|
|
onFinished: ctx.onEditingFinished,
|
|
isNew: ctx.editingLevelIsNew,
|
|
allLevels: ctx.$database.accessLevels,
|
|
hierarchy: ctx.$database.hierarchy,
|
|
actions: ctx.$database.actions
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
return {
|
|
c: function create() {
|
|
accesslevelview.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(accesslevelview, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var accesslevelview_changes = {};
|
|
if (changed.editingLevel) accesslevelview_changes.level = ctx.editingLevel;
|
|
if (changed.allPermissions) accesslevelview_changes.allPermissions = ctx.allPermissions;
|
|
if (changed.onEditingFinished) accesslevelview_changes.onFinished = ctx.onEditingFinished;
|
|
if (changed.editingLevelIsNew) accesslevelview_changes.isNew = ctx.editingLevelIsNew;
|
|
if (changed.$database) accesslevelview_changes.allLevels = ctx.$database.accessLevels;
|
|
if (changed.$database) accesslevelview_changes.hierarchy = ctx.$database.hierarchy;
|
|
if (changed.$database) accesslevelview_changes.actions = ctx.$database.actions;
|
|
accesslevelview.$set(accesslevelview_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(accesslevelview.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(accesslevelview.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(accesslevelview, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (85:0) <Modal bind:isOpen={isEditing}>
|
|
function create_default_slot$9(ctx) {
|
|
var if_block_anchor, current;
|
|
|
|
var if_block = (ctx.isEditing) && create_if_block$9(ctx);
|
|
|
|
return {
|
|
c: function create() {
|
|
if (if_block) if_block.c();
|
|
if_block_anchor = empty();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
if (if_block) if_block.m(target, anchor);
|
|
insert(target, if_block_anchor, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (ctx.isEditing) {
|
|
if (if_block) {
|
|
if_block.p(changed, ctx);
|
|
transition_in(if_block, 1);
|
|
} else {
|
|
if_block = create_if_block$9(ctx);
|
|
if_block.c();
|
|
transition_in(if_block, 1);
|
|
if_block.m(if_block_anchor.parentNode, if_block_anchor);
|
|
}
|
|
} else if (if_block) {
|
|
group_outros();
|
|
transition_out(if_block, 1, 1, () => {
|
|
if_block = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (if_block) if_block.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(if_block_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$s(ctx) {
|
|
var div, t0, t1, updating_isOpen, current;
|
|
|
|
var buttongroup = new ButtonGroup({
|
|
props: {
|
|
$$slots: { default: [create_default_slot_1$6] },
|
|
$$scope: { ctx }
|
|
},
|
|
$$inline: true
|
|
});
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.$database.accessLevels) return create_if_block_1$6;
|
|
return create_else_block$7;
|
|
}
|
|
|
|
var current_block_type = select_block_type(ctx);
|
|
var if_block = current_block_type(ctx);
|
|
|
|
function modal_isOpen_binding(value) {
|
|
ctx.modal_isOpen_binding.call(null, value);
|
|
updating_isOpen = true;
|
|
add_flush_callback(() => updating_isOpen = false);
|
|
}
|
|
|
|
let modal_props = {
|
|
$$slots: { default: [create_default_slot$9] },
|
|
$$scope: { ctx }
|
|
};
|
|
if (ctx.isEditing !== void 0) {
|
|
modal_props.isOpen = ctx.isEditing;
|
|
}
|
|
var modal = new Modal({ props: modal_props, $$inline: true });
|
|
|
|
binding_callbacks.push(() => bind(modal, 'isOpen', modal_isOpen_binding));
|
|
|
|
return {
|
|
c: function create() {
|
|
div = element("div");
|
|
buttongroup.$$.fragment.c();
|
|
t0 = space();
|
|
if_block.c();
|
|
t1 = space();
|
|
modal.$$.fragment.c();
|
|
attr(div, "class", "root svelte-1be865r");
|
|
add_location(div, file$t, 51, 0, 1234);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div, anchor);
|
|
mount_component(buttongroup, div, null);
|
|
append(div, t0);
|
|
if_block.m(div, null);
|
|
append(div, t1);
|
|
mount_component(modal, div, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var buttongroup_changes = {};
|
|
if (changed.$$scope) buttongroup_changes.$$scope = { changed, ctx };
|
|
buttongroup.$set(buttongroup_changes);
|
|
|
|
if (current_block_type === (current_block_type = select_block_type(ctx)) && if_block) {
|
|
if_block.p(changed, ctx);
|
|
} else {
|
|
if_block.d(1);
|
|
if_block = current_block_type(ctx);
|
|
if (if_block) {
|
|
if_block.c();
|
|
if_block.m(div, t1);
|
|
}
|
|
}
|
|
|
|
var modal_changes = {};
|
|
if (changed.$$scope || changed.isEditing || changed.editingLevel || changed.allPermissions || changed.editingLevelIsNew || changed.$database) modal_changes.$$scope = { changed, ctx };
|
|
if (!updating_isOpen && changed.isEditing) {
|
|
modal_changes.isOpen = ctx.isEditing;
|
|
}
|
|
modal.$set(modal_changes);
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(buttongroup.$$.fragment, local);
|
|
|
|
transition_in(modal.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(buttongroup.$$.fragment, local);
|
|
transition_out(modal.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div);
|
|
}
|
|
|
|
destroy_component(buttongroup);
|
|
|
|
if_block.d();
|
|
|
|
destroy_component(modal);
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$r($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
let editingLevel = null;
|
|
let editingLevelIsNew = false;
|
|
|
|
let allPermissions = [];
|
|
database.subscribe(db => {
|
|
$$invalidate('allPermissions', allPermissions = generateFullPermissions$1(db.hierarchy, db.actions));
|
|
});
|
|
|
|
let onLevelEdit = (level) => {
|
|
$$invalidate('editingLevel', editingLevel = level);
|
|
$$invalidate('editingLevelIsNew', editingLevelIsNew = false);
|
|
};
|
|
|
|
let onLevelDelete = (level) => {
|
|
database.deleteLevel(level);
|
|
};
|
|
|
|
|
|
let createNewLevel = () => {
|
|
$$invalidate('editingLevelIsNew', editingLevelIsNew = true);
|
|
$$invalidate('editingLevel', editingLevel = getNewAccessLevel$1());
|
|
};
|
|
|
|
let onEditingFinished = (level) => {
|
|
if(level) {
|
|
database.saveLevel(level, editingLevelIsNew, editingLevel);
|
|
}
|
|
$$invalidate('editingLevel', editingLevel = null);
|
|
};
|
|
|
|
const getPermissionsString = perms => {
|
|
return `${perms.length} / ${allPermissions.length}`;
|
|
};
|
|
|
|
function click_handler({ level }) {
|
|
return onLevelEdit(level);
|
|
}
|
|
|
|
function click_handler_1({ level }) {
|
|
return onLevelDelete(level);
|
|
}
|
|
|
|
function modal_isOpen_binding(value) {
|
|
isEditing = value;
|
|
$$invalidate('isEditing', isEditing), $$invalidate('editingLevel', editingLevel);
|
|
}
|
|
|
|
let isEditing;
|
|
|
|
$$self.$$.update = ($$dirty = { editingLevel: 1 }) => {
|
|
if ($$dirty.editingLevel) { $$invalidate('isEditing', isEditing = (editingLevel !== null)); }
|
|
};
|
|
|
|
return {
|
|
editingLevel,
|
|
editingLevelIsNew,
|
|
allPermissions,
|
|
onLevelEdit,
|
|
onLevelDelete,
|
|
createNewLevel,
|
|
onEditingFinished,
|
|
getPermissionsString,
|
|
isEditing,
|
|
$database,
|
|
click_handler,
|
|
click_handler_1,
|
|
modal_isOpen_binding
|
|
};
|
|
}
|
|
|
|
class AccessLevelsRoot extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$r, create_fragment$s, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
/* src\PackageRoot.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$u = "src\\PackageRoot.svelte";
|
|
|
|
// (27:55)
|
|
function create_if_block_3$2(ctx) {
|
|
var current;
|
|
|
|
var userinterface = new UserInterfaceRoot({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
userinterface.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(userinterface, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(userinterface.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(userinterface.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(userinterface, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (25:54)
|
|
function create_if_block_2$4(ctx) {
|
|
var current;
|
|
|
|
var accesslevels = new AccessLevelsRoot({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
accesslevels.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(accesslevels, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(accesslevels.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(accesslevels.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(accesslevels, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (23:48)
|
|
function create_if_block_1$7(ctx) {
|
|
var current;
|
|
|
|
var actionsandtriggers = new ActionsAndTriggersRoot({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
actionsandtriggers.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(actionsandtriggers, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(actionsandtriggers.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(actionsandtriggers.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(actionsandtriggers, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (21:4) {#if $database.activeNav === "database"}
|
|
function create_if_block$a(ctx) {
|
|
var current;
|
|
|
|
var database_1 = new DatabaseRoot({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
database_1.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(database_1, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(database_1.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(database_1.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(database_1, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$t(ctx) {
|
|
var div1, t, div0, current_block_type_index, if_block, current;
|
|
|
|
var nav = new Nav({
|
|
props: { width: ctx.navWidth },
|
|
$$inline: true
|
|
});
|
|
|
|
var if_block_creators = [
|
|
create_if_block$a,
|
|
create_if_block_1$7,
|
|
create_if_block_2$4,
|
|
create_if_block_3$2
|
|
];
|
|
|
|
var if_blocks = [];
|
|
|
|
function select_block_type(ctx) {
|
|
if (ctx.$database.activeNav === "database") return 0;
|
|
if (ctx.$database.activeNav === "actions") return 1;
|
|
if (ctx.$database.activeNav === "access levels") return 2;
|
|
if (ctx.$database.activeNav === "user interface") return 3;
|
|
return -1;
|
|
}
|
|
|
|
if (~(current_block_type_index = select_block_type(ctx))) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
}
|
|
|
|
return {
|
|
c: function create() {
|
|
div1 = element("div");
|
|
nav.$$.fragment.c();
|
|
t = space();
|
|
div0 = element("div");
|
|
if (if_block) if_block.c();
|
|
attr(div0, "class", "content svelte-1rxbdcd");
|
|
set_style(div0, "width", "calc(100% - " + ctx.navWidth + ")");
|
|
set_style(div0, "left", ctx.navWidth);
|
|
add_location(div0, file$u, 18, 2, 532);
|
|
attr(div1, "class", "root svelte-1rxbdcd");
|
|
add_location(div1, file$u, 16, 0, 482);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, div1, anchor);
|
|
mount_component(nav, div1, null);
|
|
append(div1, t);
|
|
append(div1, div0);
|
|
if (~current_block_type_index) if_blocks[current_block_type_index].m(div0, null);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
var nav_changes = {};
|
|
if (changed.navWidth) nav_changes.width = ctx.navWidth;
|
|
nav.$set(nav_changes);
|
|
|
|
var previous_block_index = current_block_type_index;
|
|
current_block_type_index = select_block_type(ctx);
|
|
if (current_block_type_index !== previous_block_index) {
|
|
if (if_block) {
|
|
group_outros();
|
|
transition_out(if_blocks[previous_block_index], 1, 1, () => {
|
|
if_blocks[previous_block_index] = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
|
|
if (~current_block_type_index) {
|
|
if_block = if_blocks[current_block_type_index];
|
|
if (!if_block) {
|
|
if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
|
|
if_block.c();
|
|
}
|
|
transition_in(if_block, 1);
|
|
if_block.m(div0, null);
|
|
} else {
|
|
if_block = null;
|
|
}
|
|
}
|
|
|
|
if (!current || changed.navWidth) {
|
|
set_style(div0, "width", "calc(100% - " + ctx.navWidth + ")");
|
|
set_style(div0, "left", ctx.navWidth);
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(nav.$$.fragment, local);
|
|
|
|
transition_in(if_block);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(nav.$$.fragment, local);
|
|
transition_out(if_block);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(div1);
|
|
}
|
|
|
|
destroy_component(nav);
|
|
|
|
if (~current_block_type_index) if_blocks[current_block_type_index].d();
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$s($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
let { navWidth = "50px" } = $$props;
|
|
|
|
const writable_props = ['navWidth'];
|
|
Object.keys($$props).forEach(key => {
|
|
if (!writable_props.includes(key) && !key.startsWith('$$')) console.warn(`<PackageRoot> was created with unknown prop '${key}'`);
|
|
});
|
|
|
|
$$self.$set = $$props => {
|
|
if ('navWidth' in $$props) $$invalidate('navWidth', navWidth = $$props.navWidth);
|
|
};
|
|
|
|
return { navWidth, $database };
|
|
}
|
|
|
|
class PackageRoot extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$s, create_fragment$t, safe_not_equal, ["navWidth"]);
|
|
}
|
|
|
|
get navWidth() {
|
|
throw new Error("<PackageRoot>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
|
|
set navWidth(value) {
|
|
throw new Error("<PackageRoot>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
|
}
|
|
}
|
|
|
|
/* src\App.svelte generated by Svelte v3.6.9 */
|
|
|
|
const file$v = "src\\App.svelte";
|
|
|
|
// (27:1) {:catch err}
|
|
function create_catch_block(ctx) {
|
|
var h1, t_value = ctx.err, t;
|
|
|
|
return {
|
|
c: function create() {
|
|
h1 = element("h1");
|
|
t = text(t_value);
|
|
set_style(h1, "color", "red");
|
|
add_location(h1, file$v, 27, 2, 428);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, h1, anchor);
|
|
append(h1, t);
|
|
},
|
|
|
|
p: noop,
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(h1);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (18:1) {:then result}
|
|
function create_then_block(ctx) {
|
|
var t, if_block1_anchor, current;
|
|
|
|
var if_block0 = (ctx.$database.hasAppPackage) && create_if_block_1$8();
|
|
|
|
var if_block1 = (!ctx.$database.hasAppPackage) && create_if_block$b();
|
|
|
|
return {
|
|
c: function create() {
|
|
if (if_block0) if_block0.c();
|
|
t = space();
|
|
if (if_block1) if_block1.c();
|
|
if_block1_anchor = empty();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
if (if_block0) if_block0.m(target, anchor);
|
|
insert(target, t, anchor);
|
|
if (if_block1) if_block1.m(target, anchor);
|
|
insert(target, if_block1_anchor, anchor);
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, ctx) {
|
|
if (ctx.$database.hasAppPackage) {
|
|
if (!if_block0) {
|
|
if_block0 = create_if_block_1$8();
|
|
if_block0.c();
|
|
transition_in(if_block0, 1);
|
|
if_block0.m(t.parentNode, t);
|
|
} else {
|
|
transition_in(if_block0, 1);
|
|
}
|
|
} else if (if_block0) {
|
|
group_outros();
|
|
transition_out(if_block0, 1, 1, () => {
|
|
if_block0 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
|
|
if (!ctx.$database.hasAppPackage) {
|
|
if (!if_block1) {
|
|
if_block1 = create_if_block$b();
|
|
if_block1.c();
|
|
transition_in(if_block1, 1);
|
|
if_block1.m(if_block1_anchor.parentNode, if_block1_anchor);
|
|
} else {
|
|
transition_in(if_block1, 1);
|
|
}
|
|
} else if (if_block1) {
|
|
group_outros();
|
|
transition_out(if_block1, 1, 1, () => {
|
|
if_block1 = null;
|
|
});
|
|
check_outros();
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(if_block0);
|
|
transition_in(if_block1);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(if_block0);
|
|
transition_out(if_block1);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (if_block0) if_block0.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(t);
|
|
}
|
|
|
|
if (if_block1) if_block1.d(detaching);
|
|
|
|
if (detaching) {
|
|
detach(if_block1_anchor);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// (19:2) {#if $database.hasAppPackage}
|
|
function create_if_block_1$8(ctx) {
|
|
var current;
|
|
|
|
var packageroot = new PackageRoot({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
packageroot.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(packageroot, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(packageroot.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(packageroot.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(packageroot, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (23:2) {#if !$database.hasAppPackage}
|
|
function create_if_block$b(ctx) {
|
|
var current;
|
|
|
|
var nopackage = new NoPackage({ $$inline: true });
|
|
|
|
return {
|
|
c: function create() {
|
|
nopackage.$$.fragment.c();
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
mount_component(nopackage, target, anchor);
|
|
current = true;
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(nopackage.$$.fragment, local);
|
|
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
transition_out(nopackage.$$.fragment, local);
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
destroy_component(nopackage, detaching);
|
|
}
|
|
};
|
|
}
|
|
|
|
// (14:14) <h1>loading</h1> {:then result}
|
|
function create_pending_block(ctx) {
|
|
var h1;
|
|
|
|
return {
|
|
c: function create() {
|
|
h1 = element("h1");
|
|
h1.textContent = "loading";
|
|
add_location(h1, file$v, 15, 2, 261);
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, h1, anchor);
|
|
},
|
|
|
|
p: noop,
|
|
i: noop,
|
|
o: noop,
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(h1);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
function create_fragment$u(ctx) {
|
|
var main, promise, current;
|
|
|
|
let info = {
|
|
ctx,
|
|
current: null,
|
|
token: null,
|
|
pending: create_pending_block,
|
|
then: create_then_block,
|
|
catch: create_catch_block,
|
|
value: 'result',
|
|
error: 'err',
|
|
blocks: [,,,]
|
|
};
|
|
|
|
handle_promise(promise = ctx.init, info);
|
|
|
|
return {
|
|
c: function create() {
|
|
main = element("main");
|
|
|
|
info.block.c();
|
|
attr(main, "class", "svelte-j8mzr7");
|
|
add_location(main, file$v, 11, 0, 234);
|
|
},
|
|
|
|
l: function claim(nodes) {
|
|
throw new Error("options.hydrate only works if the component was compiled with the `hydratable: true` option");
|
|
},
|
|
|
|
m: function mount(target, anchor) {
|
|
insert(target, main, anchor);
|
|
|
|
info.block.m(main, info.anchor = null);
|
|
info.mount = () => main;
|
|
info.anchor = null;
|
|
|
|
current = true;
|
|
},
|
|
|
|
p: function update(changed, new_ctx) {
|
|
ctx = new_ctx;
|
|
info.ctx = ctx;
|
|
|
|
if (promise !== (promise = ctx.init) && handle_promise(promise, info)) ; else {
|
|
info.block.p(changed, assign(assign({}, ctx), info.resolved));
|
|
}
|
|
},
|
|
|
|
i: function intro(local) {
|
|
if (current) return;
|
|
transition_in(info.block);
|
|
current = true;
|
|
},
|
|
|
|
o: function outro(local) {
|
|
for (let i = 0; i < 3; i += 1) {
|
|
const block = info.blocks[i];
|
|
transition_out(block);
|
|
}
|
|
|
|
current = false;
|
|
},
|
|
|
|
d: function destroy(detaching) {
|
|
if (detaching) {
|
|
detach(main);
|
|
}
|
|
|
|
info.block.d();
|
|
info.token = null;
|
|
info = null;
|
|
}
|
|
};
|
|
}
|
|
|
|
function instance$t($$self, $$props, $$invalidate) {
|
|
let $database;
|
|
|
|
validate_store(database, 'database');
|
|
subscribe($$self, database, $$value => { $database = $$value; $$invalidate('$database', $database); });
|
|
|
|
|
|
|
|
let init = initialise$1();
|
|
|
|
return { init, $database };
|
|
}
|
|
|
|
class App extends SvelteComponentDev {
|
|
constructor(options) {
|
|
super(options);
|
|
init(this, options, instance$t, create_fragment$u, safe_not_equal, []);
|
|
}
|
|
}
|
|
|
|
var uikit_min = createCommonjsModule(function (module, exports) {
|
|
/*! UIkit 3.1.6 | http://www.getuikit.com | (c) 2014 - 2018 YOOtheme | MIT License */
|
|
|
|
!function(t,e){module.exports=e();}(commonjsGlobal,function(){function l(n,i){return function(t){var e=arguments.length;return e?1<e?n.apply(i,arguments):n.call(i,t):n.call(i)}}var e=Object.prototype,n=e.hasOwnProperty;function c(t,e){return n.call(t,e)}var i={},r=/([a-z\d])([A-Z])/g;function d(t){return t in i||(i[t]=t.replace(r,"$1-$2").toLowerCase()),i[t]}var o=/-(\w)/g;function f(t){return t.replace(o,s)}function s(t,e){return e?e.toUpperCase():""}function p(t){return t.length?s(0,t.charAt(0))+t.slice(1):""}var t=String.prototype,a=t.startsWith||function(t){return 0===this.lastIndexOf(t,0)};function w(t,e){return a.call(t,e)}var h=t.endsWith||function(t){return this.substr(-t.length)===t};function u(t,e){return h.call(t,e)}function m(t,e){return ~this.indexOf(t,e)}var g=Array.prototype,v=t.includes||m,b=g.includes||m;function y(t,e){return t&&(D(t)?v:b).call(t,e)}var x=g.findIndex||function(t){for(var e=arguments,n=0;n<this.length;n++)if(t.call(e[1],this[n],n,this))return n;return -1};function k(t,e){return x.call(t,e)}var $=Array.isArray;function I(t){return "function"==typeof t}function S(t){return null!==t&&"object"==typeof t}function T(t){return S(t)&&Object.getPrototypeOf(t)===e}function E(t){return S(t)&&t===t.window}function A(t){return S(t)&&9===t.nodeType}function C(t){return S(t)&&!!t.jquery}function N(t){return t instanceof Node||S(t)&&1<=t.nodeType}var _=e.toString;function M(t){return _.call(t).match(/^\[object (NodeList|HTMLCollection)\]$/)}function O(t){return "boolean"==typeof t}function D(t){return "string"==typeof t}function B(t){return "number"==typeof t}function z(t){return B(t)||D(t)&&!isNaN(t-parseFloat(t))}function P(t){return !($(t)?t.length:S(t)&&Object.keys(t).length)}function H(t){return void 0===t}function L(t){return O(t)?t:"true"===t||"1"===t||""===t||"false"!==t&&"0"!==t&&t}function F(t){var e=Number(t);return !isNaN(e)&&e}function j(t){return parseFloat(t)||0}function W(t){return N(t)||E(t)||A(t)?t:M(t)||C(t)?t[0]:$(t)?W(t[0]):null}function V(t){return N(t)?[t]:M(t)?g.slice.call(t):$(t)?t.map(W).filter(Boolean):C(t)?t.toArray():[]}function Y(t){return $(t)?t:D(t)?t.split(/,(?![^(]*\))/).map(function(t){return z(t)?F(t):L(t.trim())}):[t]}function R(t){return t?u(t,"ms")?j(t):1e3*j(t):0}function q(t,n){return t===n||S(t)&&S(n)&&Object.keys(t).length===Object.keys(n).length&&K(t,function(t,e){return t===n[e]})}function U(t,e,n){return t.replace(new RegExp(e+"|"+n,"mg"),function(t){return t===e?n:e})}var X=Object.assign||function(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];t=Object(t);for(var i=0;i<e.length;i++){var r=e[i];if(null!==r)for(var o in r)c(r,o)&&(t[o]=r[o]);}return t};function K(t,e){for(var n in t)if(!1===e(t[n],n))return !1;return !0}function G(t,r){return t.sort(function(t,e){var n=t[r];void 0===n&&(n=0);var i=e[r];return void 0===i&&(i=0),i<n?1:n<i?-1:0})}function J(t,n){var i=new Set;return t.filter(function(t){var e=t[n];return !i.has(e)&&(i.add(e)||!0)})}function Z(t,e,n){return void 0===e&&(e=0),void 0===n&&(n=1),Math.min(Math.max(F(t)||0,e),n)}function Q(){}function tt(t,e){return t.left<e.right&&t.right>e.left&&t.top<e.bottom&&t.bottom>e.top}function et(t,e){return t.x<=e.right&&t.x>=e.left&&t.y<=e.bottom&&t.y>=e.top}var nt={ratio:function(t,e,n){var i,r="width"===e?"height":"width";return (i={})[r]=t[e]?Math.round(n*t[r]/t[e]):t[r],i[e]=n,i},contain:function(n,i){var r=this;return K(n=X({},n),function(t,e){return n=n[e]>i[e]?r.ratio(n,e,i[e]):n}),n},cover:function(n,i){var r=this;return K(n=this.contain(n,i),function(t,e){return n=n[e]<i[e]?r.ratio(n,e,i[e]):n}),n}};function it(t,e,n){if(S(e))for(var i in e)it(t,i,e[i]);else{if(H(n))return (t=W(t))&&t.getAttribute(e);V(t).forEach(function(t){I(n)&&(n=n.call(t,it(t,e))),null===n?ot(t,e):t.setAttribute(e,n);});}}function rt(t,e){return V(t).some(function(t){return t.hasAttribute(e)})}function ot(t,e){t=V(t),e.split(" ").forEach(function(e){return t.forEach(function(t){return t.hasAttribute(e)&&t.removeAttribute(e)})});}function st(t,e){for(var n=0,i=[e,"data-"+e];n<i.length;n++)if(rt(t,i[n]))return it(t,i[n])}function at(t,e){return W(t)||ut(t,ct(t,e))}function ht(t,e){var n=V(t);return n.length&&n||lt(t,ct(t,e))}function ct(t,e){return void 0===e&&(e=document),mt(t)||A(e)?e:e.ownerDocument}function ut(t,e){return W(dt(t,e,"querySelector"))}function lt(t,e){return V(dt(t,e,"querySelectorAll"))}function dt(t,s,e){if(void 0===s&&(s=document),!t||!D(t))return null;var a;mt(t=t.replace(pt,"$1 *"))&&(a=[],t=function(t){return t.match(gt).map(function(t){return t.replace(/,$/,"").trim()})}(t).map(function(t,e){var n=s;if("!"===t[0]){var i=t.substr(1).trim().split(" ");n=xt(s.parentNode,i[0]),t=i.slice(1).join(" ").trim();}if("-"===t[0]){var r=t.substr(1).trim().split(" "),o=(n||s).previousElementSibling;n=bt(o,t.substr(1))?o:null,t=r.slice(1).join(" ");}return n?(n.id||(n.id="uk-"+Date.now()+e,a.push(function(){return ot(n,"id")})),"#"+It(n.id)+" "+t):null}).filter(Boolean).join(","),s=document);try{return s[e](t)}catch(t){return null}finally{a&&a.forEach(function(t){return t()});}}var ft=/(^|[^\\],)\s*[!>+~-]/,pt=/([!>+~-])(?=\s+[!>+~-]|\s*$)/g;function mt(t){return D(t)&&t.match(ft)}var gt=/.*?[^\\](?:,|$)/g;var vt=Element.prototype,wt=vt.matches||vt.webkitMatchesSelector||vt.msMatchesSelector;function bt(t,e){return V(t).some(function(t){return wt.call(t,e)})}var yt=vt.closest||function(t){var e=this;do{if(bt(e,t))return e;e=e.parentNode;}while(e&&1===e.nodeType)};function xt(t,e){return w(e,">")&&(e=e.slice(1)),N(t)?t.parentNode&&yt.call(t,e):V(t).map(function(t){return xt(t,e)}).filter(Boolean)}function kt(t,e){for(var n=[],i=W(t).parentNode;i&&1===i.nodeType;)bt(i,e)&&n.push(i),i=i.parentNode;return n}var $t=window.CSS&&CSS.escape||function(t){return t.replace(/([^\x7f-\uFFFF\w-])/g,function(t){return "\\"+t})};function It(t){return D(t)?$t.call(null,t):""}var St={area:!0,base:!0,br:!0,col:!0,embed:!0,hr:!0,img:!0,input:!0,keygen:!0,link:!0,menuitem:!0,meta:!0,param:!0,source:!0,track:!0,wbr:!0};function Tt(t){return V(t).some(function(t){return St[t.tagName.toLowerCase()]})}function Et(t){return V(t).some(function(t){return t.offsetWidth||t.offsetHeight||t.getClientRects().length})}var At="input,select,textarea,button";function Ct(t){return V(t).some(function(t){return bt(t,At)})}function Nt(t,e){return V(t).filter(function(t){return bt(t,e)})}function _t(t,e){return D(e)?bt(t,e)||xt(t,e):t===e||(A(e)?e.documentElement:W(e)).contains(W(t))}function Mt(){for(var t=[],e=arguments.length;e--;)t[e]=arguments[e];var n=Pt(t),i=n[0],r=n[1],o=n[2],s=n[3],a=n[4];return i=Ft(i),o&&(s=function(t,i,r){var o=this;return function(n){t.forEach(function(t){var e=">"===i[0]?lt(i,t).reverse().filter(function(t){return _t(n.target,t)})[0]:xt(n.target,i);e&&(n.delegate=t,n.current=e,r.call(o,n));});}}(i,o,s)),1<s.length&&(s=function(e){return function(t){return $(t.detail)?e.apply(void 0,[t].concat(t.detail)):e(t)}}(s)),r.split(" ").forEach(function(e){return i.forEach(function(t){return t.addEventListener(e,s,a)})}),function(){return Ot(i,r,s,a)}}function Ot(t,e,n,i){void 0===i&&(i=!1),t=Ft(t),e.split(" ").forEach(function(e){return t.forEach(function(t){return t.removeEventListener(e,n,i)})});}function Dt(){for(var t=[],e=arguments.length;e--;)t[e]=arguments[e];var n=Pt(t),i=n[0],r=n[1],o=n[2],s=n[3],a=n[4],h=n[5],c=Mt(i,r,o,function(t){var e=!h||h(t);e&&(c(),s(t,e));},a);return c}function Bt(t,n,i){return Ft(t).reduce(function(t,e){return t&&e.dispatchEvent(zt(n,!0,!0,i))},!0)}function zt(t,e,n,i){if(void 0===e&&(e=!0),void 0===n&&(n=!1),D(t)){var r=document.createEvent("CustomEvent");r.initCustomEvent(t,e,n,i),t=r;}return t}function Pt(t){return I(t[2])&&t.splice(2,0,!1),t}function Ht(t){return t&&"addEventListener"in t}function Lt(t){return Ht(t)?t:W(t)}function Ft(t){return $(t)?t.map(Lt).filter(Boolean):D(t)?lt(t):Ht(t)?[t]:V(t)}function jt(t){return "touch"===t.pointerType||t.touches}function Wt(t,e){void 0===e&&(e="client");var n=t.touches,i=t.changedTouches,r=n&&n[0]||i&&i[0]||t;return {x:r[e+"X"],y:r[e+"Y"]}}function Vt(){var n=this;this.promise=new Yt(function(t,e){n.reject=e,n.resolve=t;});}var Yt="Promise"in window?window.Promise:Ut,Rt=2,qt="setImmediate"in window?setImmediate:setTimeout;function Ut(t){this.state=Rt,this.value=void 0,this.deferred=[];var e=this;try{t(function(t){e.resolve(t);},function(t){e.reject(t);});}catch(t){e.reject(t);}}Ut.reject=function(n){return new Ut(function(t,e){e(n);})},Ut.resolve=function(n){return new Ut(function(t,e){t(n);})},Ut.all=function(s){return new Ut(function(n,t){var i=[],r=0;function e(e){return function(t){i[e]=t,(r+=1)===s.length&&n(i);}}0===s.length&&n(i);for(var o=0;o<s.length;o+=1)Ut.resolve(s[o]).then(e(o),t);})},Ut.race=function(i){return new Ut(function(t,e){for(var n=0;n<i.length;n+=1)Ut.resolve(i[n]).then(t,e);})};var Xt=Ut.prototype;function Kt(s,a){return new Yt(function(t,e){var n=X({data:null,method:"GET",headers:{},xhr:new XMLHttpRequest,beforeSend:Q,responseType:""},a);n.beforeSend(n);var i=n.xhr;for(var r in n)if(r in i)try{i[r]=n[r];}catch(t){}for(var o in i.open(n.method.toUpperCase(),s),n.headers)i.setRequestHeader(o,n.headers[o]);Mt(i,"load",function(){0===i.status||200<=i.status&&i.status<300||304===i.status?t(i):e(X(Error(i.statusText),{xhr:i,status:i.status}));}),Mt(i,"error",function(){return e(X(Error("Network Error"),{xhr:i}))}),Mt(i,"timeout",function(){return e(X(Error("Network Timeout"),{xhr:i}))}),i.send(n.data);})}function Gt(i,r,o){return new Yt(function(t,e){var n=new Image;n.onerror=e,n.onload=function(){return t(n)},o&&(n.sizes=o),r&&(n.srcset=r),n.src=i;})}Xt.resolve=function(t){var e=this;if(e.state===Rt){if(t===e)throw new TypeError("Promise settled with itself.");var n=!1;try{var i=t&&t.then;if(null!==t&&S(t)&&I(i))return void i.call(t,function(t){n||e.resolve(t),n=!0;},function(t){n||e.reject(t),n=!0;})}catch(t){return void(n||e.reject(t))}e.state=0,e.value=t,e.notify();}},Xt.reject=function(t){var e=this;if(e.state===Rt){if(t===e)throw new TypeError("Promise settled with itself.");e.state=1,e.value=t,e.notify();}},Xt.notify=function(){var o=this;qt(function(){if(o.state!==Rt)for(;o.deferred.length;){var t=o.deferred.shift(),e=t[0],n=t[1],i=t[2],r=t[3];try{0===o.state?I(e)?i(e.call(void 0,o.value)):i(o.value):1===o.state&&(I(n)?i(n.call(void 0,o.value)):r(o.value));}catch(t){r(t);}}});},Xt.then=function(n,i){var r=this;return new Ut(function(t,e){r.deferred.push([n,i,t,e]),r.notify();})},Xt.catch=function(t){return this.then(void 0,t)};var Jt=/msie|trident/i.test(window.navigator.userAgent),Zt="rtl"===it(document.documentElement,"dir"),Qt="ontouchstart"in window,te=window.PointerEvent,ee=Qt||window.DocumentTouch&&document instanceof DocumentTouch||navigator.maxTouchPoints,ne=te?"pointerdown":Qt?"touchstart":"mousedown",ie=te?"pointermove":Qt?"touchmove":"mousemove",re=te?"pointerup":Qt?"touchend":"mouseup",oe=te?"pointerenter":Qt?"":"mouseenter",se=te?"pointerleave":Qt?"":"mouseleave",ae=te?"pointercancel":"touchcancel";function he(t){if("loading"===document.readyState)var e=Mt(document,"DOMContentLoaded",function(){e(),t();});else t();}function ce(t,e){return e?V(t).indexOf(W(e)):V((t=W(t))&&t.parentNode.children).indexOf(t)}function ue(t,e,n,i){void 0===n&&(n=0),void 0===i&&(i=!1);var r=(e=V(e)).length;return t=z(t)?F(t):"next"===t?n+1:"previous"===t?n-1:ce(e,t),i?Z(t,0,r-1):(t%=r)<0?t+r:t}function le(t){return (t=Se(t)).innerHTML="",t}function de(t,e){return t=Se(t),H(e)?t.innerHTML:fe(t.hasChildNodes()?le(t):t,e)}function fe(e,t){return e=Se(e),ge(t,function(t){return e.appendChild(t)})}function pe(e,t){return e=Se(e),ge(t,function(t){return e.parentNode.insertBefore(t,e)})}function me(e,t){return e=Se(e),ge(t,function(t){return e.nextSibling?pe(e.nextSibling,t):fe(e.parentNode,t)})}function ge(t,e){return (t=D(t)?$e(t):t)?"length"in t?V(t).map(e):e(t):null}function ve(t){V(t).map(function(t){return t.parentNode&&t.parentNode.removeChild(t)});}function we(t,e){for(e=W(pe(t,e));e.firstChild;)e=e.firstChild;return fe(e,t),e}function be(t,e){return V(V(t).map(function(t){return t.hasChildNodes?we(V(t.childNodes),e):fe(t,e)}))}function ye(t){V(t).map(function(t){return t.parentNode}).filter(function(t,e,n){return n.indexOf(t)===e}).forEach(function(t){pe(t,t.childNodes),ve(t);});}var xe=/^\s*<(\w+|!)[^>]*>/,ke=/^<(\w+)\s*\/?>(?:<\/\1>)?$/;function $e(t){var e=ke.exec(t);if(e)return document.createElement(e[1]);var n=document.createElement("div");return xe.test(t)?n.insertAdjacentHTML("beforeend",t.trim()):n.textContent=t,1<n.childNodes.length?V(n.childNodes):n.firstChild}function Ie(t,e){if(t&&1===t.nodeType)for(e(t),t=t.firstElementChild;t;)Ie(t,e),t=t.nextElementSibling;}function Se(t,e){return D(t)?Ee(t)?W($e(t)):ut(t,e):W(t)}function Te(t,e){return D(t)?Ee(t)?V($e(t)):lt(t,e):V(t)}function Ee(t){return "<"===t[0]||t.match(/^\s*</)}function Ae(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];De(t,e,"add");}function Ce(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];De(t,e,"remove");}function Ne(t,e){it(t,"class",function(t){return (t||"").replace(new RegExp("\\b"+e+"\\b","g"),"")});}function _e(t){for(var e=[],n=arguments.length-1;0<n--;)e[n]=arguments[n+1];e[0]&&Ce(t,e[0]),e[1]&&Ae(t,e[1]);}function Me(t,e){return e&&V(t).some(function(t){return t.classList.contains(e.split(" ")[0])})}function Oe(t){for(var i=[],e=arguments.length-1;0<e--;)i[e]=arguments[e+1];if(i.length){var r=D((i=Be(i))[i.length-1])?[]:i.pop();i=i.filter(Boolean),V(t).forEach(function(t){for(var e=t.classList,n=0;n<i.length;n++)ze.Force?e.toggle.apply(e,[i[n]].concat(r)):e[(H(r)?!e.contains(i[n]):r)?"add":"remove"](i[n]);});}}function De(t,n,i){(n=Be(n).filter(Boolean)).length&&V(t).forEach(function(t){var e=t.classList;ze.Multiple?e[i].apply(e,n):n.forEach(function(t){return e[i](t)});});}function Be(t){return t.reduce(function(t,e){return t.concat.call(t,D(e)&&y(e," ")?e.trim().split(" "):e)},[])}var ze={get Multiple(){return this.get("_multiple")},get Force(){return this.get("_force")},get:function(t){if(!c(this,t)){var e=document.createElement("_").classList;e.add("a","b"),e.toggle("c",!1),this._multiple=e.contains("b"),this._force=!e.contains("c");}return this[t]}},Pe={"animation-iteration-count":!0,"column-count":!0,"fill-opacity":!0,"flex-grow":!0,"flex-shrink":!0,"font-weight":!0,"line-height":!0,opacity:!0,order:!0,orphans:!0,"stroke-dasharray":!0,"stroke-dashoffset":!0,widows:!0,"z-index":!0,zoom:!0};function He(t,e,r){return V(t).map(function(n){if(D(e)){if(e=Ye(e),H(r))return Fe(n,e);r||B(r)?n.style[e]=z(r)&&!Pe[e]?r+"px":r:n.style.removeProperty(e);}else{if($(e)){var i=Le(n);return e.reduce(function(t,e){return t[e]=i[Ye(e)],t},{})}S(e)&&K(e,function(t,e){return He(n,e,t)});}return n})[0]}function Le(t,e){return (t=W(t)).ownerDocument.defaultView.getComputedStyle(t,e)}function Fe(t,e,n){return Le(t,n)[e]}var je={};function We(t){var e=document.documentElement;if(!Jt)return Le(e).getPropertyValue("--uk-"+t);if(!(t in je)){var n=fe(e,document.createElement("div"));Ae(n,"uk-"+t),je[t]=Fe(n,"content",":before").replace(/^["'](.*)["']$/,"$1"),ve(n);}return je[t]}var Ve={};function Ye(t){var e=Ve[t];return e=e||(Ve[t]=function(t){t=d(t);var e=document.documentElement.style;if(t in e)return t;var n,i=Re.length;for(;i--;)if((n="-"+Re[i]+"-"+t)in e)return n}(t)||t)}var Re=["webkit","moz","ms"];function qe(t,s,a,h){return void 0===a&&(a=400),void 0===h&&(h="linear"),Yt.all(V(t).map(function(o){return new Yt(function(n,i){for(var t in s){var e=He(o,t);""===e&&He(o,t,e);}var r=setTimeout(function(){return Bt(o,"transitionend")},a);Dt(o,"transitionend transitioncanceled",function(t){var e=t.type;clearTimeout(r),Ce(o,"uk-transition"),He(o,{"transition-property":"","transition-duration":"","transition-timing-function":""}),"transitioncanceled"===e?i():n();},!1,function(t){var e=t.target;return o===e}),Ae(o,"uk-transition"),He(o,X({"transition-property":Object.keys(s).map(Ye).join(","),"transition-duration":a+"ms","transition-timing-function":h},s));})}))}var Ue={start:qe,stop:function(t){return Bt(t,"transitionend"),Yt.resolve()},cancel:function(t){Bt(t,"transitioncanceled");},inProgress:function(t){return Me(t,"uk-transition")}},Xe="uk-animation-",Ke="uk-cancel-animation";function Ge(t,e,n,a,h){var c=arguments;return void 0===n&&(n=200),Yt.all(V(t).map(function(s){return new Yt(function(i,r){if(Me(s,Ke))requestAnimationFrame(function(){return Yt.resolve().then(function(){return Ge.apply(void 0,c).then(i,r)})});else{var t=e+" "+Xe+(h?"leave":"enter");w(e,Xe)&&(a&&(t+=" uk-transform-origin-"+a),h&&(t+=" "+Xe+"reverse")),o(),Dt(s,"animationend animationcancel",function(t){var e=t.type,n=!1;"animationcancel"===e?(r(),o()):(i(),Yt.resolve().then(function(){n=!0,o();})),requestAnimationFrame(function(){n||(Ae(s,Ke),requestAnimationFrame(function(){return Ce(s,Ke)}));});},!1,function(t){var e=t.target;return s===e}),He(s,"animationDuration",n+"ms"),Ae(s,t);}function o(){He(s,"animationDuration",""),Ne(s,Xe+"\\S*");}})}))}var Je=new RegExp(Xe+"(enter|leave)"),Ze={in:function(t,e,n,i){return Ge(t,e,n,i,!1)},out:function(t,e,n,i){return Ge(t,e,n,i,!0)},inProgress:function(t){return Je.test(it(t,"class"))},cancel:function(t){Bt(t,"animationcancel");}},Qe={width:["x","left","right"],height:["y","top","bottom"]};function tn(t,e,u,l,d,n,i,r){u=un(u),l=un(l);var f={element:u,target:l};if(!t||!e)return f;var p=nn(t),m=nn(e),g=m;if(cn(g,u,p,-1),cn(g,l,m,1),d=ln(d,p.width,p.height),n=ln(n,m.width,m.height),d.x+=n.x,d.y+=n.y,g.left+=d.x,g.top+=d.y,i){var o=[nn(bn(t))];r&&o.unshift(nn(r)),K(Qe,function(t,s){var a=t[0],h=t[1],c=t[2];!0!==i&&!y(i,a)||o.some(function(i){var t=u[a]===h?-p[s]:u[a]===c?p[s]:0,e=l[a]===h?m[s]:l[a]===c?-m[s]:0;if(g[h]<i[h]||g[h]+p[s]>i[c]){var n=p[s]/2,r="center"===l[a]?-m[s]/2:0;return "center"===u[a]&&(o(n,r)||o(-n,-r))||o(t,e)}function o(e,t){var n=g[h]+e+t-2*d[a];if(n>=i[h]&&n+p[s]<=i[c])return g[h]=n,["element","target"].forEach(function(t){f[t][a]=e?f[t][a]===Qe[s][1]?Qe[s][2]:Qe[s][1]:f[t][a];}),!0}});});}return en(t,g),f}function en(n,i){if(n=W(n),!i)return nn(n);var r=en(n),o=He(n,"position");["left","top"].forEach(function(t){if(t in i){var e=He(n,t);He(n,t,i[t]-r[t]+j("absolute"===o&&"auto"===e?rn(n)[t]:e));}});}function nn(t){var e,n,i=bn(t=W(t)),r=i.pageYOffset,o=i.pageXOffset;if(E(t)){var s=t.innerHeight,a=t.innerWidth;return {top:r,left:o,height:s,width:a,bottom:r+s,right:o+a}}Et(t)||"none"!==He(t,"display")||(e=it(t,"style"),n=it(t,"hidden"),it(t,{style:(e||"")+";display:block !important;",hidden:null}));var h=t.getBoundingClientRect();return H(e)||it(t,{style:e,hidden:n}),{height:h.height,width:h.width,top:h.top+r,left:h.left+o,bottom:h.bottom+r,right:h.right+o}}function rn(i){var r=(i=W(i)).offsetParent||function(t){return yn(t).documentElement}(i),o=en(r),t=["top","left"].reduce(function(t,e){var n=p(e);return t[e]-=o[e]+j(He(i,"margin"+n))+j(He(r,"border"+n+"Width")),t},en(i));return {top:t.top,left:t.left}}var on=an("height"),sn=an("width");function an(i){var r=p(i);return function(t,e){if(t=W(t),H(e)){if(E(t))return t["inner"+r];if(A(t)){var n=t.documentElement;return Math.max(n["offset"+r],n["scroll"+r])}return (e="auto"===(e=He(t,i))?t["offset"+r]:j(e)||0)-hn(i,t)}He(t,i,e||0===e?+e+hn(i,t)+"px":"");}}function hn(t,n,e){return void 0===e&&(e="border-box"),He(n,"boxSizing")===e?Qe[t].slice(1).map(p).reduce(function(t,e){return t+j(He(n,"padding"+e))+j(He(n,"border"+e+"Width"))},0):0}function cn(o,s,a,h){K(Qe,function(t,e){var n=t[0],i=t[1],r=t[2];s[n]===r?o[i]+=a[e]*h:"center"===s[n]&&(o[i]+=a[e]*h/2);});}function un(t){var e=/left|center|right/,n=/top|center|bottom/;return 1===(t=(t||"").split(" ")).length&&(t=e.test(t[0])?t.concat(["center"]):n.test(t[0])?["center"].concat(t):["center","center"]),{x:e.test(t[0])?t[0]:"center",y:n.test(t[1])?t[1]:"center"}}function ln(t,e,n){var i=(t||"").split(" "),r=i[0],o=i[1];return {x:r?j(r)*(u(r,"%")?e/100:1):0,y:o?j(o)*(u(o,"%")?n/100:1):0}}function dn(t){switch(t){case"left":return "right";case"right":return "left";case"top":return "bottom";case"bottom":return "top";default:return t}}function fn(t,e,n){if(void 0===e&&(e=0),void 0===n&&(n=0),!Et(t))return !1;var i=bn(t=W(t)),r=t.getBoundingClientRect(),o={top:-e,left:-n,bottom:e+on(i),right:n+sn(i)};return tt(r,o)||et({x:r.left,y:r.top},o)}function pn(t,e){if(void 0===e&&(e=0),!Et(t))return 0;var n=bn(t=W(t)),i=yn(t),r=t.offsetHeight+e,o=gn(t)[0],s=on(n),a=s+Math.min(0,o-s),h=Math.max(0,s-(on(i)+e-(o+r)));return Z((a+n.pageYOffset-o)/((a+(r-(h<s?h:0)))/100)/100)}function mn(t,e){if(E(t=W(t))||A(t)){var n=bn(t);(0, n.scrollTo)(n.pageXOffset,e);}else t.scrollTop=e;}function gn(t){var e=[0,0];do{if(e[0]+=t.offsetTop,e[1]+=t.offsetLeft,"fixed"===He(t,"position")){var n=bn(t);return e[0]+=n.pageYOffset,e[1]+=n.pageXOffset,e}}while(t=t.offsetParent);return e}function vn(t,e,n){return void 0===e&&(e="width"),void 0===n&&(n=window),z(t)?+t:u(t,"vh")?wn(on(bn(n)),t):u(t,"vw")?wn(sn(bn(n)),t):u(t,"%")?wn(nn(n)[e],t):j(t)}function wn(t,e){return t*j(e)/100}function bn(t){return E(t)?t:yn(t).defaultView}function yn(t){return W(t).ownerDocument}var xn={reads:[],writes:[],read:function(t){return this.reads.push(t),$n(),t},write:function(t){return this.writes.push(t),$n(),t},clear:function(t){return Sn(this.reads,t)||Sn(this.writes,t)},flush:kn};function kn(){In(xn.reads),In(xn.writes.splice(0,xn.writes.length)),xn.scheduled=!1,(xn.reads.length||xn.writes.length)&&$n(!0);}function $n(t){void 0===t&&(t=!1),xn.scheduled||(xn.scheduled=!0,t?Yt.resolve().then(kn):requestAnimationFrame(kn));}function In(t){for(var e;e=t.shift();)e();}function Sn(t,e){var n=t.indexOf(e);return !!~n&&!!t.splice(n,1)}function Tn(){}function En(t,e){return (e.y-t.y)/(e.x-t.x)}Tn.prototype={positions:[],position:null,init:function(){var i=this;this.positions=[],this.position=null;var r=!1;this.unbind=Mt(document,"mousemove",function(n){r||(setTimeout(function(){var t=Date.now(),e=i.positions.length;e&&100<t-i.positions[e-1].time&&i.positions.splice(0,e),i.positions.push({time:t,x:n.pageX,y:n.pageY}),5<i.positions.length&&i.positions.shift(),r=!1;},5),r=!0);});},cancel:function(){this.unbind&&this.unbind();},movesTo:function(t){if(this.positions.length<2)return !1;var e=en(t),n=this.positions[this.positions.length-1],i=this.positions[0];if(e.left<=n.x&&n.x<=e.right&&e.top<=n.y&&n.y<=e.bottom)return !1;var r=[[{x:e.left,y:e.top},{x:e.right,y:e.bottom}],[{x:e.right,y:e.top},{x:e.left,y:e.bottom}]];return e.right<=n.x||(e.left>=n.x?(r[0].reverse(),r[1].reverse()):e.bottom<=n.y?r[0].reverse():e.top>=n.y&&r[1].reverse()),!!r.reduce(function(t,e){return t+(En(i,e[0])<En(n,e[0])&&En(i,e[1])>En(n,e[1]))},0)}};var An={};function Cn(t,e,n){return An.computed(I(t)?t.call(n,n):t,I(e)?e.call(n,n):e)}function Nn(t,e){return t=t&&!$(t)?[t]:t,e?t?t.concat(e):$(e)?e:[e]:t}function _n(e,n,i){var r={};if(I(n)&&(n=n.options),n.extends&&(e=_n(e,n.extends,i)),n.mixins)for(var t=0,o=n.mixins.length;t<o;t++)e=_n(e,n.mixins[t],i);for(var s in e)h(s);for(var a in n)c(e,a)||h(a);function h(t){r[t]=(An[t]||function(t,e){return H(e)?t:e})(e[t],n[t],i);}return r}function Mn(t,e){var n;void 0===e&&(e=[]);try{return t?w(t,"{")?JSON.parse(t):e.length&&!y(t,":")?((n={})[e[0]]=t,n):t.split(";").reduce(function(t,e){var n=e.split(/:(.*)/),i=n[0],r=n[1];return i&&!H(r)&&(t[i.trim()]=r.trim()),t},{}):{}}catch(t){return {}}}An.events=An.created=An.beforeConnect=An.connected=An.beforeDisconnect=An.disconnected=An.destroy=Nn,An.args=function(t,e){return !1!==e&&Nn(e||t)},An.update=function(t,e){return G(Nn(t,I(e)?{read:e}:e),"order")},An.props=function(t,e){return $(e)&&(e=e.reduce(function(t,e){return t[e]=String,t},{})),An.methods(t,e)},An.computed=An.methods=function(t,e){return e?t?X({},t,e):e:t},An.data=function(e,n,t){return t?Cn(e,n,t):n?e?function(t){return Cn(e,n,t)}:n:e};function On(t){this.id=++Dn,this.el=W(t);}var Dn=0;function Bn(t,e){try{t.contentWindow.postMessage(JSON.stringify(X({event:"command"},e)),"*");}catch(t){}}On.prototype.isVideo=function(){return this.isYoutube()||this.isVimeo()||this.isHTML5()},On.prototype.isHTML5=function(){return "VIDEO"===this.el.tagName},On.prototype.isIFrame=function(){return "IFRAME"===this.el.tagName},On.prototype.isYoutube=function(){return this.isIFrame()&&!!this.el.src.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/(watch\?v=[^&\s]+|embed)|youtu\.be\/.*/)},On.prototype.isVimeo=function(){return this.isIFrame()&&!!this.el.src.match(/vimeo\.com\/video\/.*/)},On.prototype.enableApi=function(){var e=this;if(this.ready)return this.ready;var n,i=this.isYoutube(),r=this.isVimeo();return i||r?this.ready=new Yt(function(t){Dt(e.el,"load",function(){if(i){var t=function(){return Bn(e.el,{event:"listening",id:e.id})};n=setInterval(t,100),t();}}),function(i){return new Yt(function(n){Dt(window,"message",function(t,e){return n(e)},!1,function(t){var e=t.data;if(e&&D(e)){try{e=JSON.parse(e);}catch(t){return}return e&&i(e)}});})}(function(t){return i&&t.id===e.id&&"onReady"===t.event||r&&Number(t.player_id)===e.id}).then(function(){t(),n&&clearInterval(n);}),it(e.el,"src",e.el.src+(y(e.el.src,"?")?"&":"?")+(i?"enablejsapi=1":"api=1&player_id="+e.id));}):Yt.resolve()},On.prototype.play=function(){var t=this;if(this.isVideo())if(this.isIFrame())this.enableApi().then(function(){return Bn(t.el,{func:"playVideo",method:"play"})});else if(this.isHTML5())try{var e=this.el.play();e&&e.catch(Q);}catch(t){}},On.prototype.pause=function(){var t=this;this.isVideo()&&(this.isIFrame()?this.enableApi().then(function(){return Bn(t.el,{func:"pauseVideo",method:"pause"})}):this.isHTML5()&&this.el.pause());},On.prototype.mute=function(){var t=this;this.isVideo()&&(this.isIFrame()?this.enableApi().then(function(){return Bn(t.el,{func:"mute",method:"setVolume",value:0})}):this.isHTML5()&&(this.el.muted=!0,it(this.el,"muted","")));};var zn="IntersectionObserver"in window?window.IntersectionObserver:function(){function t(e,t){var n=this;void 0===t&&(t={});var i=t.rootMargin;void 0===i&&(i="0 0"),this.targets=[];var r,o=(i||"0 0").split(" ").map(j),s=o[0],a=o[1];this.offsetTop=s,this.offsetLeft=a,this.apply=function(){r=r||requestAnimationFrame(function(){return setTimeout(function(){var t=n.takeRecords();t.length&&e(t,n),r=!1;})});},this.off=Mt(window,"scroll resize load",this.apply,{passive:!0,capture:!0});}return t.prototype.takeRecords=function(){var n=this;return this.targets.filter(function(t){var e=fn(t.target,n.offsetTop,n.offsetLeft);if(null===t.isIntersecting||e^t.isIntersecting)return t.isIntersecting=e,!0})},t.prototype.observe=function(t){this.targets.push({target:t,isIntersecting:null}),this.apply();},t.prototype.disconnect=function(){this.targets=[],this.off();},t}();function Pn(t){return !(!w(t,"uk-")&&!w(t,"data-uk-"))&&f(t.replace("data-uk-","").replace("uk-",""))}function Hn(t){this._init(t);}var Ln,Fn,jn,Wn,Vn,Yn,Rn,qn,Un;function Xn(t,e){if(t)for(var n in t)t[n]._connected&&t[n]._callUpdate(e);}function Kn(t,e){var n={},i=t.args;void 0===i&&(i=[]);var r=t.props;void 0===r&&(r={});var o=t.el;if(!r)return n;for(var s in r){var a=d(s),h=st(o,a);if(!H(h)){if(h=r[s]===Boolean&&""===h||Qn(r[s],h),"target"===a&&(!h||w(h,"_")))continue;n[s]=h;}}var c=Mn(st(o,e),i);for(var u in c){var l=f(u);void 0!==r[l]&&(n[l]=Qn(r[l],c[u]));}return n}function Gn(i,r,o){Object.defineProperty(i,r,{enumerable:!0,get:function(){var t=i._computeds,e=i.$props,n=i.$el;return c(t,r)||(t[r]=(o.get||o).call(i,e,n)),t[r]},set:function(t){var e=i._computeds;e[r]=o.set?o.set.call(i,t):t,H(e[r])&&delete e[r];}});}function Jn(e,n,i){T(n)||(n={name:i,handler:n});var t=n.name,r=n.el,o=n.handler,s=n.capture,a=n.passive,h=n.delegate,c=n.filter,u=n.self;r=I(r)?r.call(e):r||e.$el,$(r)?r.forEach(function(t){return Jn(e,X({},n,{el:t}),i)}):!r||c&&!c.call(e)||(o=function(e){return function(t){return $(t.detail)?e.apply(void 0,[t].concat(t.detail)):e(t)}}(D(o)?e[o]:l(o,e)),u&&(o=function(e){return function(t){if(t.target===t.currentTarget||t.target===t.current)return e.call(null,t)}}(o)),e._events.push(Mt(r,t,h?D(h)?h:h.call(e):null,o,O(a)?{passive:a,capture:s}:s)));}function Zn(t,e){return t.every(function(t){return !t||!c(t,e)})}function Qn(t,e){return t===Boolean?L(e):t===Number?F(e):"list"===t?Y(e):t?t(e):e}Hn.util=Object.freeze({ajax:Kt,getImage:Gt,transition:qe,Transition:Ue,animate:Ge,Animation:Ze,attr:it,hasAttr:rt,removeAttr:ot,data:st,addClass:Ae,removeClass:Ce,removeClasses:Ne,replaceClass:_e,hasClass:Me,toggleClass:Oe,positionAt:tn,offset:en,position:rn,height:on,width:sn,boxModelAdjust:hn,flipPosition:dn,isInView:fn,scrolledOver:pn,scrollTop:mn,offsetPosition:gn,toPx:vn,ready:he,index:ce,getIndex:ue,empty:le,html:de,prepend:function(e,t){return (e=Se(e)).hasChildNodes()?ge(t,function(t){return e.insertBefore(t,e.firstChild)}):fe(e,t)},append:fe,before:pe,after:me,remove:ve,wrapAll:we,wrapInner:be,unwrap:ye,fragment:$e,apply:Ie,$:Se,$$:Te,isIE:Jt,isRtl:Zt,hasTouch:ee,pointerDown:ne,pointerMove:ie,pointerUp:re,pointerEnter:oe,pointerLeave:se,pointerCancel:ae,on:Mt,off:Ot,once:Dt,trigger:Bt,createEvent:zt,toEventTargets:Ft,isTouch:jt,getEventPos:Wt,fastdom:xn,isVoidElement:Tt,isVisible:Et,selInput:At,isInput:Ct,filter:Nt,within:_t,bind:l,hasOwn:c,hyphenate:d,camelize:f,ucfirst:p,startsWith:w,endsWith:u,includes:y,findIndex:k,isArray:$,isFunction:I,isObject:S,isPlainObject:T,isWindow:E,isDocument:A,isJQuery:C,isNode:N,isNodeCollection:M,isBoolean:O,isString:D,isNumber:B,isNumeric:z,isEmpty:P,isUndefined:H,toBoolean:L,toNumber:F,toFloat:j,toNode:W,toNodes:V,toList:Y,toMs:R,isEqual:q,swap:U,assign:X,each:K,sortBy:G,uniqueBy:J,clamp:Z,noop:Q,intersectRect:tt,pointInRect:et,Dimensions:nt,MouseTracker:Tn,mergeOptions:_n,parseOptions:Mn,Player:On,Promise:Yt,Deferred:Vt,IntersectionObserver:zn,query:at,queryAll:ht,find:ut,findAll:lt,matches:bt,closest:xt,parents:kt,escape:It,css:He,getStyles:Le,getStyle:Fe,getCssVar:We,propName:Ye}),Hn.data="__uikit__",Hn.prefix="uk-",Hn.options={},jn=(Ln=Hn).data,Ln.use=function(t){if(!t.installed)return t.call(null,this),t.installed=!0,this},Ln.mixin=function(t,e){(e=(D(e)?Ln.component(e):e)||this).options=_n(e.options,t);},Ln.extend=function(t){function e(t){this._init(t);}return t=t||{},((e.prototype=Object.create(this.prototype)).constructor=e).options=_n(this.options,t),e.super=this,e.extend=this.extend,e},Ln.update=function(t,e){(function t(e,n){e&&e!==document.body&&e.parentNode&&(t(e.parentNode,n),n(e.parentNode));})(t=t?W(t):document.body,function(t){return Xn(t[jn],e)}),Ie(t,function(t){return Xn(t[jn],e)});},Object.defineProperty(Ln,"container",{get:function(){return Fn||document.body},set:function(t){Fn=Se(t);}}),(Wn=Hn).prototype._callHook=function(t){var e=this,n=this.$options[t];n&&n.forEach(function(t){return t.call(e)});},Wn.prototype._callConnected=function(){this._connected||(this._data={},this._computeds={},this._initProps(),this._callHook("beforeConnect"),this._connected=!0,this._initEvents(),this._initObserver(),this._callHook("connected"),this._callUpdate());},Wn.prototype._callDisconnected=function(){this._connected&&(this._callHook("beforeDisconnect"),this._observer&&(this._observer.disconnect(),this._observer=null),this._unbindEvents(),this._callHook("disconnected"),this._connected=!1);},Wn.prototype._callUpdate=function(t){var o=this;void 0===t&&(t="update");var s=t.type||t;y(["update","resize"],s)&&this._callWatches();var e=this.$options.update,n=this._frames,a=n.reads,h=n.writes;e&&e.forEach(function(t,e){var n=t.read,i=t.write,r=t.events;"update"!==s&&!y(r,s)||(n&&!y(xn.reads,a[e])&&(a[e]=xn.read(function(){var t=o._connected&&n.call(o,o._data,s);!1===t&&i?xn.clear(h[e]):T(t)&&X(o._data,t);})),i&&!y(xn.writes,h[e])&&(h[e]=xn.write(function(){return o._connected&&i.call(o,o._data,s)})));});},Yn=0,(Vn=Hn).prototype._init=function(t){(t=t||{}).data=function(t,e){var n=t.data,i=(t.el,e.args),r=e.props;if(void 0===r&&(r={}),n=$(n)?P(i)?void 0:n.slice(0,i.length).reduce(function(t,e,n){return T(e)?X(t,e):t[i[n]]=e,t},{}):n)for(var o in n)H(n[o])?delete n[o]:n[o]=r[o]?Qn(r[o],n[o]):n[o];return n}(t,this.constructor.options),this.$options=_n(this.constructor.options,t,this),this.$el=null,this.$props={},this._frames={reads:{},writes:{}},this._events=[],this._uid=Yn++,this._initData(),this._initMethods(),this._initComputeds(),this._callHook("created"),t.el&&this.$mount(t.el);},Vn.prototype._initData=function(){var t=this.$options.data;for(var e in void 0===t&&(t={}),t)this.$props[e]=this[e]=t[e];},Vn.prototype._initMethods=function(){var t=this.$options.methods;if(t)for(var e in t)this[e]=l(t[e],this);},Vn.prototype._initComputeds=function(){var t=this.$options.computed;if(this._computeds={},t)for(var e in t)Gn(this,e,t[e]);},Vn.prototype._callWatches=function(){var t=this.$options.computed,e=this._computeds;for(var n in e){var i=e[n];delete e[n],t[n].watch&&!q(i,this[n])&&t[n].watch.call(this,this[n],i);}},Vn.prototype._initProps=function(t){var e;for(e in t=t||Kn(this.$options,this.$name))H(t[e])||(this.$props[e]=t[e]);var n=[this.$options.computed,this.$options.methods];for(e in this.$props)e in t&&Zn(n,e)&&(this[e]=this.$props[e]);},Vn.prototype._initEvents=function(){var n=this,t=this.$options.events;t&&t.forEach(function(t){if(c(t,"handler"))Jn(n,t);else for(var e in t)Jn(n,t[e],e);});},Vn.prototype._unbindEvents=function(){this._events.forEach(function(t){return t()}),this._events=[];},Vn.prototype._initObserver=function(){var n=this,t=this.$options,i=t.attrs,e=t.props,r=t.el;if(!this._observer&&e&&!1!==i){i=$(i)?i:Object.keys(e),this._observer=new MutationObserver(function(){var e=Kn(n.$options,n.$name);i.some(function(t){return !H(e[t])&&e[t]!==n.$props[t]})&&n.$reset();});var o=i.map(function(t){return d(t)}).concat(this.$name);this._observer.observe(r,{attributes:!0,attributeFilter:o.concat(o.map(function(t){return "data-"+t}))});}},qn=(Rn=Hn).data,Un={},Rn.component=function(s,t){if(!t)return T(Un[s])&&(Un[s]=Rn.extend(Un[s])),Un[s];Rn[s]=function(t,n){for(var e=arguments.length,i=Array(e);e--;)i[e]=arguments[e];var r=Rn.component(s);return T(t)?new r({data:t}):r.options.functional?new r({data:[].concat(i)}):t&&t.nodeType?o(t):Te(t).map(o)[0];function o(t){var e=Rn.getComponent(t,s);if(e){if(!n)return e;e.$destroy();}return new r({el:t,data:n})}};var e=T(t)?X({},t):t.options;if(e.name=s,e.install&&e.install(Rn,e,s),Rn._initialized&&!e.functional){var n=d(s);xn.read(function(){return Rn[s]("[uk-"+n+"],[data-uk-"+n+"]")});}return Un[s]=T(t)?e:t},Rn.getComponents=function(t){return t&&t[qn]||{}},Rn.getComponent=function(t,e){return Rn.getComponents(t)[e]},Rn.connect=function(t){if(t[qn])for(var e in t[qn])t[qn][e]._callConnected();for(var n=0;n<t.attributes.length;n++){var i=Pn(t.attributes[n].name);i&&i in Un&&Rn[i](t);}},Rn.disconnect=function(t){for(var e in t[qn])t[qn][e]._callDisconnected();},function(i){var r=i.data;i.prototype.$mount=function(t){var e=this.$options.name;t[r]||(t[r]={}),t[r][e]||((t[r][e]=this).$el=this.$options.el=this.$options.el||t,_t(t,document)&&this._callConnected());},i.prototype.$emit=function(t){this._callUpdate(t);},i.prototype.$reset=function(){this._callDisconnected(),this._callConnected();},i.prototype.$destroy=function(t){void 0===t&&(t=!1);var e=this.$options,n=e.el,i=e.name;n&&this._callDisconnected(),this._callHook("destroy"),n&&n[r]&&(delete n[r][i],P(n[r])||delete n[r],t&&ve(this.$el));},i.prototype.$create=function(t,e,n){return i[t](e,n)},i.prototype.$update=i.update,i.prototype.$getComponent=i.getComponent;var e={};Object.defineProperties(i.prototype,{$container:Object.getOwnPropertyDescriptor(i,"container"),$name:{get:function(){var t=this.$options.name;return e[t]||(e[t]=i.prefix+d(t)),e[t]}}});}(Hn);var ti={connected:function(){Me(this.$el,this.$name)||Ae(this.$el,this.$name);}},ei={props:{cls:Boolean,animation:"list",duration:Number,origin:String,transition:String,queued:Boolean},data:{cls:!1,animation:[!1],duration:200,origin:!1,transition:"linear",queued:!1,initProps:{overflow:"",height:"",paddingTop:"",paddingBottom:"",marginTop:"",marginBottom:""},hideProps:{overflow:"hidden",height:0,paddingTop:0,paddingBottom:0,marginTop:0,marginBottom:0}},computed:{hasAnimation:function(t){return !!t.animation[0]},hasTransition:function(t){var e=t.animation;return this.hasAnimation&&!0===e[0]}},methods:{toggleElement:function(c,u,l){var d=this;return new Yt(function(t){c=V(c);function e(t){return Yt.all(t.map(function(t){return d._toggleElement(t,u,l)}))}var n,i=c.filter(function(t){return d.isToggled(t)}),r=c.filter(function(t){return !y(i,t)});if(d.queued&&H(l)&&H(u)&&d.hasAnimation&&!(c.length<2)){var o=document.body,s=o.scrollTop,a=i[0],h=Ze.inProgress(a)&&Me(a,"uk-animation-leave")||Ue.inProgress(a)&&"0px"===a.style.height;n=e(i),h||(n=n.then(function(){var t=e(r);return o.scrollTop=s,t}));}else n=e(r.concat(i));n.then(t,Q);})},toggleNow:function(e,n){var i=this;return new Yt(function(t){return Yt.all(V(e).map(function(t){return i._toggleElement(t,n,!1)})).then(t,Q)})},isToggled:function(t){var e=V(t||this.$el);return this.cls?Me(e,this.cls.split(" ")[0]):!rt(e,"hidden")},updateAria:function(t){!1===this.cls&&it(t,"aria-hidden",!this.isToggled(t));},_toggleElement:function(t,e,n){var i=this;if(e=O(e)?e:Ze.inProgress(t)?Me(t,"uk-animation-leave"):Ue.inProgress(t)?"0px"===t.style.height:!this.isToggled(t),!Bt(t,"before"+(e?"show":"hide"),[this]))return Yt.reject();var r=(I(n)?n:!1!==n&&this.hasAnimation?this.hasTransition?function(t){var s=t.isToggled,a=t.duration,h=t.initProps,c=t.hideProps,u=t.transition,l=t._toggle;return function(t,e){var n=Ue.inProgress(t),i=t.hasChildNodes?j(He(t.firstElementChild,"marginTop"))+j(He(t.lastElementChild,"marginBottom")):0,r=Et(t)?on(t)+(n?0:i):0;Ue.cancel(t),s(t)||l(t,!0),on(t,""),xn.flush();var o=on(t)+(n?0:i);return on(t,r),(e?Ue.start(t,X({},h,{overflow:"hidden",height:o}),Math.round(a*(1-r/o)),u):Ue.start(t,c,Math.round(a*(r/o)),u).then(function(){return l(t,!1)})).then(function(){return He(t,h)})}}(this):function(t){var n=t.animation,i=t.duration,r=t.origin,o=t._toggle;return function(t,e){return Ze.cancel(t),e?(o(t,!0),Ze.in(t,n[0],i,r)):Ze.out(t,n[1]||n[0],i,r).then(function(){return o(t,!1)})}}(this):this._toggle)(t,e);Bt(t,e?"show":"hide",[this]);function o(){Bt(t,e?"shown":"hidden",[i]),i.$update(t);}return r?r.then(o):Yt.resolve(o())},_toggle:function(t,e){var n;t&&(e=Boolean(e),this.cls?(n=y(this.cls," ")||e!==Me(t,this.cls))&&Oe(t,this.cls,y(this.cls," ")?void 0:e):(n=e===rt(t,"hidden"))&&it(t,"hidden",e?null:""),Te("[autofocus]",t).some(function(t){return Et(t)?t.focus()||!0:t.blur()}),this.updateAria(t),n&&this.$update(t));}}};var ni={mixins:[ti,ei],props:{targets:String,active:null,collapsible:Boolean,multiple:Boolean,toggle:String,content:String,transition:String},data:{targets:"> *",active:!1,animation:[!0],collapsible:!0,multiple:!1,clsOpen:"uk-open",toggle:"> .uk-accordion-title",content:"> .uk-accordion-content",transition:"ease"},computed:{items:function(t,e){return Te(t.targets,e)}},events:[{name:"click",delegate:function(){return this.targets+" "+this.$props.toggle},handler:function(t){t.preventDefault(),this.toggle(ce(Te(this.targets+" "+this.$props.toggle,this.$el),t.current));}}],connected:function(){if(!1!==this.active){var t=this.items[Number(this.active)];t&&!Me(t,this.clsOpen)&&this.toggle(t,!1);}},update:function(){var e=this;this.items.forEach(function(t){return e._toggle(Se(e.content,t),Me(t,e.clsOpen))});var t=!this.collapsible&&!Me(this.items,this.clsOpen)&&this.items[0];t&&this.toggle(t,!1);},methods:{toggle:function(r,o){var s=this,t=ue(r,this.items),a=Nt(this.items,"."+this.clsOpen);(r=this.items[t])&&[r].concat(!this.multiple&&!y(a,r)&&a||[]).forEach(function(t){var e=t===r,n=e&&!Me(t,s.clsOpen);if(n||!e||s.collapsible||!(a.length<2)){Oe(t,s.clsOpen,n);var i=t._wrapper?t._wrapper.firstElementChild:Se(s.content,t);t._wrapper||(t._wrapper=we(i,"<div>"),it(t._wrapper,"hidden",n?"":null)),s._toggle(i,!0),s.toggleElement(t._wrapper,n,o).then(function(){Me(t,s.clsOpen)===n&&(n||s._toggle(i,!1),t._wrapper=null,ye(i));});}});}}},ii={mixins:[ti,ei],args:"animation",props:{close:String},data:{animation:[!0],selClose:".uk-alert-close",duration:150,hideProps:X({opacity:0},ei.data.hideProps)},events:[{name:"click",delegate:function(){return this.selClose},handler:function(t){t.preventDefault(),this.close();}}],methods:{close:function(){var t=this;this.toggleElement(this.$el).then(function(){return t.$destroy(!0)});}}};function ri(r){he(function(){var n;r.update(),Mt(window,"load resize",function(){return r.update(null,"resize")}),Mt(document,"loadedmetadata load",function(t){var e=t.target;return r.update(e,"resize")},!0),Mt(window,"scroll",function(t){if(!n){n=!0,xn.write(function(){return n=!1});var e=t.target;r.update(1!==e.nodeType?document.body:e,t.type);}},{passive:!0,capture:!0});var e,i=0;Mt(document,"animationstart",function(t){var e=t.target;(He(e,"animationName")||"").match(/^uk-.*(left|right)/)&&(i++,He(document.body,"overflowX","hidden"),setTimeout(function(){--i||He(document.body,"overflowX","");},R(He(e,"animationDuration"))+100));},!0),Mt(document,ne,function(t){if(e&&e(),jt(t)){var r=Wt(t),o="tagName"in t.target?t.target:t.target.parentNode;e=Dt(document,re,function(t){var e=Wt(t),n=e.x,i=e.y;(o&&n&&100<Math.abs(r.x-n)||i&&100<Math.abs(r.y-i))&&setTimeout(function(){Bt(o,"swipe"),Bt(o,"swipe"+function(t,e,n,i){return Math.abs(t-n)>=Math.abs(e-i)?0<t-n?"Left":"Right":0<e-i?"Up":"Down"}(r.x,r.y,n,i));});});}},{passive:!0});});}var oi,si,ai={args:"autoplay",props:{automute:Boolean,autoplay:Boolean},data:{automute:!1,autoplay:!0},computed:{inView:function(t){return "inview"===t.autoplay}},connected:function(){this.inView&&!rt(this.$el,"preload")&&(this.$el.preload="none"),this.player=new On(this.$el),this.automute&&this.player.mute();},update:{read:function(){return !!this.player&&{visible:Et(this.$el)&&"hidden"!==He(this.$el,"visibility"),inView:this.inView&&fn(this.$el)}},write:function(t){var e=t.visible,n=t.inView;!e||this.inView&&!n?this.player.pause():(!0===this.autoplay||this.inView&&n)&&this.player.play();},events:["resize","scroll"]}},hi={mixins:[ti,ai],props:{width:Number,height:Number},data:{automute:!0},update:{read:function(){var t=this.$el;if(!Et(t))return !1;var e=t.parentNode;return {height:e.offsetHeight,width:e.offsetWidth}},write:function(t){var e=t.height,n=t.width,i=this.$el,r=this.width||i.naturalWidth||i.videoWidth||i.clientWidth,o=this.height||i.naturalHeight||i.videoHeight||i.clientHeight;r&&o&&He(i,nt.cover({width:r,height:o},{width:n+(n%2?1:0),height:e+(e%2?1:0)}));},events:["resize"]}},ci={props:{pos:String,offset:null,flip:Boolean,clsPos:String},data:{pos:"bottom-"+(Zt?"right":"left"),flip:!0,offset:!1,clsPos:""},computed:{pos:function(t){var e=t.pos;return (e+(y(e,"-")?"":"-center")).split("-")},dir:function(){return this.pos[0]},align:function(){return this.pos[1]}},methods:{positionAt:function(t,e,n){var i;Ne(t,this.clsPos+"-(top|bottom|left|right)(-[a-z]+)?"),He(t,{top:"",left:""});var r=this.offset,o=this.getAxis();z(r)||(r=(i=Se(r))?en(i)["x"===o?"left":"top"]-en(e)["x"===o?"right":"bottom"]:0);var s=tn(t,e,"x"===o?dn(this.dir)+" "+this.align:this.align+" "+dn(this.dir),"x"===o?this.dir+" "+this.align:this.align+" "+this.dir,"x"===o?""+("left"===this.dir?-r:r):" "+("top"===this.dir?-r:r),null,this.flip,n).target,a=s.x,h=s.y;this.dir="x"===o?a:h,this.align="x"===o?h:a,Oe(t,this.clsPos+"-"+this.dir+"-"+this.align,!1===this.offset);},getAxis:function(){return "top"===this.dir||"bottom"===this.dir?"y":"x"}}},ui={mixins:[ci,ei],args:"pos",props:{mode:"list",toggle:Boolean,boundary:Boolean,boundaryAlign:Boolean,delayShow:Number,delayHide:Number,clsDrop:String},data:{mode:["click","hover"],toggle:"- *",boundary:window,boundaryAlign:!1,delayShow:0,delayHide:800,clsDrop:!1,hoverIdle:200,animation:["uk-animation-fade"],cls:"uk-open"},computed:{boundary:function(t,e){return at(t.boundary,e)},clsDrop:function(t){return t.clsDrop||"uk-"+this.$options.name},clsPos:function(){return this.clsDrop}},created:function(){this.tracker=new Tn;},connected:function(){Ae(this.$el,this.clsDrop);var t=this.$props.toggle;this.toggle=t&&this.$create("toggle",at(t,this.$el),{target:this.$el,mode:this.mode}),this.toggle||Bt(this.$el,"updatearia");},events:[{name:"click",delegate:function(){return "."+this.clsDrop+"-close"},handler:function(t){t.preventDefault(),this.hide(!1);}},{name:"click",delegate:function(){return 'a[href^="#"]'},handler:function(t){var e=t.target.hash;e||t.preventDefault(),e&&_t(e,this.$el)||this.hide(!1);}},{name:"beforescroll",handler:function(){this.hide(!1);}},{name:"toggle",self:!0,handler:function(t,e){t.preventDefault(),this.isToggled()?this.hide(!1):this.show(e,!1);}},{name:oe,filter:function(){return y(this.mode,"hover")},handler:function(t){jt(t)||(oi&&oi!==this&&oi.toggle&&y(oi.toggle.mode,"hover")&&!_t(t.target,oi.toggle.$el)&&!et({x:t.pageX,y:t.pageY},en(oi.$el))&&oi.hide(!1),t.preventDefault(),this.show(this.toggle));}},{name:"toggleshow",handler:function(t,e){e&&!y(e.target,this.$el)||(t.preventDefault(),this.show(e||this.toggle));}},{name:"togglehide "+se,handler:function(t,e){jt(t)||e&&!y(e.target,this.$el)||(t.preventDefault(),this.toggle&&y(this.toggle.mode,"hover")&&this.hide());}},{name:"beforeshow",self:!0,handler:function(){this.clearTimers(),Ze.cancel(this.$el),this.position();}},{name:"show",self:!0,handler:function(){this.tracker.init(),Bt(this.$el,"updatearia"),function(){if(si)return;si=!0,Mt(document,re,function(t){var e,n=t.target;if(!t.defaultPrevented)for(;oi&&oi!==e&&!_t(n,oi.$el)&&(!oi.toggle||!_t(n,oi.toggle.$el));)(e=oi).hide(!1);});}();}},{name:"beforehide",self:!0,handler:function(){this.clearTimers();}},{name:"hide",handler:function(t){var e=t.target;this.$el===e?(oi=this.isActive()?null:oi,Bt(this.$el,"updatearia"),this.tracker.cancel()):oi=null===oi&&_t(e,this.$el)&&this.isToggled()?this:oi;}},{name:"updatearia",self:!0,handler:function(t,e){t.preventDefault(),this.updateAria(this.$el),(e||this.toggle)&&(it((e||this.toggle).$el,"aria-expanded",this.isToggled()?"true":"false"),Oe(this.toggle.$el,this.cls,this.isToggled()));}}],update:{write:function(){this.isToggled()&&!Ze.inProgress(this.$el)&&this.position();},events:["resize"]},methods:{show:function(e,n){var i=this;void 0===n&&(n=!0);function r(){return !i.isToggled()&&i.toggleElement(i.$el,!0)}function t(){if(i.toggle=e||i.toggle,i.clearTimers(),!i.isActive())if(n&&oi&&oi!==i&&oi.isDelaying)i.showTimer=setTimeout(i.show,10);else{if(i.isParentOf(oi)){if(!oi.hideTimer)return;oi.hide(!1);}else if(oi&&i.isChildOf(oi))oi.clearTimers();else if(oi&&!i.isChildOf(oi)&&!i.isParentOf(oi))for(var t;oi&&oi!==t&&!i.isChildOf(oi);)(t=oi).hide(!1);n&&i.delayShow?i.showTimer=setTimeout(r,i.delayShow):r(),oi=i;}}e&&this.toggle&&e.$el!==this.toggle.$el?(Dt(this.$el,"hide",t),this.hide(!1)):t();},hide:function(t){var e=this;void 0===t&&(t=!0);function n(){return e.toggleNow(e.$el,!1)}this.clearTimers(),this.isDelaying=this.tracker.movesTo(this.$el),t&&this.isDelaying?this.hideTimer=setTimeout(this.hide,this.hoverIdle):t&&this.delayHide?this.hideTimer=setTimeout(n,this.delayHide):n();},clearTimers:function(){clearTimeout(this.showTimer),clearTimeout(this.hideTimer),this.showTimer=null,this.hideTimer=null,this.isDelaying=!1;},isActive:function(){return oi===this},isChildOf:function(t){return t&&t!==this&&_t(this.$el,t.$el)},isParentOf:function(t){return t&&t!==this&&_t(t.$el,this.$el)},position:function(){Ne(this.$el,this.clsDrop+"-(stack|boundary)"),He(this.$el,{top:"",left:"",display:"block"}),Oe(this.$el,this.clsDrop+"-boundary",this.boundaryAlign);var t=en(this.boundary),e=this.boundaryAlign?t:en(this.toggle.$el);if("justify"===this.align){var n="y"===this.getAxis()?"width":"height";He(this.$el,n,e[n]);}else this.$el.offsetWidth>Math.max(t.right-e.left,e.right-t.left)&&Ae(this.$el,this.clsDrop+"-stack");this.positionAt(this.$el,this.boundaryAlign?this.boundary:this.toggle.$el,this.boundary),He(this.$el,"display","");}}};var li={extends:ui},di={mixins:[ti],args:"target",props:{target:Boolean},data:{target:!1},computed:{input:function(t,e){return Se(At,e)},state:function(){return this.input.nextElementSibling},target:function(t,e){var n=t.target;return n&&(!0===n&&this.input.parentNode===e&&this.input.nextElementSibling||at(n,e))}},update:function(){var t=this.target,e=this.input;if(t){var n,i=Ct(t)?"value":"textContent",r=t[i],o=e.files&&e.files[0]?e.files[0].name:bt(e,"select")&&(n=Te("option",e).filter(function(t){return t.selected})[0])?n.textContent:e.value;r!==o&&(t[i]=o);}},events:[{name:"change",handler:function(){this.$emit();}},{name:"reset",el:function(){return xt(this.$el,"form")},handler:function(){this.$emit();}}]},fi={update:{read:function(t){var e=fn(this.$el);if(!e||t.isInView===e)return !1;t.isInView=e;},write:function(){this.$el.src=this.$el.src;},events:["scroll","resize"]}},pi={props:{margin:String,firstColumn:Boolean},data:{margin:"uk-margin-small-top",firstColumn:"uk-first-column"},update:{read:function(t){var e=this.$el.children;if(!e.length||!Et(this.$el))return t.rows=[[]];t.rows=mi(e),t.stacks=!t.rows.some(function(t){return 1<t.length});},write:function(t){var i=this;t.rows.forEach(function(t,n){return t.forEach(function(t,e){Oe(t,i.margin,0!==n),Oe(t,i.firstColumn,0===e);})});},events:["resize"]}};function mi(t){for(var e=[[]],n=0;n<t.length;n++){var i=t[n],r=gi(i);if(r.height)for(var o=e.length-1;0<=o;o--){var s=e[o];if(!s[0]){s.push(i);break}var a=void 0;if(a=s[0].offsetParent===i.offsetParent?gi(s[0]):(r=gi(i,!0),gi(s[0],!0)),r.top>=a.bottom-1){e.push([i]);break}if(r.bottom>a.top){if(r.left<a.left&&!Zt){s.unshift(i);break}s.push(i);break}if(0===o){e.unshift([i]);break}}}return e}function gi(t,e){var n;void 0===e&&(e=!1);var i=t.offsetTop,r=t.offsetLeft,o=t.offsetHeight;return e&&(i=(n=gn(t))[0],r=n[1]),{top:i,left:r,height:o,bottom:i+o}}var vi={extends:pi,mixins:[ti],name:"grid",props:{masonry:Boolean,parallax:Number},data:{margin:"uk-grid-margin",clsStack:"uk-grid-stack",masonry:!1,parallax:0},computed:{length:function(t,e){return e.children.length},parallax:function(t){var e=t.parallax;return e&&this.length?Math.abs(e):""}},connected:function(){this.masonry&&Ae(this.$el,"uk-flex-top uk-flex-wrap-top");},update:[{read:function(t){var r=t.rows;(this.masonry||this.parallax)&&(r=r.map(function(t){return G(t,"offsetLeft")}),Zt&&r.map(function(t){return t.reverse()}));var e=r.some(function(t){return t.some(Ue.inProgress)}),n=!1,i="";if(this.masonry&&this.length){var o=0;n=r.reduce(function(n,t,i){return n[i]=t.map(function(t,e){return 0===i?0:j(n[i-1][e])+(o-j(r[i-1][e]&&r[i-1][e].offsetHeight))}),o=t.reduce(function(t,e){return Math.max(t,e.offsetHeight)},0),n},[]),i=function(t){return Math.max.apply(Math,t.reduce(function(n,t){return t.forEach(function(t,e){return n[e]=(n[e]||0)+t.offsetHeight}),n},[]))}(r)+function(t,e){var n=V(t.children),i=n.filter(function(t){return Me(t,e)})[0];return j(i?He(i,"marginTop"):He(n[0],"paddingLeft"))}(this.$el,this.margin)*(r.length-1);}return {rows:r,translates:n,height:!e&&i}},write:function(t){var e=t.stacks,n=t.height;Oe(this.$el,this.clsStack,e),He(this.$el,"paddingBottom",this.parallax),!1!==n&&He(this.$el,"height",n);},events:["resize"]},{read:function(t){var e=t.height;return {scrolled:!!this.parallax&&pn(this.$el,e?e-on(this.$el):0)*this.parallax}},write:function(t){var e=t.rows,i=t.scrolled,r=t.translates;!1===i&&!r||e.forEach(function(t,n){return t.forEach(function(t,e){return He(t,"transform",i||r?"translateY("+((r&&-r[n][e])+(i?e%2?i:i/8:0))+"px)":"")})});},events:["scroll","resize"]}]};var wi=Jt?{data:{selMinHeight:!1,forceHeight:!1},computed:{elements:function(t,e){var n=t.selMinHeight;return n?Te(n,e):[e]}},update:[{read:function(){He(this.elements,"height","");},order:-5,events:["resize"]},{write:function(){var n=this;this.elements.forEach(function(t){var e=j(He(t,"minHeight"));e&&(n.forceHeight||Math.round(e+hn("height",t,"content-box"))>=t.offsetHeight)&&He(t,"height",e);});},order:5,events:["resize"]}]}:{},bi={mixins:[wi],args:"target",props:{target:String,row:Boolean},data:{target:"> *",row:!0,forceHeight:!0},computed:{elements:function(t,e){return Te(t.target,e)}},update:{read:function(){return {rows:(this.row?mi(this.elements):[this.elements]).map(yi)}},write:function(t){t.rows.forEach(function(t){var n=t.heights;return t.elements.forEach(function(t,e){return He(t,"minHeight",n[e])})});},events:["resize"]}};function yi(t){var e;if(t.length<2)return {heights:[""],elements:t};var n=xi(t),i=n.heights,r=n.max,o=t.some(function(t){return t.style.minHeight}),s=t.some(function(t,e){return !t.style.minHeight&&i[e]<r});return o&&s&&(He(t,"minHeight",""),e=xi(t),i=e.heights,r=e.max),{heights:i=t.map(function(t,e){return i[e]===r&&j(t.style.minHeight).toFixed(2)!==r.toFixed(2)?"":r}),elements:t}}function xi(t){var e=t.map(function(t){return en(t).height-hn("height",t,"content-box")});return {heights:e,max:Math.max.apply(null,e)}}var ki={mixins:[wi],props:{expand:Boolean,offsetTop:Boolean,offsetBottom:Boolean,minHeight:Number},data:{expand:!1,offsetTop:!1,offsetBottom:!1,minHeight:0},update:{read:function(t){var e=t.minHeight,n="",i=hn("height",this.$el,"content-box");if(this.expand)n=on(window)-($i(document.documentElement)-$i(this.$el))-i||"";else{if(n="calc(100vh",this.offsetTop){var r=en(this.$el).top;n+=r<on(window)/2?" - "+r+"px":"";}!0===this.offsetBottom?n+=" - "+$i(this.$el.nextElementSibling)+"px":z(this.offsetBottom)?n+=" - "+this.offsetBottom+"vh":this.offsetBottom&&u(this.offsetBottom,"px")?n+=" - "+j(this.offsetBottom)+"px":D(this.offsetBottom)&&(n+=" - "+$i(at(this.offsetBottom,this.$el))+"px"),n+=(i?" - "+i+"px":"")+")";}return {minHeight:n,prev:e}},write:function(t){var e=t.minHeight,n=t.prev;He(this.$el,{minHeight:e}),e!==n&&this.$update(this.$el,"resize"),this.minHeight&&j(He(this.$el,"minHeight"))<this.minHeight&&He(this.$el,"minHeight",this.minHeight);},events:["resize"]}};function $i(t){return t&&t.offsetHeight||0}var Ii={args:"src",props:{id:Boolean,icon:String,src:String,style:String,width:Number,height:Number,ratio:Number,class:String,strokeAnimation:Boolean,attributes:"list"},data:{ratio:1,include:["style","class"],class:"",strokeAnimation:!1},beforeConnect:function(){var t,e=this;if(this.class+=" uk-svg",!this.icon&&y(this.src,"#")){var n=this.src.split("#");1<n.length&&(t=n,this.src=t[0],this.icon=t[1]);}this.svg=this.getSvg().then(function(t){return e.applyAttributes(t),e.svgEl=function(t,e){{if(Tt(e)||"CANVAS"===e.tagName){it(e,"hidden",!0);var n=e.nextElementSibling;return Ci(t,n)?n:me(e,t)}var i=e.lastElementChild;return Ci(t,i)?i:fe(e,t)}}(t,e.$el)},Q);},disconnected:function(){var e=this;Tt(this.$el)&&it(this.$el,"hidden",null),this.svg&&this.svg.then(function(t){return (!e._connected||t!==e.svgEl)&&ve(t)},Q),this.svg=this.svgEl=null;},update:{read:function(){return !!(this.strokeAnimation&&this.svgEl&&Et(this.svgEl))},write:function(){!function(t){var e=Ai(t);e&&t.style.setProperty("--uk-animation-stroke",e);}(this.svgEl);},type:["resize"]},methods:{getSvg:function(){var e=this;return function(n){if(Si[n])return Si[n];return Si[n]=new Yt(function(e,t){n?w(n,"data:")?e(decodeURIComponent(n.split(",")[1])):Kt(n).then(function(t){return e(t.response)},function(){return t("SVG not found.")}):t();})}(this.src).then(function(t){return function(t,e){e&&y(t,"<symbol")&&(t=function(t,e){if(!Ei[t]){var n;for(Ei[t]={};n=Ti.exec(t);)Ei[t][n[3]]='<svg xmlns="http://www.w3.org/2000/svg"'+n[1]+"svg>";Ti.lastIndex=0;}return Ei[t][e]}(t,e)||t);return (t=Se(t.substr(t.indexOf("<svg"))))&&t.hasChildNodes()&&t}(t,e.icon)||Yt.reject("SVG not found.")})},applyAttributes:function(n){var i=this;for(var t in this.$options.props)this[t]&&y(this.include,t)&&it(n,t,this[t]);for(var e in this.attributes){var r=this.attributes[e].split(":",2),o=r[0],s=r[1];it(n,o,s);}this.id||ot(n,"id");var a=["width","height"],h=[this.width,this.height];h.some(function(t){return t})||(h=a.map(function(t){return it(n,t)}));var c=it(n,"viewBox");c&&!h.some(function(t){return t})&&(h=c.split(" ").slice(2)),h.forEach(function(t,e){(t=(0|t)*i.ratio)&&it(n,a[e],t),t&&!h[1^e]&&ot(n,a[1^e]);}),it(n,"data-svg",this.icon||this.src);}}},Si={};var Ti=/<symbol(.*?id=(['"])(.*?)\2[^]*?<\/)symbol>/g,Ei={};function Ai(t){return Math.ceil(Math.max.apply(Math,Te("[stroke]",t).map(function(t){return t.getTotalLength&&t.getTotalLength()||0}).concat([0])))}function Ci(t,e){return it(t,"data-svg")===it(e,"data-svg")}var Ni={},_i={spinner:'<svg width="30" height="30" viewBox="0 0 30 30" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" cx="15" cy="15" r="14"/></svg>',totop:'<svg width="18" height="10" viewBox="0 0 18 10" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.2" points="1 9 9 1 17 9 "/></svg>',marker:'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect x="9" y="4" width="1" height="11"/><rect x="4" y="9" width="11" height="1"/></svg>',"close-icon":'<svg width="14" height="14" viewBox="0 0 14 14" xmlns="http://www.w3.org/2000/svg"><line fill="none" stroke="#000" stroke-width="1.1" x1="1" y1="1" x2="13" y2="13"/><line fill="none" stroke="#000" stroke-width="1.1" x1="13" y1="1" x2="1" y2="13"/></svg>',"close-large":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><line fill="none" stroke="#000" stroke-width="1.4" x1="1" y1="1" x2="19" y2="19"/><line fill="none" stroke="#000" stroke-width="1.4" x1="19" y1="1" x2="1" y2="19"/></svg>',"navbar-toggle-icon":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><rect y="9" width="20" height="2"/><rect y="3" width="20" height="2"/><rect y="15" width="20" height="2"/></svg>',"overlay-icon":'<svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg"><rect x="19" y="0" width="1" height="40"/><rect x="0" y="19" width="40" height="1"/></svg>',"pagination-next":'<svg width="7" height="12" viewBox="0 0 7 12" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.2" points="1 1 6 6 1 11"/></svg>',"pagination-previous":'<svg width="7" height="12" viewBox="0 0 7 12" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.2" points="6 1 1 6 6 11"/></svg>',"search-icon":'<svg width="20" height="20" viewBox="0 0 20 20" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="9" cy="9" r="7"/><path fill="none" stroke="#000" stroke-width="1.1" d="M14,14 L18,18 L14,14 Z"/></svg>',"search-large":'<svg width="40" height="40" viewBox="0 0 40 40" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.8" cx="17.5" cy="17.5" r="16.5"/><line fill="none" stroke="#000" stroke-width="1.8" x1="38" y1="39" x2="29" y2="30"/></svg>',"search-navbar":'<svg width="24" height="24" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg"><circle fill="none" stroke="#000" stroke-width="1.1" cx="10.5" cy="10.5" r="9.5"/><line fill="none" stroke="#000" stroke-width="1.1" x1="23" y1="23" x2="17" y2="17"/></svg>',"slidenav-next":'<svg width="14px" height="24px" viewBox="0 0 14 24" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.4" points="1.225,23 12.775,12 1.225,1 "/></svg>',"slidenav-next-large":'<svg width="25px" height="40px" viewBox="0 0 25 40" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="2" points="4.002,38.547 22.527,20.024 4,1.5 "/></svg>',"slidenav-previous":'<svg width="14px" height="24px" viewBox="0 0 14 24" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="1.4" points="12.775,1 1.225,12 12.775,23 "/></svg>',"slidenav-previous-large":'<svg width="25px" height="40px" viewBox="0 0 25 40" xmlns="http://www.w3.org/2000/svg"><polyline fill="none" stroke="#000" stroke-width="2" points="20.527,1.5 2,20.024 20.525,38.547 "/></svg>'},Mi={install:function(r){r.icon.add=function(t,e){var n,i=D(t)?((n={})[t]=e,n):t;K(i,function(t,e){_i[e]=t,delete Ni[e];}),r._initialized&&Ie(document.body,function(t){return K(r.getComponents(t),function(t){t.$options.isIcon&&t.icon in i&&t.$reset();})});};},extends:Ii,args:"icon",props:["icon"],data:{include:[]},isIcon:!0,beforeConnect:function(){Ae(this.$el,"uk-icon");},methods:{getSvg:function(){var t=function(t){if(!_i[t])return null;Ni[t]||(Ni[t]=Se(_i[t].trim()));return Ni[t].cloneNode(!0)}(function(t){return Zt?U(U(t,"left","right"),"previous","next"):t}(this.icon));return t?Yt.resolve(t):Yt.reject("Icon not found.")}}},Oi={args:!1,extends:Mi,data:function(t){return {icon:d(t.constructor.options.name)}},beforeConnect:function(){Ae(this.$el,this.$name);}},Di={extends:Oi,beforeConnect:function(){Ae(this.$el,"uk-slidenav");},computed:{icon:function(t,e){var n=t.icon;return Me(e,"uk-slidenav-large")?n+"-large":n}}},Bi={extends:Oi,computed:{icon:function(t,e){var n=t.icon;return Me(e,"uk-search-icon")&&kt(e,".uk-search-large").length?"search-large":kt(e,".uk-search-navbar").length?"search-navbar":n}}},zi={extends:Oi,computed:{icon:function(){return "close-"+(Me(this.$el,"uk-close-large")?"large":"icon")}}},Pi={extends:Oi,connected:function(){var e=this;this.svg.then(function(t){return 1!==e.ratio&&He(Se("circle",t),"strokeWidth",1/e.ratio)},Q);}};var Hi={args:"dataSrc",props:{dataSrc:String,dataSrcset:Boolean,sizes:String,width:Number,height:Number,offsetTop:String,offsetLeft:String,target:String},data:{dataSrc:"",dataSrcset:!1,sizes:!1,width:!1,height:!1,offsetTop:"50vh",offsetLeft:0,target:!1},computed:{cacheKey:function(t){var e=t.dataSrc;return this.$name+"."+e},width:function(t){var e=t.width,n=t.dataWidth;return e||n},height:function(t){var e=t.height,n=t.dataHeight;return e||n},sizes:function(t){var e=t.sizes,n=t.dataSizes;return e||n},isImg:function(t,e){return Ri(e)},target:{get:function(t){var e=t.target;return [this.$el].concat(ht(e,this.$el))},watch:function(){this.observe();}},offsetTop:function(t){return vn(t.offsetTop,"height")},offsetLeft:function(t){return vn(t.offsetLeft,"width")}},connected:function(){Ui[this.cacheKey]?Li(this.$el,Ui[this.cacheKey]||this.dataSrc,this.dataSrcset,this.sizes):this.isImg&&this.width&&this.height&&Li(this.$el,function(t,e,n){var i;n&&(i=nt.ratio({width:t,height:e},"width",vn(ji(n))),t=i.width,e=i.height);return 'data:image/svg+xml;utf8,<svg xmlns="http://www.w3.org/2000/svg" width="'+t+'" height="'+e+'"></svg>'}(this.width,this.height,this.sizes)),this.observer=new zn(this.load,{rootMargin:this.offsetTop+"px "+this.offsetLeft+"px"}),requestAnimationFrame(this.observe);},disconnected:function(){this.observer.disconnect();},update:{read:function(t){var e=this,n=t.image;if(n||"complete"!==document.readyState||this.load(this.observer.takeRecords()),this.isImg)return !1;n&&n.then(function(t){return t&&""!==t.currentSrc&&Li(e.$el,qi(t))});},write:function(t){if(this.dataSrcset&&1!==window.devicePixelRatio){var e=He(this.$el,"backgroundSize");!e.match(/^(auto\s?)+$/)&&j(e)!==t.bgSize||(t.bgSize=function(t,e){var n=vn(ji(e)),i=(t.match(Yi)||[]).map(j).sort(function(t,e){return t-e});return i.filter(function(t){return n<=t})[0]||i.pop()||""}(this.dataSrcset,this.sizes),He(this.$el,"backgroundSize",t.bgSize+"px"));}},events:["resize"]},methods:{load:function(t){var e=this;t.some(function(t){return t.isIntersecting})&&(this._data.image=Gt(this.dataSrc,this.dataSrcset,this.sizes).then(function(t){return Li(e.$el,qi(t),t.srcset,t.sizes),Ui[e.cacheKey]=qi(t),t},Q),this.observer.disconnect());},observe:function(){var e=this;!this._data.image&&this._connected&&this.target.forEach(function(t){return e.observer.observe(t)});}}};function Li(t,e,n,i){if(Ri(t))i&&(t.sizes=i),n&&(t.srcset=n),e&&(t.src=e);else if(e){!y(t.style.backgroundImage,e)&&(He(t,"backgroundImage","url("+It(e)+")"),Bt(t,zt("load",!1)));}}var Fi=/\s*(.*?)\s*(\w+|calc\(.*?\))\s*(?:,|$)/g;function ji(t){var e,n;for(Fi.lastIndex=0;e=Fi.exec(t);)if(!e[1]||window.matchMedia(e[1]).matches){e=w(n=e[2],"calc")?n.substring(5,n.length-1).replace(Wi,function(t){return vn(t)}).replace(/ /g,"").match(Vi).reduce(function(t,e){return t+ +e},0):n;break}return e||"100vw"}var Wi=/\d+(?:\w+|%)/g,Vi=/[+-]?(\d+)/g;var Yi=/\s+\d+w\s*(?:,|$)/g;function Ri(t){return "IMG"===t.tagName}function qi(t){return t.currentSrc||t.src}var Ui,Xi="__test__";try{(Ui=window.sessionStorage||{})[Xi]=1,delete Ui[Xi];}catch(t){Ui={};}var Ki={props:{media:Boolean},data:{media:!1},computed:{matchMedia:function(){var t=function(t){if(D(t)){if("@"===t[0])t=j(We("breakpoint-"+t.substr(1)));else if(isNaN(t))return t}return !(!t||isNaN(t))&&"(min-width: "+t+"px)"}(this.media);return !t||window.matchMedia(t).matches}}};var Gi,Ji,Zi={mixins:[ti,Ki],props:{fill:String},data:{fill:"",clsWrapper:"uk-leader-fill",clsHide:"uk-leader-hide",attrFill:"data-fill"},computed:{fill:function(t){return t.fill||We("leader-fill-content")}},connected:function(){var t;t=be(this.$el,'<span class="'+this.clsWrapper+'">'),this.wrapper=t[0];},disconnected:function(){ye(this.wrapper.childNodes);},update:{read:function(t){var e=t.changed,n=t.width,i=n;return {width:n=Math.floor(this.$el.offsetWidth/2),fill:this.fill,changed:e||i!==n,hide:!this.matchMedia}},write:function(t){Oe(this.wrapper,this.clsHide,t.hide),t.changed&&(t.changed=!1,it(this.wrapper,this.attrFill,new Array(t.width).join(t.fill)));},events:["resize"]}},Qi={props:{container:Boolean},data:{container:!0},computed:{container:function(t){var e=t.container;return !0===e&&this.$container||e&&Se(e)}}},tr={mixins:[ti,Qi,ei],props:{selPanel:String,selClose:String,escClose:Boolean,bgClose:Boolean,stack:Boolean},data:{cls:"uk-open",escClose:!0,bgClose:!0,overlay:!0,stack:!1},computed:{panel:function(t,e){return Se(t.selPanel,e)},transitionElement:function(){return this.panel},bgClose:function(t){return t.bgClose&&this.panel}},beforeDisconnect:function(){this.isToggled()&&this.toggleNow(this.$el,!1);},events:[{name:"click",delegate:function(){return this.selClose},handler:function(t){t.preventDefault(),this.hide();}},{name:"toggle",self:!0,handler:function(t){t.defaultPrevented||(t.preventDefault(),this.toggle());}},{name:"beforeshow",self:!0,handler:function(t){var n=Gi&&Gi!==this&&Gi;Gi=this,n?this.stack?this.prev=n:((Gi=n).isToggled()?n.hide().then(this.show):Dt(n.$el,"beforeshow hidden",this.show,!1,function(t){var e=t.target;return "hidden"===t.type&&e===n.$el}),t.preventDefault()):function(){if(Ji)return;Ji=[Mt(document,re,function(t){var e=t.target,n=t.defaultPrevented;!Gi||!Gi.bgClose||n||Gi.overlay&&!_t(e,Gi.$el)||_t(e,Gi.panel)||Gi.hide();}),Mt(document,"keydown",function(t){27===t.keyCode&&Gi&&Gi.escClose&&(t.preventDefault(),Gi.hide());})];}();}},{name:"show",self:!0,handler:function(){Me(document.documentElement,this.clsPage)||(this.scrollbarWidth=sn(window)-sn(document),He(document.body,"overflowY",this.scrollbarWidth&&this.overlay?"scroll":"")),Ae(document.documentElement,this.clsPage);}},{name:"hide",self:!0,handler:function(){Gi&&(Gi!==this||this.prev)||(Ji&&Ji.forEach(function(t){return t()}),Ji=null);}},{name:"hidden",self:!0,handler:function(){var t,e=this.prev;if(Gi=Gi&&Gi!==this&&Gi||e)for(;e;){if(e.clsPage===this.clsPage){t=!0;break}e=e.prev;}else He(document.body,"overflowY","");t||Ce(document.documentElement,this.clsPage);}}],methods:{toggle:function(){return this.isToggled()?this.hide():this.show()},show:function(){var e=this;return this.isToggled()?Yt.resolve():this.container&&this.$el.parentNode!==this.container?(fe(this.container,this.$el),new Yt(function(t){return requestAnimationFrame(function(){return e.show().then(t)})})):this.toggleElement(this.$el,!0,er(this))},hide:function(){return this.isToggled()?this.toggleElement(this.$el,!1,er(this)):Yt.resolve()},getActive:function(){return Gi}}};function er(t){var r=t.transitionElement,o=t._toggle;return function(n,i){return new Yt(function(t,e){return Dt(n,"show hide",function(){n._reject&&n._reject(),n._reject=e,o(n,i),R(He(r,"transitionDuration"))?Dt(r,"transitionend",t,!1,function(t){return t.target===r}):t();})})}}var nr={install:function(a){a.modal.dialog=function(t,e){var n=a.modal(' <div class="uk-modal"> <div class="uk-modal-dialog">'+t+"</div> </div> ",e);return n.show(),Mt(n.$el,"hidden",function(t){t.target===t.currentTarget&&Yt.resolve(function(){return n.$destroy(!0)});}),n},a.modal.alert=function(e,n){return n=X({bgClose:!1,escClose:!1,labels:a.modal.labels},n),new Yt(function(t){return Mt(a.modal.dialog(' <div class="uk-modal-body">'+(D(e)?e:de(e))+'</div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-primary uk-modal-close" autofocus>'+n.labels.ok+"</button> </div> ",n).$el,"hide",t)})},a.modal.confirm=function(r,o){return o=X({bgClose:!1,escClose:!0,labels:a.modal.labels},o),new Yt(function(e,t){var n=a.modal.dialog(' <form> <div class="uk-modal-body">'+(D(r)?r:de(r))+'</div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-default uk-modal-close" type="button">'+o.labels.cancel+'</button> <button class="uk-button uk-button-primary" autofocus>'+o.labels.ok+"</button> </div> </form> ",o),i=!1;Mt(n.$el,"submit","form",function(t){t.preventDefault(),e(),i=!0,n.hide();}),Mt(n.$el,"hide",function(){i||t();});})},a.modal.prompt=function(t,o,s){return s=X({bgClose:!1,escClose:!0,labels:a.modal.labels},s),new Yt(function(e){var n=a.modal.dialog(' <form class="uk-form-stacked"> <div class="uk-modal-body"> <label>'+(D(t)?t:de(t))+'</label> <input class="uk-input" autofocus> </div> <div class="uk-modal-footer uk-text-right"> <button class="uk-button uk-button-default uk-modal-close" type="button">'+s.labels.cancel+'</button> <button class="uk-button uk-button-primary">'+s.labels.ok+"</button> </div> </form> ",s),i=Se("input",n.$el);i.value=o;var r=!1;Mt(n.$el,"submit","form",function(t){t.preventDefault(),e(i.value),r=!0,n.hide();}),Mt(n.$el,"hide",function(){r||e(null);});})},a.modal.labels={ok:"Ok",cancel:"Cancel"};},mixins:[tr],data:{clsPage:"uk-modal-page",selPanel:".uk-modal-dialog",selClose:".uk-modal-close, .uk-modal-close-default, .uk-modal-close-outside, .uk-modal-close-full"},events:[{name:"show",self:!0,handler:function(){Me(this.panel,"uk-margin-auto-vertical")?Ae(this.$el,"uk-flex"):He(this.$el,"display","block"),on(this.$el);}},{name:"hidden",self:!0,handler:function(){He(this.$el,"display",""),Ce(this.$el,"uk-flex");}}]};var ir={extends:ni,data:{targets:"> .uk-parent",toggle:"> a",content:"> ul"}},rr={mixins:[ti,wi],props:{dropdown:String,mode:"list",align:String,offset:Number,boundary:Boolean,boundaryAlign:Boolean,clsDrop:String,delayShow:Number,delayHide:Number,dropbar:Boolean,dropbarMode:String,dropbarAnchor:Boolean,duration:Number},data:{dropdown:".uk-navbar-nav > li",align:Zt?"right":"left",clsDrop:"uk-navbar-dropdown",mode:void 0,offset:void 0,delayShow:void 0,delayHide:void 0,boundaryAlign:void 0,flip:"x",boundary:!0,dropbar:!1,dropbarMode:"slide",dropbarAnchor:!1,duration:200,forceHeight:!0,selMinHeight:".uk-navbar-nav > li > a, .uk-navbar-item, .uk-navbar-toggle"},computed:{boundary:function(t,e){var n=t.boundary,i=t.boundaryAlign;return !0===n||i?e:n},dropbarAnchor:function(t,e){return at(t.dropbarAnchor,e)},pos:function(t){return "bottom-"+t.align},dropdowns:function(t,e){return Te(t.dropdown+" ."+t.clsDrop,e)}},beforeConnect:function(){var t=this.$props.dropbar;this.dropbar=t&&(at(t,this.$el)||Se("+ .uk-navbar-dropbar",this.$el)||Se("<div></div>")),this.dropbar&&(Ae(this.dropbar,"uk-navbar-dropbar"),"slide"===this.dropbarMode&&Ae(this.dropbar,"uk-navbar-dropbar-slide"));},disconnected:function(){this.dropbar&&ve(this.dropbar);},update:function(){var e=this;this.$create("drop",this.dropdowns.filter(function(t){return !e.getDropdown(t)}),X({},this.$props,{boundary:this.boundary,pos:this.pos,offset:this.dropbar||this.offset}));},events:[{name:"mouseover",delegate:function(){return this.dropdown},handler:function(t){var e=t.current,n=this.getActive();n&&n.toggle&&!_t(n.toggle.$el,e)&&!n.tracker.movesTo(n.$el)&&n.hide(!1);}},{name:"mouseleave",el:function(){return this.dropbar},handler:function(){var t=this.getActive();t&&!this.dropdowns.some(function(t){return bt(t,":hover")})&&t.hide();}},{name:"beforeshow",capture:!0,filter:function(){return this.dropbar},handler:function(){this.dropbar.parentNode||me(this.dropbarAnchor||this.$el,this.dropbar);}},{name:"show",capture:!0,filter:function(){return this.dropbar},handler:function(t,e){var n=e.$el,i=e.dir;this.clsDrop&&Ae(n,this.clsDrop+"-dropbar"),"bottom"===i&&this.transitionTo(n.offsetHeight+j(He(n,"marginTop"))+j(He(n,"marginBottom")),n);}},{name:"beforehide",filter:function(){return this.dropbar},handler:function(t,e){var n=e.$el,i=this.getActive();bt(this.dropbar,":hover")&&i&&i.$el===n&&t.preventDefault();}},{name:"hide",filter:function(){return this.dropbar},handler:function(t,e){var n=e.$el,i=this.getActive();(!i||i&&i.$el===n)&&this.transitionTo(0);}}],methods:{getActive:function(){var t=this.dropdowns.map(this.getDropdown).filter(function(t){return t&&t.isActive()})[0];return t&&y(t.mode,"hover")&&_t(t.toggle.$el,this.$el)&&t},transitionTo:function(t,e){var n=this,i=this.dropbar,r=Et(i)?on(i):0;return He(e=r<t&&e,"clip","rect(0,"+e.offsetWidth+"px,"+r+"px,0)"),on(i,r),Ue.cancel([e,i]),Yt.all([Ue.start(i,{height:t},this.duration),Ue.start(e,{clip:"rect(0,"+e.offsetWidth+"px,"+t+"px,0)"},this.duration)]).catch(Q).then(function(){He(e,{clip:""}),n.$update(i);})},getDropdown:function(t){return this.$getComponent(t,"drop")||this.$getComponent(t,"dropdown")}}},or={mixins:[tr],args:"mode",props:{mode:String,flip:Boolean,overlay:Boolean},data:{mode:"slide",flip:!1,overlay:!1,clsPage:"uk-offcanvas-page",clsContainer:"uk-offcanvas-container",selPanel:".uk-offcanvas-bar",clsFlip:"uk-offcanvas-flip",clsContainerAnimation:"uk-offcanvas-container-animation",clsSidebarAnimation:"uk-offcanvas-bar-animation",clsMode:"uk-offcanvas",clsOverlay:"uk-offcanvas-overlay",selClose:".uk-offcanvas-close"},computed:{clsFlip:function(t){var e=t.flip,n=t.clsFlip;return e?n:""},clsOverlay:function(t){var e=t.overlay,n=t.clsOverlay;return e?n:""},clsMode:function(t){var e=t.mode;return t.clsMode+"-"+e},clsSidebarAnimation:function(t){var e=t.mode,n=t.clsSidebarAnimation;return "none"===e||"reveal"===e?"":n},clsContainerAnimation:function(t){var e=t.mode,n=t.clsContainerAnimation;return "push"!==e&&"reveal"!==e?"":n},transitionElement:function(t){return "reveal"===t.mode?this.panel.parentNode:this.panel}},events:[{name:"click",delegate:function(){return 'a[href^="#"]'},handler:function(t){var e=t.current;e.hash&&Se(e.hash,document.body)&&this.hide();}},{name:"touchstart",passive:!0,el:function(){return this.panel},handler:function(t){var e=t.targetTouches;1===e.length&&(this.clientY=e[0].clientY);}},{name:"touchmove",self:!0,passive:!1,filter:function(){return this.overlay},handler:function(t){t.cancelable&&t.preventDefault();}},{name:"touchmove",passive:!1,el:function(){return this.panel},handler:function(t){if(1===t.targetTouches.length){var e=event.targetTouches[0].clientY-this.clientY,n=this.panel,i=n.scrollTop,r=n.scrollHeight,o=n.clientHeight;(r<=o||0===i&&0<e||r-i<=o&&e<0)&&t.cancelable&&t.preventDefault();}}},{name:"show",self:!0,handler:function(){"reveal"!==this.mode||Me(this.panel.parentNode,this.clsMode)||(we(this.panel,"<div>"),Ae(this.panel.parentNode,this.clsMode)),He(document.documentElement,"overflowY",this.overlay?"hidden":""),Ae(document.body,this.clsContainer,this.clsFlip),He(this.$el,"display","block"),Ae(this.$el,this.clsOverlay),Ae(this.panel,this.clsSidebarAnimation,"reveal"!==this.mode?this.clsMode:""),on(document.body),Ae(document.body,this.clsContainerAnimation),this.clsContainerAnimation&&(sr().content+=",user-scalable=0");}},{name:"hide",self:!0,handler:function(){Ce(document.body,this.clsContainerAnimation);var t=this.getActive();("none"===this.mode||t&&t!==this&&t!==this.prev)&&Bt(this.panel,"transitionend");}},{name:"hidden",self:!0,handler:function(){this.clsContainerAnimation&&function(){var t=sr();t.content=t.content.replace(/,user-scalable=0$/,"");}(),"reveal"===this.mode&&ye(this.panel),Ce(this.panel,this.clsSidebarAnimation,this.clsMode),Ce(this.$el,this.clsOverlay),He(this.$el,"display",""),Ce(document.body,this.clsContainer,this.clsFlip),He(document.documentElement,"overflowY","");}},{name:"swipeLeft swipeRight",handler:function(t){this.isToggled()&&u(t.type,"Left")^this.flip&&this.hide();}}]};function sr(){return Se('meta[name="viewport"]',document.head)||fe(document.head,'<meta name="viewport">')}var ar={mixins:[ti],props:{selContainer:String,selContent:String},data:{selContainer:".uk-modal",selContent:".uk-modal-dialog"},computed:{container:function(t,e){return xt(e,t.selContainer)},content:function(t,e){return xt(e,t.selContent)}},connected:function(){He(this.$el,"minHeight",150);},update:{read:function(){return !(!this.content||!this.container)&&{current:j(He(this.$el,"maxHeight")),max:Math.max(150,on(this.container)-(en(this.content).height-on(this.$el)))}},write:function(t){var e=t.current,n=t.max;He(this.$el,"maxHeight",n),Math.round(e)!==Math.round(n)&&Bt(this.$el,"resize");},events:["resize"]}},hr={props:["width","height"],connected:function(){Ae(this.$el,"uk-responsive-width");},update:{read:function(){return !!(Et(this.$el)&&this.width&&this.height)&&{width:sn(this.$el.parentNode),height:this.height}},write:function(t){on(this.$el,nt.contain({height:this.height,width:this.width},t).height);},events:["resize"]}},cr={props:{duration:Number,offset:Number},data:{duration:1e3,offset:0},methods:{scrollTo:function(e){var n=this;e=e&&Se(e)||document.body;var t=on(document),i=on(window),r=en(e).top-this.offset;if(t<r+i&&(r=t-i),Bt(this.$el,"beforescroll",[this,e])){var o=Date.now(),s=window.pageYOffset,a=function(){var t=s+(r-s)*function(t){return .5*(1-Math.cos(Math.PI*t))}(Z((Date.now()-o)/n.duration));mn(window,t),t!==r?requestAnimationFrame(a):Bt(n.$el,"scrolled",[n,e]);};a();}}},events:{click:function(t){t.defaultPrevented||(t.preventDefault(),this.scrollTo(It(decodeURIComponent(this.$el.hash)).substr(1)));}}};var ur={args:"cls",props:{cls:String,target:String,hidden:Boolean,offsetTop:Number,offsetLeft:Number,repeat:Boolean,delay:Number},data:function(){return {cls:!1,target:!1,hidden:!0,offsetTop:0,offsetLeft:0,repeat:!1,delay:0,inViewClass:"uk-scrollspy-inview"}},computed:{elements:function(t,e){var n=t.target;return n?Te(n,e):[e]}},update:[{write:function(){this.hidden&&He(Nt(this.elements,":not(."+this.inViewClass+")"),"visibility","hidden");}},{read:function(t){var n=this;t.update&&this.elements.forEach(function(t){var e=t._ukScrollspyState;(e=e||{cls:st(t,"uk-scrollspy-class")||n.cls}).show=fn(t,n.offsetTop,n.offsetLeft),t._ukScrollspyState=e;});},write:function(r){var o=this;if(!r.update)return this.$emit(),r.update=!0;this.elements.forEach(function(t){var n=t._ukScrollspyState,e=n.cls;if(!n.show||n.inview||n.queued){if(!n.show&&(n.inview||n.queued)&&o.repeat){if(n.abort&&n.abort(),!n.inview)return;He(t,"visibility",o.hidden?"hidden":""),Ce(t,o.inViewClass),Oe(t,e),Bt(t,"outview"),o.$update(t),n.inview=!1;}}else{var i=function(){He(t,"visibility",""),Ae(t,o.inViewClass),Oe(t,e),Bt(t,"inview"),o.$update(t),n.inview=!0,n.abort&&n.abort();};o.delay?(n.queued=!0,r.promise=(r.promise||Yt.resolve()).then(function(){return !n.inview&&new Yt(function(t){var e=setTimeout(function(){i(),t();},r.promise||1===o.elements.length?o.delay:0);n.abort=function(){clearTimeout(e),t(),n.queued=!1;};})})):i();}});},events:["scroll","resize"]}]},lr={props:{cls:String,closest:String,scroll:Boolean,overflow:Boolean,offset:Number},data:{cls:"uk-active",closest:!1,scroll:!1,overflow:!0,offset:0},computed:{links:function(t,e){return Te('a[href^="#"]',e).filter(function(t){return t.hash})},elements:function(t){var e=t.closest;return xt(this.links,e||"*")},targets:function(){return Te(this.links.map(function(t){return It(t.hash).substr(1)}).join(","))}},update:[{read:function(){this.scroll&&this.$create("scroll",this.links,{offset:this.offset||0});}},{read:function(o){var s=this,a=window.pageYOffset+this.offset+1,h=on(document)-on(window)+this.offset;o.active=!1,this.targets.every(function(t,e){var n=en(t).top,i=e+1===s.targets.length;if(!s.overflow&&(0===e&&a<n||i&&n+t.offsetTop<a))return !1;if(!i&&en(s.targets[e+1]).top<=a)return !0;if(h<=a)for(var r=s.targets.length-1;e<r;r--)if(fn(s.targets[r])){t=s.targets[r];break}return !(o.active=Se(Nt(s.links,'[href="#'+t.id+'"]')))});},write:function(t){var e=t.active;this.links.forEach(function(t){return t.blur()}),Ce(this.elements,this.cls),e&&Bt(this.$el,"active",[e,Ae(this.closest?xt(e,this.closest):e,this.cls)]);},events:["scroll","resize"]}]},dr={mixins:[ti,Ki],props:{top:null,bottom:Boolean,offset:Number,animation:String,clsActive:String,clsInactive:String,clsFixed:String,clsBelow:String,selTarget:String,widthElement:Boolean,showOnUp:Boolean,targetOffset:Number},data:{top:0,bottom:!1,offset:0,animation:"",clsActive:"uk-active",clsInactive:"",clsFixed:"uk-sticky-fixed",clsBelow:"uk-sticky-below",selTarget:"",widthElement:!1,showOnUp:!1,targetOffset:!1},computed:{selTarget:function(t,e){var n=t.selTarget;return n&&Se(n,e)||e},widthElement:function(t,e){return at(t.widthElement,e)||this.placeholder},isActive:{get:function(){return Me(this.selTarget,this.clsActive)},set:function(t){t&&!this.isActive?(_e(this.selTarget,this.clsInactive,this.clsActive),Bt(this.$el,"active")):t||Me(this.selTarget,this.clsInactive)||(_e(this.selTarget,this.clsActive,this.clsInactive),Bt(this.$el,"inactive"));}}},connected:function(){this.placeholder=Se("+ .uk-sticky-placeholder",this.$el)||Se('<div class="uk-sticky-placeholder"></div>'),this.isFixed=!1,this.isActive=!1;},disconnected:function(){this.isFixed&&(this.hide(),Ce(this.selTarget,this.clsInactive)),ve(this.placeholder),this.placeholder=null,this.widthElement=null;},events:[{name:"load hashchange popstate",el:window,handler:function(){var i=this;if(!1!==this.targetOffset&&location.hash&&0<window.pageYOffset){var r=Se(location.hash);r&&xn.read(function(){var t=en(r).top,e=en(i.$el).top,n=i.$el.offsetHeight;i.isFixed&&t<=e+n&&e<=t+r.offsetHeight&&mn(window,t-n-(z(i.targetOffset)?i.targetOffset:0)-i.offset);});}}}],update:[{read:function(t,e){var n=t.height;this.isActive&&"update"!==e&&(this.hide(),n=this.$el.offsetHeight,this.show()),n=this.isActive?n:this.$el.offsetHeight,this.topOffset=en(this.isFixed?this.placeholder:this.$el).top,this.bottomOffset=this.topOffset+n;var i=fr("bottom",this);return this.top=Math.max(j(fr("top",this)),this.topOffset)-this.offset,this.bottom=i&&i-n,this.inactive=!this.matchMedia,{lastScroll:!1,height:n,margins:He(this.$el,["marginTop","marginBottom","marginLeft","marginRight"])}},write:function(t){var e=t.height,n=t.margins,i=this.placeholder;He(i,X({height:e},n)),_t(i,document)||(me(this.$el,i),it(i,"hidden","")),this.isActive=this.isActive;},events:["resize"]},{read:function(t){var e=t.scroll;return void 0===e&&(e=0),this.width=(Et(this.widthElement)?this.widthElement:this.$el).offsetWidth,this.scroll=window.pageYOffset,{dir:e<=this.scroll?"down":"up",scroll:this.scroll,visible:Et(this.$el),top:gn(this.placeholder)[0]}},write:function(t,e){var n=this,i=t.initTimestamp;void 0===i&&(i=0);var r=t.dir,o=t.lastDir,s=t.lastScroll,a=t.scroll,h=t.top,c=t.visible,u=performance.now();if(!((t.lastScroll=a)<0||a===s||!c||this.disabled||this.showOnUp&&"scroll"!==e||((300<u-i||r!==o)&&(t.initScroll=a,t.initTimestamp=u),t.lastDir=r,this.showOnUp&&Math.abs(t.initScroll-a)<=30&&Math.abs(s-a)<=10)))if(this.inactive||a<this.top||this.showOnUp&&(a<=this.top||"down"===r||"up"===r&&!this.isFixed&&a<=this.bottomOffset)){if(!this.isFixed)return void(Ze.inProgress(this.$el)&&a<h&&(Ze.cancel(this.$el),this.hide()));this.isFixed=!1,this.animation&&a>this.topOffset?(Ze.cancel(this.$el),Ze.out(this.$el,this.animation).then(function(){return n.hide()},Q)):this.hide();}else this.isFixed?this.update():this.animation?(Ze.cancel(this.$el),this.show(),Ze.in(this.$el,this.animation).catch(Q)):this.show();},events:["resize","scroll"]}],methods:{show:function(){this.isFixed=!0,this.update(),it(this.placeholder,"hidden",null);},hide:function(){this.isActive=!1,Ce(this.$el,this.clsFixed,this.clsBelow),He(this.$el,{position:"",top:"",width:""}),it(this.placeholder,"hidden","");},update:function(){var t=0!==this.top||this.scroll>this.top,e=Math.max(0,this.offset);this.bottom&&this.scroll>this.bottom-this.offset&&(e=this.bottom-this.scroll),He(this.$el,{position:"fixed",top:e+"px",width:this.width}),this.isActive=t,Oe(this.$el,this.clsBelow,this.scroll>this.bottomOffset),Ae(this.$el,this.clsFixed);}}};function fr(t,e){var n=e.$props,i=e.$el,r=e[t+"Offset"],o=n[t];if(o){if(z(o))return r+j(o);if(D(o)&&o.match(/^-?\d+vh$/))return on(window)*j(o)/100;var s=!0===o?i.parentNode:at(o,i);return s?en(s).top+s.offsetHeight:void 0}}var pr,mr={mixins:[ei],args:"connect",props:{connect:String,toggle:String,active:Number,swiping:Boolean},data:{connect:"~.uk-switcher",toggle:"> * > :first-child",active:0,swiping:!0,cls:"uk-active",clsContainer:"uk-switcher",attrItem:"uk-switcher-item",queued:!0},computed:{connects:function(t,e){return ht(t.connect,e)},toggles:function(t,e){return Te(t.toggle,e)}},events:[{name:"click",delegate:function(){return this.toggle+":not(.uk-disabled)"},handler:function(e){e.preventDefault(),this.show(V(this.$el.children).filter(function(t){return _t(e.current,t)})[0]);}},{name:"click",el:function(){return this.connects},delegate:function(){return "["+this.attrItem+"],[data-"+this.attrItem+"]"},handler:function(t){t.preventDefault(),this.show(st(t.current,this.attrItem));}},{name:"swipeRight swipeLeft",filter:function(){return this.swiping},el:function(){return this.connects},handler:function(t){var e=t.type;this.show(u(e,"Left")?"next":"previous");}}],update:function(){var e=this;this.connects.forEach(function(t){return e.updateAria(t.children)});var t=this.$el.children;this.show(Nt(t,"."+this.cls)[0]||t[this.active]||t[0]);},methods:{index:function(){return !P(this.connects)&&ce(Nt(this.connects[0].children,"."+this.cls)[0])},show:function(t){for(var e,n,i=this,r=this.$el.children,o=r.length,s=this.index(),a=0<=s,h="previous"===t?-1:1,c=ue(t,r,s),u=0;u<o;u++,c=(c+h+o)%o)if(!bt(this.toggles[c],".uk-disabled *, .uk-disabled, [disabled]")){e=this.toggles[c],n=r[c];break}!n||0<=s&&Me(n,this.cls)||s===c||(Ce(r,this.cls),Ae(n,this.cls),it(this.toggles,"aria-expanded",!1),it(e,"aria-expanded",!0),this.connects.forEach(function(t){a?i.toggleElement([t.children[s],t.children[c]]):i.toggleNow(t.children[c]);}));}}},gr={mixins:[ti],extends:mr,props:{media:Boolean},data:{media:960,attrItem:"uk-tab-item"},connected:function(){var t=Me(this.$el,"uk-tab-left")?"uk-tab-left":!!Me(this.$el,"uk-tab-right")&&"uk-tab-right";t&&this.$create("toggle",this.$el,{cls:t,mode:"media",media:this.media});}},vr={mixins:[Ki,ei],args:"target",props:{href:String,target:null,mode:"list"},data:{href:!1,target:!1,mode:"click",queued:!0},computed:{target:function(t,e){var n=t.href,i=t.target;return (i=ht(i||n,e)).length&&i||[e]}},connected:function(){Bt(this.target,"updatearia",[this]);},events:[{name:oe+" "+se,filter:function(){return y(this.mode,"hover")},handler:function(t){jt(t)||this.toggle("toggle"+(t.type===oe?"show":"hide"));}},{name:"click",filter:function(){return y(this.mode,"click")||ee&&y(this.mode,"hover")},handler:function(t){var e;(xt(t.target,'a[href="#"], a[href=""]')||(e=xt(t.target,"a[href]"))&&(this.cls||!Et(this.target)||e.hash&&bt(this.target,e.hash)))&&t.preventDefault(),this.toggle();}}],update:{read:function(){return !(!y(this.mode,"media")||!this.media)&&{match:this.matchMedia}},write:function(t){var e=t.match,n=this.isToggled(this.target);(e?!n:n)&&this.toggle();},events:["resize"]},methods:{toggle:function(t){Bt(this.target,t||"toggle",[this])&&this.toggleElement(this.target);}}};Hn.version="3.1.6",(pr=Hn).component("accordion",ni),pr.component("alert",ii),pr.component("cover",hi),pr.component("drop",ui),pr.component("dropdown",li),pr.component("formCustom",di),pr.component("gif",fi),pr.component("grid",vi),pr.component("heightMatch",bi),pr.component("heightViewport",ki),pr.component("icon",Mi),pr.component("img",Hi),pr.component("leader",Zi),pr.component("margin",pi),pr.component("modal",nr),pr.component("nav",ir),pr.component("navbar",rr),pr.component("offcanvas",or),pr.component("overflowAuto",ar),pr.component("responsive",hr),pr.component("scroll",cr),pr.component("scrollspy",ur),pr.component("scrollspyNav",lr),pr.component("sticky",dr),pr.component("svg",Ii),pr.component("switcher",mr),pr.component("tab",gr),pr.component("toggle",vr),pr.component("video",ai),pr.component("close",zi),pr.component("marker",Oi),pr.component("navbarToggleIcon",Oi),pr.component("overlayIcon",Oi),pr.component("paginationNext",Oi),pr.component("paginationPrevious",Oi),pr.component("searchIcon",Bi),pr.component("slidenavNext",Di),pr.component("slidenavPrevious",Di),pr.component("spinner",Pi),pr.component("totop",Oi),pr.use(ri);var wr={mixins:[ti],props:{date:String,clsWrapper:String},data:{date:"",clsWrapper:".uk-countdown-%unit%"},computed:{date:function(t){var e=t.date;return Date.parse(e)},days:function(t,e){return Se(t.clsWrapper.replace("%unit%","days"),e)},hours:function(t,e){return Se(t.clsWrapper.replace("%unit%","hours"),e)},minutes:function(t,e){return Se(t.clsWrapper.replace("%unit%","minutes"),e)},seconds:function(t,e){return Se(t.clsWrapper.replace("%unit%","seconds"),e)},units:function(){var e=this;return ["days","hours","minutes","seconds"].filter(function(t){return e[t]})}},connected:function(){this.start();},disconnected:function(){var e=this;this.stop(),this.units.forEach(function(t){return le(e[t])});},events:[{name:"visibilitychange",el:document,handler:function(){document.hidden?this.stop():this.start();}}],update:{write:function(){var i=this,r=function(t){var e=t-Date.now();return {total:e,seconds:e/1e3%60,minutes:e/1e3/60%60,hours:e/1e3/60/60%24,days:e/1e3/60/60/24}}(this.date);r.total<=0&&(this.stop(),r.days=r.hours=r.minutes=r.seconds=0),this.units.forEach(function(t){var e=String(Math.floor(r[t]));e=e.length<2?"0"+e:e;var n=i[t];n.textContent!==e&&((e=e.split("")).length!==n.children.length&&de(n,e.map(function(){return "<span></span>"}).join("")),e.forEach(function(t,e){return n.children[e].textContent=t}));});}},methods:{start:function(){var t=this;this.stop(),this.date&&this.units.length&&(this.$emit(),this.timer=setInterval(function(){return t.$emit()},1e3));},stop:function(){this.timer&&(clearInterval(this.timer),this.timer=null);}}};var br,yr="uk-animation-target",xr={props:{animation:Number},data:{animation:150},computed:{target:function(){return this.$el}},methods:{animate:function(t){var i=this;!function(){if(br)return;(br=fe(document.head,"<style>").sheet).insertRule("."+yr+" > * {\n margin-top: 0 !important;\n transform: none !important;\n }",0);}();var r=V(this.target.children),o=r.map(function(t){return kr(t,!0)}),e=on(this.target),n=window.pageYOffset;t(),Ue.cancel(this.target),r.forEach(Ue.cancel),$r(this.target),this.$update(this.target),xn.flush();var s=on(this.target),a=(r=r.concat(V(this.target.children).filter(function(t){return !y(r,t)}))).map(function(t,e){return !!(t.parentNode&&e in o)&&(o[e]?Et(t)?Ir(t):{opacity:0}:{opacity:Et(t)?1:0})});return o=a.map(function(t,e){var n=r[e].parentNode===i.target&&(o[e]||kr(r[e]));if(n)if(t){if(!("opacity"in t)){n.opacity%1?t.opacity=1:delete n.opacity;}}else delete n.opacity;return n}),Ae(this.target,yr),r.forEach(function(t,e){return o[e]&&He(t,o[e])}),He(this.target,"height",e),mn(window,n),Yt.all(r.map(function(t,e){return o[e]&&a[e]?Ue.start(t,a[e],i.animation,"ease"):Yt.resolve()}).concat(Ue.start(this.target,{height:s},this.animation,"ease"))).then(function(){r.forEach(function(t,e){return He(t,{display:0===a[e].opacity?"none":"",zIndex:""})}),$r(i.target),i.$update(i.target),xn.flush();},Q)}}};function kr(t,e){var n=He(t,"zIndex");return !!Et(t)&&X({display:"",opacity:e?He(t,"opacity"):"0",pointerEvents:"none",position:"absolute",zIndex:"auto"===n?ce(t):n},Ir(t))}function $r(t){He(t.children,{height:"",left:"",opacity:"",pointerEvents:"",position:"",top:"",width:""}),Ce(t,yr),He(t,"height","");}function Ir(t){var e=t.getBoundingClientRect(),n=e.height,i=e.width,r=rn(t),o=r.top,s=r.left;return {top:o+=j(He(t,"marginTop")),left:s,height:n,width:i}}var Sr={mixins:[xr],args:"target",props:{target:Boolean,selActive:Boolean},data:{target:null,selActive:!1,attrItem:"uk-filter-control",cls:"uk-active",animation:250},computed:{toggles:{get:function(t,e){t.attrItem;return Te("["+this.attrItem+"],[data-"+this.attrItem+"]",e)},watch:function(){this.updateState();}},target:function(t,e){return Se(t.target,e)},children:{get:function(){return V(this.target&&this.target.children)},watch:function(t,e){!function(t,e){return t.length===e.length&&t.every(function(t){return ~e.indexOf(t)})}(t,e)&&this.updateState();}}},events:[{name:"click",delegate:function(){return "["+this.attrItem+"],[data-"+this.attrItem+"]"},handler:function(t){t.preventDefault(),this.apply(t.current);}}],connected:function(){var e=this;if(this.updateState(),!1!==this.selActive){var n=Te(this.selActive,this.$el);this.toggles.forEach(function(t){return Oe(t,e.cls,y(n,t))});}},methods:{apply:function(t){this.setState(Er(t,this.attrItem,this.getState()));},getState:function(){var n=this;return this.toggles.filter(function(t){return Me(t,n.cls)}).reduce(function(t,e){return Er(e,n.attrItem,t)},{filter:{"":""},sort:[]})},setState:function(o,t){var s=this;void 0===t&&(t=!0),o=X({filter:{"":""},sort:[]},o),Bt(this.$el,"beforeFilter",[this,o]);var a=this.children;this.toggles.forEach(function(t){return Oe(t,s.cls,!!function(t,e,n){var i=n.filter;void 0===i&&(i={"":""});var r=n.sort,o=r[0],s=r[1],a=Tr(t,e),h=a.filter;void 0===h&&(h="");var c=a.group;void 0===c&&(c="");var u=a.sort,l=a.order;void 0===l&&(l="asc");return H(u)?c in i&&h===i[c]||!h&&c&&!(c in i)&&!i[""]:o===u&&s===l}(t,s.attrItem,o))});function e(){var e=function(t){var e=t.filter,n="";return K(e,function(t){return n+=t||""}),n}(o);a.forEach(function(t){return He(t,"display",e&&!bt(t,e)?"none":"")});var t=o.sort,n=t[0],i=t[1];if(n){var r=function(t,n,i){return X([],t).sort(function(t,e){return st(t,n).localeCompare(st(e,n),void 0,{numeric:!0})*("asc"===i||-1)})}(a,n,i);q(r,a)||r.forEach(function(t){return fe(s.target,t)});}}t?this.animate(e).then(function(){return Bt(s.$el,"afterFilter",[s])}):(e(),Bt(this.$el,"afterFilter",[this]));},updateState:function(){var t=this;xn.write(function(){return t.setState(t.getState(),!1)});}}};function Tr(t,e){return Mn(st(t,e),["filter"])}function Er(t,e,n){var i=Tr(t,e),r=i.filter,o=i.group,s=i.sort,a=i.order;return void 0===a&&(a="asc"),(r||H(s))&&(o?r?(delete n.filter[""],n.filter[o]=r):(delete n.filter[o],(P(n.filter)||""in n.filter)&&(n.filter={"":r||""})):n.filter={"":r||""}),H(s)||(n.sort=[s,a]),n}var Ar={slide:{show:function(t){return [{transform:Nr(-100*t)},{transform:Nr()}]},percent:function(t){return Cr(t)},translate:function(t,e){return [{transform:Nr(-100*e*t)},{transform:Nr(100*e*(1-t))}]}}};function Cr(t){return Math.abs(He(t,"transform").split(",")[4]/t.offsetWidth)||0}function Nr(t,e){return void 0===t&&(t=0),void 0===e&&(e="%"),t+=t?e:"",Jt?"translateX("+t+")":"translate3d("+t+", 0, 0)"}function _r(t){return "scale3d("+t+", "+t+", 1)"}var Mr=X({},Ar,{fade:{show:function(){return [{opacity:0},{opacity:1}]},percent:function(t){return 1-He(t,"opacity")},translate:function(t){return [{opacity:1-t},{opacity:t}]}},scale:{show:function(){return [{opacity:0,transform:_r(.8)},{opacity:1,transform:_r(1)}]},percent:function(t){return 1-He(t,"opacity")},translate:function(t){return [{opacity:1-t,transform:_r(1-.2*t)},{opacity:t,transform:_r(.8+.2*t)}]}}});function Or(t,e,n){Bt(t,zt(e,!1,!1,n));}var Dr={mixins:[{props:{autoplay:Boolean,autoplayInterval:Number,pauseOnHover:Boolean},data:{autoplay:!1,autoplayInterval:7e3,pauseOnHover:!0},connected:function(){this.autoplay&&this.startAutoplay();},disconnected:function(){this.stopAutoplay();},update:function(){it(this.slides,"tabindex","-1");},events:[{name:"visibilitychange",el:document,filter:function(){return this.autoplay},handler:function(){document.hidden?this.stopAutoplay():this.startAutoplay();}},{name:"mouseenter",filter:function(){return this.autoplay&&this.pauseOnHover},handler:function(){this.isHovering=!0;}},{name:"mouseleave",filter:function(){return this.autoplay&&this.pauseOnHover},handler:function(){this.isHovering=!1;}}],methods:{startAutoplay:function(){var t=this;this.stopAutoplay(),this.interval=setInterval(function(){return !_t(document.activeElement,t.$el)&&!t.isHovering&&!t.stack.length&&t.show("next")},this.autoplayInterval);},stopAutoplay:function(){this.interval&&clearInterval(this.interval);}}},{props:{draggable:Boolean},data:{draggable:!0,threshold:10},created:function(){var i=this;["start","move","end"].forEach(function(t){var n=i[t];i[t]=function(t){var e=Wt(t).x*(Zt?-1:1);i.prevPos=e!==i.pos?i.pos:i.prevPos,i.pos=e,n(t);};});},events:[{name:ne,delegate:function(){return this.selSlides},handler:function(t){!this.draggable||!jt(t)&&function(t){return !t.children.length&&t.childNodes.length}(t.target)||0<t.button||this.length<2||this.start(t);}},{name:"touchmove",passive:!1,handler:"move",delegate:function(){return this.selSlides}},{name:"dragstart",handler:function(t){t.preventDefault();}}],methods:{start:function(){var t=this;this.drag=this.pos,this._transitioner?(this.percent=this._transitioner.percent(),this.drag+=this._transitioner.getDistance()*this.percent*this.dir,this._transitioner.cancel(),this._transitioner.translate(this.percent),this.dragging=!0,this.stack=[]):this.prevIndex=this.index;var e="touchmove"!=ie?Mt(document,ie,this.move,{passive:!1}):Q;this.unbindMove=function(){e(),t.unbindMove=null;},Mt(window,"scroll",this.unbindMove),Mt(document,re,this.end,!0),He(this.list,"userSelect","none");},move:function(t){var e=this;if(this.unbindMove){var n=this.pos-this.drag;if(!(0==n||this.prevPos===this.pos||!this.dragging&&Math.abs(n)<this.threshold)){He(this.list,"pointerEvents","none"),t.cancelable&&t.preventDefault(),this.dragging=!0,this.dir=n<0?1:-1;for(var i=this.slides,r=this.prevIndex,o=Math.abs(n),s=this.getIndex(r+this.dir,r),a=this._getDistance(r,s)||i[r].offsetWidth;s!==r&&a<o;)this.drag-=a*this.dir,r=s,o-=a,s=this.getIndex(r+this.dir,r),a=this._getDistance(r,s)||i[r].offsetWidth;this.percent=o/a;var h,c=i[r],u=i[s],l=this.index!==s,d=r===s;[this.index,this.prevIndex].filter(function(t){return !y([s,r],t)}).forEach(function(t){Bt(i[t],"itemhidden",[e]),d&&(h=!0,e.prevIndex=r);}),(this.index===r&&this.prevIndex!==r||h)&&Bt(i[this.index],"itemshown",[this]),l&&(this.prevIndex=r,this.index=s,d||Bt(c,"beforeitemhide",[this]),Bt(u,"beforeitemshow",[this])),this._transitioner=this._translate(Math.abs(this.percent),c,!d&&u),l&&(d||Bt(c,"itemhide",[this]),Bt(u,"itemshow",[this]));}}},end:function(){if(Ot(window,"scroll",this.unbindMove),this.unbindMove&&this.unbindMove(),Ot(document,re,this.end,!0),this.dragging)if(this.dragging=null,this.index===this.prevIndex)this.percent=1-this.percent,this.dir*=-1,this._show(!1,this.index,!0),this._transitioner=null;else{var t=(Zt?this.dir*(Zt?1:-1):this.dir)<0==this.prevPos>this.pos;this.index=t?this.index:this.prevIndex,t&&(this.percent=1-this.percent),this.show(0<this.dir&&!t||this.dir<0&&t?"next":"previous",!0);}He(this.list,{userSelect:"",pointerEvents:""}),this.drag=this.percent=null;}}},{data:{selNav:!1},computed:{nav:function(t,e){return Se(t.selNav,e)},selNavItem:function(t){var e=t.attrItem;return "["+e+"],[data-"+e+"]"},navItems:function(t,e){return Te(this.selNavItem,e)}},update:{write:function(){var n=this;this.nav&&this.length!==this.nav.children.length&&de(this.nav,this.slides.map(function(t,e){return "<li "+n.attrItem+'="'+e+'"><a href="#"></a></li>'}).join("")),Oe(Te(this.selNavItem,this.$el).concat(this.nav),"uk-hidden",!this.maxIndex),this.updateNav();},events:["resize"]},events:[{name:"click",delegate:function(){return this.selNavItem},handler:function(t){t.preventDefault(),this.show(st(t.current,this.attrItem));}},{name:"itemshow",handler:"updateNav"}],methods:{updateNav:function(){var n=this,i=this.getValidIndex();this.navItems.forEach(function(t){var e=st(t,n.attrItem);Oe(t,n.clsActive,F(e)===i),Oe(t,"uk-invisible",n.finite&&("previous"===e&&0===i||"next"===e&&i>=n.maxIndex));});}}}],props:{clsActivated:Boolean,easing:String,index:Number,finite:Boolean,velocity:Number},data:function(){return {easing:"ease",finite:!1,velocity:1,index:0,stack:[],percent:0,clsActive:"uk-active",clsActivated:!1,Transitioner:!1,transitionOptions:{}}},computed:{duration:function(t,e){var n=t.velocity;return Br(e.offsetWidth/n)},length:function(){return this.slides.length},list:function(t,e){return Se(t.selList,e)},maxIndex:function(){return this.length-1},selSlides:function(t){return t.selList+" > *"},slides:function(){return V(this.list.children)}},events:{itemshown:function(){this.$update(this.list);}},methods:{show:function(t,e){var n=this;if(void 0===e&&(e=!1),!this.dragging&&this.length){var i=this.stack,r=e?0:i.length,o=function(){i.splice(r,1),i.length&&n.show(i.shift(),!0);};if(i[e?"unshift":"push"](t),!e&&1<i.length)2===i.length&&this._transitioner.forward(Math.min(this.duration,200));else{var s=this.index,a=Me(this.slides,this.clsActive)&&this.slides[s],h=this.getIndex(t,this.index),c=this.slides[h];if(a!==c){if(this.dir=function(t,e){return "next"===t?1:"previous"===t?-1:t<e?-1:1}(t,s),this.prevIndex=s,this.index=h,a&&Bt(a,"beforeitemhide",[this]),!Bt(c,"beforeitemshow",[this,a]))return this.index=this.prevIndex,void o();var u=this._show(a,c,e).then(function(){return a&&Bt(a,"itemhidden",[n]),Bt(c,"itemshown",[n]),new Yt(function(t){xn.write(function(){i.shift(),i.length?n.show(i.shift(),!0):n._transitioner=null,t();});})});return a&&Bt(a,"itemhide",[this]),Bt(c,"itemshow",[this]),u}o();}}},getIndex:function(t,e){return void 0===t&&(t=this.index),void 0===e&&(e=this.index),Z(ue(t,this.slides,e,this.finite),0,this.maxIndex)},getValidIndex:function(t,e){return void 0===t&&(t=this.index),void 0===e&&(e=this.prevIndex),this.getIndex(t,e)},_show:function(t,e,n){if(this._transitioner=this._getTransitioner(t,e,this.dir,X({easing:n?e.offsetWidth<600?"cubic-bezier(0.25, 0.46, 0.45, 0.94)":"cubic-bezier(0.165, 0.84, 0.44, 1)":this.easing},this.transitionOptions)),!n&&!t)return this._transitioner.translate(1),Yt.resolve();var i=this.stack.length;return this._transitioner[1<i?"forward":"show"](1<i?Math.min(this.duration,75+75/(i-1)):this.duration,this.percent)},_getDistance:function(t,e){return new this._getTransitioner(t,t!==e&&e).getDistance()},_translate:function(t,e,n){void 0===e&&(e=this.prevIndex),void 0===n&&(n=this.index);var i=this._getTransitioner(e!==n&&e,n);return i.translate(t),i},_getTransitioner:function(t,e,n,i){return void 0===t&&(t=this.prevIndex),void 0===e&&(e=this.index),void 0===n&&(n=this.dir||1),void 0===i&&(i=this.transitionOptions),new this.Transitioner(B(t)?this.slides[t]:t,B(e)?this.slides[e]:e,n*(Zt?-1:1),i)}}};function Br(t){return .5*t+300}var zr={mixins:[Dr],props:{animation:String},data:{animation:"slide",clsActivated:"uk-transition-active",Animations:Ar,Transitioner:function(o,s,a,t){var e=t.animation,h=t.easing,n=e.percent,i=e.translate,r=e.show;void 0===r&&(r=Q);var c=r(a),u=new Vt;return {dir:a,show:function(t,e,n){var i=this;void 0===e&&(e=0);var r=n?"linear":h;return t-=Math.round(t*Z(e,-1,1)),this.translate(e),Or(s,"itemin",{percent:e,duration:t,timing:r,dir:a}),Or(o,"itemout",{percent:1-e,duration:t,timing:r,dir:a}),Yt.all([Ue.start(s,c[1],t,r),Ue.start(o,c[0],t,r)]).then(function(){i.reset(),u.resolve();},Q),u.promise},stop:function(){return Ue.stop([s,o])},cancel:function(){Ue.cancel([s,o]);},reset:function(){for(var t in c[0])He([s,o],t,"");},forward:function(t,e){return void 0===e&&(e=this.percent()),Ue.cancel([s,o]),this.show(t,e,!0)},translate:function(t){this.reset();var e=i(t,a);He(s,e[1]),He(o,e[0]),Or(s,"itemtranslatein",{percent:t,dir:a}),Or(o,"itemtranslateout",{percent:1-t,dir:a});},percent:function(){return n(o||s,s,a)},getDistance:function(){return o&&o.offsetWidth}}}},computed:{animation:function(t){var e=t.animation,n=t.Animations;return X(e in n?n[e]:n.slide,{name:e})},transitionOptions:function(){return {animation:this.animation}}},events:{"itemshow itemhide itemshown itemhidden":function(t){var e=t.target;this.$update(e);},beforeitemshow:function(t){Ae(t.target,this.clsActive);},itemshown:function(t){Ae(t.target,this.clsActivated);},itemhidden:function(t){Ce(t.target,this.clsActive,this.clsActivated);}}},Pr={mixins:[Qi,tr,ei,zr],functional:!0,props:{delayControls:Number,preload:Number,videoAutoplay:Boolean,template:String},data:function(){return {preload:1,videoAutoplay:!1,delayControls:3e3,items:[],cls:"uk-open",clsPage:"uk-lightbox-page",selList:".uk-lightbox-items",attrItem:"uk-lightbox-item",selClose:".uk-close-large",pauseOnHover:!1,velocity:2,Animations:Mr,template:'<div class="uk-lightbox uk-overflow-hidden"> <ul class="uk-lightbox-items"></ul> <div class="uk-lightbox-toolbar uk-position-top uk-text-right uk-transition-slide-top uk-transition-opaque"> <button class="uk-lightbox-toolbar-icon uk-close-large" type="button" uk-close></button> </div> <a class="uk-lightbox-button uk-position-center-left uk-position-medium uk-transition-fade" href="#" uk-slidenav-previous uk-lightbox-item="previous"></a> <a class="uk-lightbox-button uk-position-center-right uk-position-medium uk-transition-fade" href="#" uk-slidenav-next uk-lightbox-item="next"></a> <div class="uk-lightbox-toolbar uk-lightbox-caption uk-position-bottom uk-text-center uk-transition-slide-bottom uk-transition-opaque"></div> </div>'}},created:function(){var t=this;this.$mount(fe(this.container,this.template)),this.caption=Se(".uk-lightbox-caption",this.$el),this.items.forEach(function(){return fe(t.list,"<li></li>")});},events:[{name:ie+" "+ne+" keydown",handler:"showControls"},{name:"click",self:!0,delegate:function(){return this.selSlides},handler:function(t){t.defaultPrevented||this.hide();}},{name:"shown",self:!0,handler:function(){this.showControls();}},{name:"hide",self:!0,handler:function(){this.hideControls(),Ce(this.slides,this.clsActive),Ue.stop(this.slides);}},{name:"hidden",self:!0,handler:function(){this.$destroy(!0);}},{name:"keyup",el:document,handler:function(t){if(this.isToggled(this.$el))switch(t.keyCode){case 37:this.show("previous");break;case 39:this.show("next");}}},{name:"beforeitemshow",handler:function(t){this.isToggled()||(this.draggable=!1,t.preventDefault(),this.toggleNow(this.$el,!0),this.animation=Mr.scale,Ce(t.target,this.clsActive),this.stack.splice(1,0,this.index));}},{name:"itemshow",handler:function(t){var e=ce(t.target),n=this.getItem(e).caption;He(this.caption,"display",n?"":"none"),de(this.caption,n);for(var i=0;i<=this.preload;i++)this.loadItem(this.getIndex(e+i)),this.loadItem(this.getIndex(e-i));}},{name:"itemshown",handler:function(){this.draggable=this.$props.draggable;}},{name:"itemload",handler:function(t,r){var o,s=this,e=r.source,n=r.type,i=r.alt;if(this.setItem(r,"<span uk-spinner></span>"),e)if("image"===n||e.match(/\.(jp(e)?g|png|gif|svg|webp)($|\?)/i))Gt(e).then(function(t){return s.setItem(r,'<img width="'+t.width+'" height="'+t.height+'" src="'+e+'" alt="'+(i||"")+'">')},function(){return s.setError(r)});else if("video"===n||e.match(/\.(mp4|webm|ogv)($|\?)/i)){var a=Se("<video controls playsinline"+(r.poster?' poster="'+r.poster+'"':"")+' uk-video="'+this.videoAutoplay+'"></video>');it(a,"src",e),Dt(a,"error loadedmetadata",function(t){"error"===t?s.setError(r):(it(a,{width:a.videoWidth,height:a.videoHeight}),s.setItem(r,a));});}else if("iframe"===n||e.match(/\.(html|php)($|\?)/i))this.setItem(r,'<iframe class="uk-lightbox-iframe" src="'+e+'" frameborder="0" allowfullscreen></iframe>');else if(o=e.match(/\/\/.*?youtube(-nocookie)?\.[a-z]+\/watch\?v=([^&\s]+)/)||e.match(/()youtu\.be\/(.*)/)){var h=o[2],c=function(t,e){return void 0===t&&(t=640),void 0===e&&(e=450),s.setItem(r,Hr("https://www.youtube"+(o[1]||"")+".com/embed/"+h,t,e,s.videoAutoplay))};Gt("https://img.youtube.com/vi/"+h+"/maxresdefault.jpg").then(function(t){var e=t.width,n=t.height;120===e&&90===n?Gt("https://img.youtube.com/vi/"+h+"/0.jpg").then(function(t){var e=t.width,n=t.height;return c(e,n)},c):c(e,n);},c);}else(o=e.match(/(\/\/.*?)vimeo\.[a-z]+\/([0-9]+).*?/))&&Kt("https://vimeo.com/api/oembed.json?maxwidth=1920&url="+encodeURI(e),{responseType:"json",withCredentials:!1}).then(function(t){var e=t.response,n=e.height,i=e.width;return s.setItem(r,Hr("https://player.vimeo.com/video/"+o[2],i,n,s.videoAutoplay))},function(){return s.setError(r)});}}],methods:{loadItem:function(t){void 0===t&&(t=this.index);var e=this.getItem(t);e.content||Bt(this.$el,"itemload",[e]);},getItem:function(t){return void 0===t&&(t=this.index),this.items[t]||{}},setItem:function(t,e){X(t,{content:e});var n=de(this.slides[this.items.indexOf(t)],e);Bt(this.$el,"itemloaded",[this,n]),this.$update(n);},setError:function(t){this.setItem(t,'<span uk-icon="icon: bolt; ratio: 2"></span>');},showControls:function(){clearTimeout(this.controlsTimer),this.controlsTimer=setTimeout(this.hideControls,this.delayControls),Ae(this.$el,"uk-active","uk-transition-active");},hideControls:function(){Ce(this.$el,"uk-active","uk-transition-active");}}};function Hr(t,e,n,i){return '<iframe src="'+t+'" width="'+e+'" height="'+n+'" style="max-width: 100%; box-sizing: border-box;" frameborder="0" allowfullscreen uk-video="autoplay: '+i+'" uk-responsive></iframe>'}var Lr,Fr={install:function(t,e){t.lightboxPanel||t.component("lightboxPanel",Pr);X(e.props,t.component("lightboxPanel").options.props);},props:{toggle:String},data:{toggle:"a"},computed:{toggles:{get:function(t,e){return Te(t.toggle,e)},watch:function(){this.hide();}},items:function(){return J(this.toggles.map(jr),"source")}},disconnected:function(){this.hide();},events:[{name:"click",delegate:function(){return this.toggle+":not(.uk-disabled)"},handler:function(t){t.preventDefault();var e=st(t.current,"href");this.show(k(this.items,function(t){return t.source===e}));}}],methods:{show:function(t){var e=this;return this.panel=this.panel||this.$create("lightboxPanel",X({},this.$props,{items:this.items})),Mt(this.panel.$el,"hidden",function(){return e.panel=!1}),this.panel.show(t)},hide:function(){return this.panel&&this.panel.hide()}}};function jr(n){return ["href","caption","type","poster","alt"].reduce(function(t,e){return t["href"===e?"source":e]=st(n,e),t},{})}var Wr={},Vr={functional:!0,args:["message","status"],data:{message:"",status:"",timeout:5e3,group:null,pos:"top-center",clsClose:"uk-notification-close",clsMsg:"uk-notification-message"},install:function(r){r.notification.closeAll=function(n,i){Ie(document.body,function(t){var e=r.getComponent(t,"notification");!e||n&&n!==e.group||e.close(i);});};},computed:{marginProp:function(t){return "margin"+(w(t.pos,"top")?"Top":"Bottom")},startProps:function(){var t;return (t={opacity:0})[this.marginProp]=-this.$el.offsetHeight,t}},created:function(){Wr[this.pos]||(Wr[this.pos]=fe(this.$container,'<div class="uk-notification uk-notification-'+this.pos+'"></div>'));var t=He(Wr[this.pos],"display","block");this.$mount(fe(t,'<div class="'+this.clsMsg+(this.status?" "+this.clsMsg+"-"+this.status:"")+'"> <a href="#" class="'+this.clsClose+'" data-uk-close></a> <div>'+this.message+"</div> </div>"));},connected:function(){var t,e=this,n=j(He(this.$el,this.marginProp));Ue.start(He(this.$el,this.startProps),((t={opacity:1})[this.marginProp]=n,t)).then(function(){e.timeout&&(e.timer=setTimeout(e.close,e.timeout));});},events:(Lr={click:function(t){xt(t.target,'a[href="#"],a[href=""]')&&t.preventDefault(),this.close();}},Lr[oe]=function(){this.timer&&clearTimeout(this.timer);},Lr[se]=function(){this.timeout&&(this.timer=setTimeout(this.close,this.timeout));},Lr),methods:{close:function(t){function e(){Bt(n.$el,"close",[n]),ve(n.$el),Wr[n.pos].children.length||He(Wr[n.pos],"display","none");}var n=this;this.timer&&clearTimeout(this.timer),t?e():Ue.start(this.$el,this.startProps).then(e);}}};var Yr=["x","y","bgx","bgy","rotate","scale","color","backgroundColor","borderColor","opacity","blur","hue","grayscale","invert","saturate","sepia","fopacity","stroke"],Rr={mixins:[Ki],props:Yr.reduce(function(t,e){return t[e]="list",t},{}),data:Yr.reduce(function(t,e){return t[e]=void 0,t},{}),computed:{props:function(m,g){var v=this;return Yr.reduce(function(t,e){if(H(m[e]))return t;var n,i,r,o=e.match(/color/i),s=o||"opacity"===e,a=m[e].slice(0);s&&He(g,e,""),a.length<2&&a.unshift(("scale"===e?1:s?He(g,e):0)||0);var h=function(t){return t.reduce(function(t,e){return D(e)&&e.replace(/-|\d/g,"").trim()||t},"")}(a);if(o){var c=g.style.color;a=a.map(function(t){return function(t,e){return He(He(t,"color",e),"color").split(/[(),]/g).slice(1,-1).concat(1).slice(0,4).map(j)}(g,t)}),g.style.color=c;}else if(w(e,"bg")){var u="bgy"===e?"height":"width";if(a=a.map(function(t){return vn(t,u,v.$el)}),He(g,"background-position-"+e[2],""),i=He(g,"backgroundPosition").split(" ")["x"===e[2]?0:1],v.covers){var l=Math.min.apply(Math,a),d=Math.max.apply(Math,a),f=a.indexOf(l)<a.indexOf(d);r=d-l,a=a.map(function(t){return t-(f?l:d)}),n=(f?-r:0)+"px";}else n=i;}else a=a.map(j);if("stroke"===e){if(!a.some(function(t){return t}))return t;var p=Ai(v.$el);He(g,"strokeDasharray",p),"%"===h&&(a=a.map(function(t){return t*p/100})),a=a.reverse(),e="strokeDashoffset";}return t[e]={steps:a,unit:h,pos:n,bgPos:i,diff:r},t},{})},bgProps:function(){var e=this;return ["bgx","bgy"].filter(function(t){return t in e.props})},covers:function(t,e){return function(t){var e=t.style.backgroundSize,n="cover"===He(He(t,"backgroundSize",""),"backgroundSize");return t.style.backgroundSize=e,n}(e)}},disconnected:function(){delete this._image;},update:{read:function(t){var h=this;if(t.active=this.matchMedia,t.active){if(!t.image&&this.covers&&this.bgProps.length){var e=He(this.$el,"backgroundImage").replace(/^none|url\(["']?(.+?)["']?\)$/,"$1");if(e){var n=new Image;n.src=e,(t.image=n).naturalWidth||(n.onload=function(){return h.$emit()});}}var i=t.image;if(i&&i.naturalWidth){var c={width:this.$el.offsetWidth,height:this.$el.offsetHeight},u={width:i.naturalWidth,height:i.naturalHeight},l=nt.cover(u,c);this.bgProps.forEach(function(t){var e=h.props[t],n=e.diff,i=e.bgPos,r=e.steps,o="bgy"===t?"height":"width",s=l[o]-c[o];if(s<n)c[o]=l[o]+n-s;else if(n<s){var a=c[o]/vn(i,o,h.$el);a&&(h.props[t].steps=r.map(function(t){return t-(s-n)/a}));}l=nt.cover(u,c);}),t.dim=l;}}},write:function(t){var e=t.dim;t.active?e&&He(this.$el,{backgroundSize:e.width+"px "+e.height+"px",backgroundRepeat:"no-repeat"}):He(this.$el,{backgroundSize:"",backgroundRepeat:""});},events:["resize"]},methods:{reset:function(){var n=this;K(this.getCss(0),function(t,e){return He(n.$el,e,"")});},getCss:function(l){var d=this.props;return Object.keys(d).reduce(function(t,e){var n=d[e],i=n.steps,r=n.unit,o=n.pos,s=function(t,e,n){void 0===n&&(n=2);var i=qr(t,e),r=i[0],o=i[1],s=i[2];return (B(r)?r+Math.abs(r-o)*s*(r<o?1:-1):+o).toFixed(n)}(i,l);switch(e){case"x":case"y":r=r||"px",t.transform+=" translate"+p(e)+"("+j(s).toFixed("px"===r?0:2)+r+")";break;case"rotate":r=r||"deg",t.transform+=" rotate("+(s+r)+")";break;case"scale":t.transform+=" scale("+s+")";break;case"bgy":case"bgx":t["background-position-"+e[2]]="calc("+o+" + "+s+"px)";break;case"color":case"backgroundColor":case"borderColor":var a=qr(i,l),h=a[0],c=a[1],u=a[2];t[e]="rgba("+h.map(function(t,e){return t+=u*(c[e]-t),3===e?j(t):parseInt(t,10)}).join(",")+")";break;case"blur":r=r||"px",t.filter+=" blur("+(s+r)+")";break;case"hue":r=r||"deg",t.filter+=" hue-rotate("+(s+r)+")";break;case"fopacity":r=r||"%",t.filter+=" opacity("+(s+r)+")";break;case"grayscale":case"invert":case"saturate":case"sepia":r=r||"%",t.filter+=" "+e+"("+(s+r)+")";break;default:t[e]=s;}return t},{transform:"",filter:""})}}};function qr(t,e){var n=t.length-1,i=Math.min(Math.floor(n*e),n-1),r=t.slice(i,i+2);return r.push(1===e?1:e%(1/n)*n),r}var Ur={mixins:[Rr],props:{target:String,viewport:Number,easing:Number},data:{target:!1,viewport:1,easing:1},computed:{target:function(t,e){var n=t.target;return function t(e){return e?"offsetTop"in e?e:t(e.parentNode):document.body}(n&&at(n,e)||e)}},update:{read:function(t,e){var n=t.percent;if("scroll"!==e&&(n=!1),t.active){var i=n;return {percent:n=function(t,e){return Z(t*(1-(e-e*t)))}(pn(this.target)/(this.viewport||1),this.easing),style:i!==n&&this.getCss(n)}}},write:function(t){var e=t.style;t.active?e&&He(this.$el,e):this.reset();},events:["scroll","resize"]}};var Xr={update:{write:function(){if(!this.stack.length&&!this.dragging){var t=this.getValidIndex();delete this.index,Ce(this.slides,this.clsActive,this.clsActivated),this.show(t);}},events:["resize"]}};function Kr(t,e,n){var i=Zr(t,e);return n?i-function(t,e){return Qr(e).width/2-Qr(t).width/2}(t,e):Math.min(i,Gr(e))}function Gr(t){return Math.max(0,Jr(t)-Qr(t).width)}function Jr(t){return eo(t).reduce(function(t,e){return Qr(e).width+t},0)}function Zr(t,e){return (rn(t).left+(Zt?Qr(t).width-Qr(e).width:0))*(Zt?-1:1)}function Qr(t){return t.getBoundingClientRect()}function to(t,e,n){Bt(t,zt(e,!1,!1,n));}function eo(t){return V(t.children)}var no={mixins:[ti,Dr,Xr],props:{center:Boolean,sets:Boolean},data:{center:!1,sets:!1,attrItem:"uk-slider-item",selList:".uk-slider-items",selNav:".uk-slider-nav",clsContainer:"uk-slider-container",Transitioner:function(r,i,o,t){var e=t.center,s=t.easing,a=t.list,h=new Vt,n=r?Kr(r,a,e):Kr(i,a,e)+Qr(i).width*o,c=i?Kr(i,a,e):n+Qr(r).width*o*(Zt?-1:1);return {dir:o,show:function(t,e,n){void 0===e&&(e=0);var i=n?"linear":s;return t-=Math.round(t*Z(e,-1,1)),this.translate(e),r&&this.updateTranslates(),e=r?e:Z(e,0,1),to(this.getItemIn(),"itemin",{percent:e,duration:t,timing:i,dir:o}),r&&to(this.getItemIn(!0),"itemout",{percent:1-e,duration:t,timing:i,dir:o}),Ue.start(a,{transform:Nr(-c*(Zt?-1:1),"px")},t,i).then(h.resolve,Q),h.promise},stop:function(){return Ue.stop(a)},cancel:function(){Ue.cancel(a);},reset:function(){He(a,"transform","");},forward:function(t,e){return void 0===e&&(e=this.percent()),Ue.cancel(a),this.show(t,e,!0)},translate:function(t){var e=this.getDistance()*o*(Zt?-1:1);He(a,"transform",Nr(Z(e-e*t-c,-Jr(a),Qr(a).width)*(Zt?-1:1),"px")),this.updateTranslates(),r&&(t=Z(t,-1,1),to(this.getItemIn(),"itemtranslatein",{percent:t,dir:o}),to(this.getItemIn(!0),"itemtranslateout",{percent:1-t,dir:o}));},percent:function(){return Math.abs((He(a,"transform").split(",")[4]*(Zt?-1:1)+n)/(c-n))},getDistance:function(){return Math.abs(c-n)},getItemIn:function(t){void 0===t&&(t=!1);var e=this.getActives(),n=G(eo(a),"offsetLeft"),i=ce(n,e[0<o*(t?-1:1)?e.length-1:0]);return ~i&&n[i+(r&&!t?o:0)]},getActives:function(){var n=Kr(r||i,a,e);return G(eo(a).filter(function(t){var e=Zr(t,a);return n<=e&&e+Qr(t).width<=Qr(a).width+n}),"offsetLeft")},updateTranslates:function(){var n=this.getActives();eo(a).forEach(function(t){var e=y(n,t);to(t,"itemtranslate"+(e?"in":"out"),{percent:e?1:0,dir:t.offsetLeft<=i.offsetLeft?1:-1});});}}}},computed:{avgWidth:function(){return Jr(this.list)/this.length},finite:function(t){return t.finite||Jr(this.list)<Qr(this.list).width+function(t){return eo(t).reduce(function(t,e){return Math.max(t,Qr(e).width)},0)}(this.list)+this.center},maxIndex:function(){if(!this.finite||this.center&&!this.sets)return this.length-1;if(this.center)return this.sets[this.sets.length-1];He(this.slides,"order","");for(var t=Gr(this.list),e=this.length;e--;)if(Zr(this.list.children[e],this.list)<t)return Math.min(e+1,this.length-1);return 0},sets:function(t){var o=this,e=t.sets,s=Qr(this.list).width/(this.center?2:1),a=0,h=s,c=0;return !P(e=e&&this.slides.reduce(function(t,e,n){var i=Qr(e).width;if(a<c+i&&(!o.center&&n>o.maxIndex&&(n=o.maxIndex),!y(t,n))){var r=o.slides[n+1];o.center&&r&&i<h-Qr(r).width/2?h-=i:(h=s,t.push(n),a=c+s+(o.center?i/2:0));}return c+=i,t},[]))&&e},transitionOptions:function(){return {center:this.center,list:this.list}}},connected:function(){Oe(this.$el,this.clsContainer,!Se("."+this.clsContainer,this.$el));},update:{write:function(){var n=this;Te("["+this.attrItem+"],[data-"+this.attrItem+"]",this.$el).forEach(function(t){var e=st(t,n.attrItem);n.maxIndex&&Oe(t,"uk-hidden",z(e)&&(n.sets&&!y(n.sets,j(e))||e>n.maxIndex));});},events:["resize"]},events:{beforeitemshow:function(t){!this.dragging&&this.sets&&this.stack.length<2&&!y(this.sets,this.index)&&(this.index=this.getValidIndex());var e=Math.abs(this.index-this.prevIndex+(0<this.dir&&this.index<this.prevIndex||this.dir<0&&this.index>this.prevIndex?(this.maxIndex+1)*this.dir:0));if(!this.dragging&&1<e){for(var n=0;n<e;n++)this.stack.splice(1,0,0<this.dir?"next":"previous");t.preventDefault();}else this.duration=Br(this.avgWidth/this.velocity)*(Qr(this.dir<0||!this.slides[this.prevIndex]?this.slides[this.index]:this.slides[this.prevIndex]).width/this.avgWidth),this.reorder();},itemshow:function(){H(this.prevIndex)||Ae(this._getTransitioner().getItemIn(),this.clsActive);},itemshown:function(){var e=this,n=this._getTransitioner(this.index).getActives();this.slides.forEach(function(t){return Oe(t,e.clsActive,y(n,t))}),this.sets&&!y(this.sets,j(this.index))||this.slides.forEach(function(t){return Oe(t,e.clsActivated,y(n,t))});}},methods:{reorder:function(){var n=this;if(He(this.slides,"order",""),!this.finite){var i=0<this.dir&&this.slides[this.prevIndex]?this.prevIndex:this.index;if(this.slides.forEach(function(t,e){return He(t,"order",0<n.dir&&e<i?1:n.dir<0&&e>=n.index?-1:"")}),this.center)for(var t=this.slides[i],e=Qr(this.list).width/2-Qr(t).width/2,r=0;0<e;){var o=this.getIndex(--r+i,i),s=this.slides[o];He(s,"order",i<o?-2:-1),e-=Qr(s).width;}}},getValidIndex:function(t,e){if(void 0===t&&(t=this.index),void 0===e&&(e=this.prevIndex),t=this.getIndex(t,e),!this.sets)return t;var n;do{if(y(this.sets,t))return t;n=t,t=this.getIndex(t+this.dir,e);}while(t!==n);return t}}},io={mixins:[Rr],data:{selItem:"!li"},computed:{item:function(t,e){return at(t.selItem,e)}},events:[{name:"itemshown",self:!0,el:function(){return this.item},handler:function(){He(this.$el,this.getCss(.5));}},{name:"itemin itemout",self:!0,el:function(){return this.item},handler:function(t){var e=t.type,n=t.detail,i=n.percent,r=n.duration,o=n.timing,s=n.dir;Ue.cancel(this.$el),He(this.$el,this.getCss(oo(e,s,i))),Ue.start(this.$el,this.getCss(ro(e)?.5:0<s?1:0),r,o).catch(Q);}},{name:"transitioncanceled transitionend",self:!0,el:function(){return this.item},handler:function(){Ue.cancel(this.$el);}},{name:"itemtranslatein itemtranslateout",self:!0,el:function(){return this.item},handler:function(t){var e=t.type,n=t.detail,i=n.percent,r=n.dir;Ue.cancel(this.$el),He(this.$el,this.getCss(oo(e,r,i)));}}]};function ro(t){return u(t,"in")}function oo(t,e,n){return n/=2,ro(t)?e<0?1-n:n:e<0?n:1-n}var so,ao=X({},Ar,{fade:{show:function(){return [{opacity:0,zIndex:0},{zIndex:-1}]},percent:function(t){return 1-He(t,"opacity")},translate:function(t){return [{opacity:1-t,zIndex:0},{zIndex:-1}]}},scale:{show:function(){return [{opacity:0,transform:_r(1.5),zIndex:0},{zIndex:-1}]},percent:function(t){return 1-He(t,"opacity")},translate:function(t){return [{opacity:1-t,transform:_r(1+.5*t),zIndex:0},{zIndex:-1}]}},pull:{show:function(t){return t<0?[{transform:Nr(30),zIndex:-1},{transform:Nr(),zIndex:0}]:[{transform:Nr(-100),zIndex:0},{transform:Nr(),zIndex:-1}]},percent:function(t,e,n){return n<0?1-Cr(e):Cr(t)},translate:function(t,e){return e<0?[{transform:Nr(30*t),zIndex:-1},{transform:Nr(-100*(1-t)),zIndex:0}]:[{transform:Nr(100*-t),zIndex:0},{transform:Nr(30*(1-t)),zIndex:-1}]}},push:{show:function(t){return t<0?[{transform:Nr(100),zIndex:0},{transform:Nr(),zIndex:-1}]:[{transform:Nr(-30),zIndex:-1},{transform:Nr(),zIndex:0}]},percent:function(t,e,n){return 0<n?1-Cr(e):Cr(t)},translate:function(t,e){return e<0?[{transform:Nr(100*t),zIndex:0},{transform:Nr(-30*(1-t)),zIndex:-1}]:[{transform:Nr(-30*t),zIndex:-1},{transform:Nr(100*(1-t)),zIndex:0}]}}}),ho={mixins:[ti,zr,Xr],props:{ratio:String,minHeight:Number,maxHeight:Number},data:{ratio:"16:9",minHeight:!1,maxHeight:!1,selList:".uk-slideshow-items",attrItem:"uk-slideshow-item",selNav:".uk-slideshow-nav",Animations:ao},update:{read:function(){var t=this.ratio.split(":").map(Number),e=t[0],n=t[1];return n=n*this.list.offsetWidth/e||0,this.minHeight&&(n=Math.max(this.minHeight,n)),this.maxHeight&&(n=Math.min(this.maxHeight,n)),{height:n-hn(this.list,"content-box")}},write:function(t){var e=t.height;He(this.list,"minHeight",e);},events:["resize"]}},co={mixins:[ti,xr],props:{group:String,threshold:Number,clsItem:String,clsPlaceholder:String,clsDrag:String,clsDragState:String,clsBase:String,clsNoDrag:String,clsEmpty:String,clsCustom:String,handle:String},data:{group:!1,threshold:5,clsItem:"uk-sortable-item",clsPlaceholder:"uk-sortable-placeholder",clsDrag:"uk-sortable-drag",clsDragState:"uk-drag",clsBase:"uk-sortable",clsNoDrag:"uk-sortable-nodrag",clsEmpty:"uk-sortable-empty",clsCustom:"",handle:!1},created:function(){var o=this;["init","start","move","end"].forEach(function(t){var r=o[t];o[t]=function(t){o.scrollY=window.pageYOffset;var e=Wt(t,"page"),n=e.x,i=e.y;o.pos={x:n,y:i},r(t);};});},events:{name:ne,passive:!1,handler:"init"},update:{write:function(){if(this.clsEmpty&&Oe(this.$el,this.clsEmpty,P(this.$el.children)),He(this.handle?Te(this.handle,this.$el):this.$el.children,{touchAction:"none",userSelect:"none"}),this.drag){en(this.drag,{top:this.pos.y+this.origin.top,left:this.pos.x+this.origin.left});var t,e=en(this.drag),n=e.top,i=n+e.height;0<n&&n<this.scrollY?t=this.scrollY-5:i<on(document)&&i>on(window)+this.scrollY&&(t=this.scrollY+5),t&&setTimeout(function(){return mn(window,t)},5);}}},methods:{init:function(t){var e=t.target,n=t.button,i=t.defaultPrevented,r=V(this.$el.children).filter(function(t){return _t(e,t)})[0];!r||i||0<n||Ct(e)||_t(e,"."+this.clsNoDrag)||this.handle&&!_t(e,this.handle)||(t.preventDefault(),this.touched=[this],this.placeholder=r,this.origin=X({target:e,index:ce(r)},this.pos),Mt(document,ie,this.move),Mt(document,re,this.end),Mt(window,"scroll",this.scroll),this.threshold||this.start(t));},start:function(t){this.drag=fe(this.$container,this.placeholder.outerHTML.replace(/^<li/i,"<div").replace(/li>$/i,"div>")),He(this.drag,X({boxSizing:"border-box",width:this.placeholder.offsetWidth,height:this.placeholder.offsetHeight},He(this.placeholder,["paddingLeft","paddingRight","paddingTop","paddingBottom"]))),it(this.drag,"uk-no-boot",""),Ae(this.drag,this.clsDrag,this.clsCustom),on(this.drag.firstElementChild,on(this.placeholder.firstElementChild));var e=en(this.placeholder),n=e.left,i=e.top;X(this.origin,{left:n-this.pos.x,top:i-this.pos.y}),Ae(this.placeholder,this.clsPlaceholder),Ae(this.$el.children,this.clsItem),Ae(document.documentElement,this.clsDragState),Bt(this.$el,"start",[this,this.placeholder]),this.move(t);},move:function(t){if(this.drag){this.$emit();var e="mousemove"===t.type?t.target:document.elementFromPoint(this.pos.x-window.pageXOffset,this.pos.y-window.pageYOffset),n=this.getSortable(e),i=this.getSortable(this.placeholder),r=n!==i;if(n&&!_t(e,this.placeholder)&&(!r||n.group&&n.group===i.group)){if(e=n.$el===e.parentNode&&e||V(n.$el.children).filter(function(t){return _t(e,t)})[0],r)i.remove(this.placeholder);else if(!e)return;n.insert(this.placeholder,e),y(this.touched,n)||this.touched.push(n);}}else(Math.abs(this.pos.x-this.origin.x)>this.threshold||Math.abs(this.pos.y-this.origin.y)>this.threshold)&&this.start(t);},end:function(t){if(Ot(document,ie,this.move),Ot(document,re,this.end),Ot(window,"scroll",this.scroll),this.drag){var e=this.getSortable(this.placeholder);this===e?this.origin.index!==ce(this.placeholder)&&Bt(this.$el,"moved",[this,this.placeholder]):(Bt(e.$el,"added",[e,this.placeholder]),Bt(this.$el,"removed",[this,this.placeholder])),Bt(this.$el,"stop",[this,this.placeholder]),ve(this.drag),this.drag=null;var n=this.touched.map(function(t){return t.clsPlaceholder+" "+t.clsItem}).join(" ");this.touched.forEach(function(t){return Ce(t.$el.children,n)}),Ce(document.documentElement,this.clsDragState);}else"touchend"===t.type&&t.target.click();},scroll:function(){var t=window.pageYOffset;t!==this.scrollY&&(this.pos.y+=t-this.scrollY,this.scrollY=t,this.$emit());},insert:function(t,e){var n=this;Ae(this.$el.children,this.clsItem);function i(){e?!_t(t,n.$el)||function(t,e){return t.parentNode===e.parentNode&&ce(t)>ce(e)}(t,e)?pe(e,t):me(e,t):fe(n.$el,t);}this.animation?this.animate(i):i();},remove:function(t){_t(t,this.$el)&&(He(this.handle?Te(this.handle,t):t,{touchAction:"",userSelect:""}),this.animation?this.animate(function(){return ve(t)}):ve(t));},getSortable:function(t){return t&&(this.$getComponent(t,"sortable")||this.getSortable(t.parentNode))}}};var uo,lo,fo,po=[],mo={mixins:[Qi,ei,ci],args:"title",props:{delay:Number,title:String},data:{pos:"top",title:"",delay:0,animation:["uk-animation-scale-up"],duration:100,cls:"uk-active",clsPos:"uk-tooltip"},beforeConnect:function(){this._hasTitle=rt(this.$el,"title"),it(this.$el,{title:"","aria-expanded":!1});},disconnected:function(){this.hide(),it(this.$el,{title:this._hasTitle?this.title:null,"aria-expanded":null});},methods:{show:function(){var e=this;this.isActive()||(po.forEach(function(t){return t.hide()}),po.push(this),this._unbind=Mt(document,re,function(t){return !_t(t.target,e.$el)&&e.hide()}),clearTimeout(this.showTimer),this.showTimer=setTimeout(function(){e._show(),e.hideTimer=setInterval(function(){Et(e.$el)||e.hide();},150);},this.delay));},hide:function(){!this.isActive()||bt(this.$el,"input")&&this.$el===document.activeElement||(po.splice(po.indexOf(this),1),clearTimeout(this.showTimer),clearInterval(this.hideTimer),it(this.$el,"aria-expanded",!1),this.toggleElement(this.tooltip,!1),this.tooltip&&ve(this.tooltip),this.tooltip=!1,this._unbind());},_show:function(){this.tooltip=fe(this.container,'<div class="'+this.clsPos+'" aria-expanded="true" aria-hidden> <div class="'+this.clsPos+'-inner">'+this.title+"</div> </div>"),this.positionAt(this.tooltip,this.$el),this.origin="y"===this.getAxis()?dn(this.dir)+"-"+this.align:this.align+"-"+dn(this.dir),this.toggleElement(this.tooltip,!0);},isActive:function(){return y(po,this)}},events:(so={focus:"show",blur:"hide"},so[oe+" "+se]=function(t){jt(t)||(t.type===oe?this.show():this.hide());},so[ne]=function(t){jt(t)&&(this.isActive()?this.hide():this.show());},so)},go={props:{allow:String,clsDragover:String,concurrent:Number,maxSize:Number,method:String,mime:String,msgInvalidMime:String,msgInvalidName:String,msgInvalidSize:String,multiple:Boolean,name:String,params:Object,type:String,url:String},data:{allow:!1,clsDragover:"uk-dragover",concurrent:1,maxSize:0,method:"POST",mime:!1,msgInvalidMime:"Invalid File Type: %s",msgInvalidName:"Invalid File Name: %s",msgInvalidSize:"Invalid File Size: %s Kilobytes Max",multiple:!1,name:"files[]",params:{},type:"",url:"",abort:Q,beforeAll:Q,beforeSend:Q,complete:Q,completeAll:Q,error:Q,fail:Q,load:Q,loadEnd:Q,loadStart:Q,progress:Q},events:{change:function(t){bt(t.target,'input[type="file"]')&&(t.preventDefault(),t.target.files&&this.upload(t.target.files),t.target.value="");},drop:function(t){wo(t);var e=t.dataTransfer;e&&e.files&&(Ce(this.$el,this.clsDragover),this.upload(e.files));},dragenter:function(t){wo(t);},dragover:function(t){wo(t),Ae(this.$el,this.clsDragover);},dragleave:function(t){wo(t),Ce(this.$el,this.clsDragover);}},methods:{upload:function(t){var i=this;if(t.length){Bt(this.$el,"upload",[t]);for(var e=0;e<t.length;e++){if(this.maxSize&&1e3*this.maxSize<t[e].size)return void this.fail(this.msgInvalidSize.replace("%s",this.maxSize));if(this.allow&&!vo(this.allow,t[e].name))return void this.fail(this.msgInvalidName.replace("%s",this.allow));if(this.mime&&!vo(this.mime,t[e].type))return void this.fail(this.msgInvalidMime.replace("%s",this.mime))}this.multiple||(t=[t[0]]),this.beforeAll(this,t);var r=function(t,e){for(var n=[],i=0;i<t.length;i+=e){for(var r=[],o=0;o<e;o++)r.push(t[i+o]);n.push(r);}return n}(t,this.concurrent),o=function(t){var e=new FormData;for(var n in t.forEach(function(t){return e.append(i.name,t)}),i.params)e.append(n,i.params[n]);Kt(i.url,{data:e,method:i.method,responseType:i.type,beforeSend:function(t){var e=t.xhr;e.upload&&Mt(e.upload,"progress",i.progress),["loadStart","load","loadEnd","abort"].forEach(function(t){return Mt(e,t.toLowerCase(),i[t])}),i.beforeSend(t);}}).then(function(t){i.complete(t),r.length?o(r.shift()):i.completeAll(t);},function(t){return i.error(t)});};o(r.shift());}}}};function vo(t,e){return e.match(new RegExp("^"+t.replace(/\//g,"\\/").replace(/\*\*/g,"(\\/[^\\/]+)*").replace(/\*/g,"[^\\/]+").replace(/((?!\\))\?/g,"$1.")+"$","i"))}function wo(t){t.preventDefault(),t.stopPropagation();}function bo(){xo(document.body,lo),xn.flush(),new MutationObserver(function(t){return t.forEach(yo)}).observe(document,{childList:!0,subtree:!0,characterData:!0,attributes:!0}),uo._initialized=!0;}function yo(t){var e=t.target;("attributes"!==t.type?function(t){for(var e=t.addedNodes,n=t.removedNodes,i=0;i<e.length;i++)xo(e[i],lo);for(var r=0;r<n.length;r++)xo(n[r],fo);return !0}(t):function(t){var e=t.target,n=t.attributeName;if("href"===n)return !0;var i=Pn(n);if(!(i&&i in uo))return;if(rt(e,n))return uo[i](e),!0;var r=uo.getComponent(e,i);if(r)return r.$destroy(),!0}(t))&&uo.update(e);}function xo(t,e){if(1===t.nodeType&&!rt(t,"uk-no-boot"))for(e(t),t=t.firstElementChild;t;){var n=t.nextElementSibling;xo(t,e),t=n;}}return Hn.component("countdown",wr),Hn.component("filter",Sr),Hn.component("lightbox",Fr),Hn.component("lightboxPanel",Pr),Hn.component("notification",Vr),Hn.component("parallax",Ur),Hn.component("slider",no),Hn.component("sliderParallax",io),Hn.component("slideshow",ho),Hn.component("slideshowParallax",io),Hn.component("sortable",co),Hn.component("tooltip",mo),Hn.component("upload",go),lo=(uo=Hn).connect,fo=uo.disconnect,"MutationObserver"in window&&(document.body?bo():new MutationObserver(function(){document.body&&(this.disconnect(),bo());}).observe(document,{childList:!0,subtree:!0})),Hn});
|
|
});
|
|
|
|
const app = new App({
|
|
target: document.getElementById("app")
|
|
});
|
|
|
|
}(fp, shortid, _, compiler_util, lunr, safe_buffer));
|
|
//# sourceMappingURL=bundle.js.map
|