2894 lines
86 KiB
JavaScript
2894 lines
86 KiB
JavaScript
|
import { Y as SvelteComponentDev, Z as init, $ as safe_not_equal, a0 as dispatch_dev, a1 as create_slot, a2 as validate_slots, a3 as base$1, a4 as tick, a5 as element, a6 as space, a7 as text, a8 as claim_element, a9 as children, aa as detach_dev, ab as claim_space, ac as claim_text, ad as attr_dev, ae as add_location, af as src_url_equal, ag as insert_hydration_dev, ah as append_hydration_dev, ai as update_slot_base, aj as get_all_dirty_from_scope, ak as get_slot_changes, al as set_data_dev, am as transition_in, an as transition_out, ao as binding_callbacks, ap as bind, aq as create_component, ar as claim_component, as as mount_component, at as destroy_component, au as add_flush_callback, av as noop, aw as bubble, ax as set_input_value, ay as listen_dev, az as run_all, aA as assign, aB as getContext, aC as get_spread_update, aD as get_spread_object, aE as to_number, aF as validate_each_argument, aG as validate_each_keys, aH as empty, aI as update_keyed_each, aJ as destroy_block, aK as logEvent, _ as __vitePreload, aL as createRouter, v as histoireConfig, aM as createWebHistory, aN as createWebHashHistory, aO as markRaw, K as reactive, d as defineComponent, r as ref, aP as watchEffect, o as openBlock, q as createBlock, aQ as mergeProps, aR as resolveDynamicComponent, h as createCommentVNode } from "./vendor-3ab3e533.js";
|
||
|
|
const ShipItem_svelte_svelte_type_style_lang = "";
|
||
|
|
const file$5 = "src/lib/components/ShipItem.svelte";
|
||
|
|
function create_fragment$b(ctx) {
|
||
|
|
let div4;
|
||
|
|
let div0;
|
||
|
|
let t0;
|
||
|
|
let div3;
|
||
|
|
let div1;
|
||
|
|
let t1;
|
||
|
|
let t2;
|
||
|
|
let img;
|
||
|
|
let img_src_value;
|
||
|
|
let t3;
|
||
|
|
let div2;
|
||
|
|
let t4;
|
||
|
|
let current;
|
||
|
|
const default_slot_template = (
|
||
|
|
/*#slots*/
|
||
|
|
ctx[5].default
|
||
|
|
);
|
||
|
|
const default_slot = create_slot(
|
||
|
|
default_slot_template,
|
||
|
|
ctx,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx[4],
|
||
|
|
null
|
||
|
|
);
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
div4 = element("div");
|
||
|
|
div0 = element("div");
|
||
|
|
if (default_slot)
|
||
|
|
default_slot.c();
|
||
|
|
t0 = space();
|
||
|
|
div3 = element("div");
|
||
|
|
div1 = element("div");
|
||
|
|
t1 = text(
|
||
|
|
/*mass*/
|
||
|
|
ctx[0]
|
||
|
|
);
|
||
|
|
t2 = space();
|
||
|
|
img = element("img");
|
||
|
|
t3 = space();
|
||
|
|
div2 = element("div");
|
||
|
|
t4 = text(
|
||
|
|
/*cost*/
|
||
|
|
ctx[1]
|
||
|
|
);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
div4 = claim_element(nodes, "DIV", { class: true });
|
||
|
|
var div4_nodes = children(div4);
|
||
|
|
div0 = claim_element(div4_nodes, "DIV", { class: true });
|
||
|
|
var div0_nodes = children(div0);
|
||
|
|
if (default_slot)
|
||
|
|
default_slot.l(div0_nodes);
|
||
|
|
div0_nodes.forEach(detach_dev);
|
||
|
|
t0 = claim_space(div4_nodes);
|
||
|
|
div3 = claim_element(div4_nodes, "DIV", { class: true });
|
||
|
|
var div3_nodes = children(div3);
|
||
|
|
div1 = claim_element(div3_nodes, "DIV", { class: true });
|
||
|
|
var div1_nodes = children(div1);
|
||
|
|
t1 = claim_text(
|
||
|
|
div1_nodes,
|
||
|
|
/*mass*/
|
||
|
|
ctx[0]
|
||
|
|
);
|
||
|
|
t2 = claim_space(div1_nodes);
|
||
|
|
img = claim_element(div1_nodes, "IMG", { src: true, alt: true, class: true });
|
||
|
|
div1_nodes.forEach(detach_dev);
|
||
|
|
t3 = claim_space(div3_nodes);
|
||
|
|
div2 = claim_element(div3_nodes, "DIV", { class: true });
|
||
|
|
var div2_nodes = children(div2);
|
||
|
|
t4 = claim_text(
|
||
|
|
div2_nodes,
|
||
|
|
/*cost*/
|
||
|
|
ctx[1]
|
||
|
|
);
|
||
|
|
div2_nodes.forEach(detach_dev);
|
||
|
|
div3_nodes.forEach(detach_dev);
|
||
|
|
div4_nodes.forEach(detach_dev);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(div0, "class", "s-Z06Qyz0SWBsp");
|
||
|
|
add_location(div0, file$5, 1, 2, 26);
|
||
|
|
if (!src_url_equal(img.src, img_src_value = base$1 + "/mass.svg"))
|
||
|
|
attr_dev(img, "src", img_src_value);
|
||
|
|
attr_dev(img, "alt", "mass");
|
||
|
|
attr_dev(img, "class", "s-Z06Qyz0SWBsp");
|
||
|
|
add_location(img, file$5, 5, 13, 124);
|
||
|
|
attr_dev(div1, "class", "mass s-Z06Qyz0SWBsp");
|
||
|
|
add_location(div1, file$5, 4, 4, 72);
|
||
|
|
attr_dev(div2, "class", "cost s-Z06Qyz0SWBsp");
|
||
|
|
add_location(div2, file$5, 7, 4, 180);
|
||
|
|
attr_dev(div3, "class", "reqs s-Z06Qyz0SWBsp");
|
||
|
|
add_location(div3, file$5, 3, 2, 49);
|
||
|
|
attr_dev(div4, "class", "ship-item s-Z06Qyz0SWBsp");
|
||
|
|
add_location(div4, file$5, 0, 0, 0);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, div4, anchor);
|
||
|
|
append_hydration_dev(div4, div0);
|
||
|
|
if (default_slot) {
|
||
|
|
default_slot.m(div0, null);
|
||
|
|
}
|
||
|
|
append_hydration_dev(div4, t0);
|
||
|
|
append_hydration_dev(div4, div3);
|
||
|
|
append_hydration_dev(div3, div1);
|
||
|
|
append_hydration_dev(div1, t1);
|
||
|
|
append_hydration_dev(div1, t2);
|
||
|
|
append_hydration_dev(div1, img);
|
||
|
|
ctx[6](div1);
|
||
|
|
append_hydration_dev(div3, t3);
|
||
|
|
append_hydration_dev(div3, div2);
|
||
|
|
append_hydration_dev(div2, t4);
|
||
|
|
ctx[7](div2);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
if (default_slot) {
|
||
|
|
if (default_slot.p && (!current || dirty & /*$$scope*/
|
||
|
|
16)) {
|
||
|
|
update_slot_base(
|
||
|
|
default_slot,
|
||
|
|
default_slot_template,
|
||
|
|
ctx2,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[4],
|
||
|
|
!current ? get_all_dirty_from_scope(
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[4]
|
||
|
|
) : get_slot_changes(
|
||
|
|
default_slot_template,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[4],
|
||
|
|
dirty,
|
||
|
|
null
|
||
|
|
),
|
||
|
|
null
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!current || dirty & /*mass*/
|
||
|
|
1)
|
||
|
|
set_data_dev(
|
||
|
|
t1,
|
||
|
|
/*mass*/
|
||
|
|
ctx2[0]
|
||
|
|
);
|
||
|
|
if (!current || dirty & /*cost*/
|
||
|
|
2)
|
||
|
|
set_data_dev(
|
||
|
|
t4,
|
||
|
|
/*cost*/
|
||
|
|
ctx2[1]
|
||
|
|
);
|
||
|
|
},
|
||
|
|
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_dev(div4);
|
||
|
|
if (default_slot)
|
||
|
|
default_slot.d(detaching);
|
||
|
|
ctx[6](null);
|
||
|
|
ctx[7](null);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$b.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$b($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("ShipItem", slots, ["default"]);
|
||
|
|
let { mass } = $$props;
|
||
|
|
let { cost } = $$props;
|
||
|
|
let mass_el;
|
||
|
|
let cost_el;
|
||
|
|
const update_el = async (el) => {
|
||
|
|
if (!el)
|
||
|
|
return;
|
||
|
|
el.classList.remove("updated");
|
||
|
|
void el.offsetWidth;
|
||
|
|
el.classList.add("updated");
|
||
|
|
};
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (mass === void 0 && !("mass" in $$props || $$self.$$.bound[$$self.$$.props["mass"]])) {
|
||
|
|
console.warn("<ShipItem> was created without expected prop 'mass'");
|
||
|
|
}
|
||
|
|
if (cost === void 0 && !("cost" in $$props || $$self.$$.bound[$$self.$$.props["cost"]])) {
|
||
|
|
console.warn("<ShipItem> was created without expected prop 'cost'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["mass", "cost"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<ShipItem> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
function div1_binding($$value) {
|
||
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
|
|
mass_el = $$value;
|
||
|
|
$$invalidate(2, mass_el);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
function div2_binding($$value) {
|
||
|
|
binding_callbacks[$$value ? "unshift" : "push"](() => {
|
||
|
|
cost_el = $$value;
|
||
|
|
$$invalidate(3, cost_el);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("mass" in $$props2)
|
||
|
|
$$invalidate(0, mass = $$props2.mass);
|
||
|
|
if ("cost" in $$props2)
|
||
|
|
$$invalidate(1, cost = $$props2.cost);
|
||
|
|
if ("$$scope" in $$props2)
|
||
|
|
$$invalidate(4, $$scope = $$props2.$$scope);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({
|
||
|
|
base: base$1,
|
||
|
|
tick,
|
||
|
|
mass,
|
||
|
|
cost,
|
||
|
|
mass_el,
|
||
|
|
cost_el,
|
||
|
|
update_el
|
||
|
|
});
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("mass" in $$props2)
|
||
|
|
$$invalidate(0, mass = $$props2.mass);
|
||
|
|
if ("cost" in $$props2)
|
||
|
|
$$invalidate(1, cost = $$props2.cost);
|
||
|
|
if ("mass_el" in $$props2)
|
||
|
|
$$invalidate(2, mass_el = $$props2.mass_el);
|
||
|
|
if ("cost_el" in $$props2)
|
||
|
|
$$invalidate(3, cost_el = $$props2.cost_el);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
$$self.$$.update = () => {
|
||
|
|
if ($$self.$$.dirty & /*mass_el, mass*/
|
||
|
|
5) {
|
||
|
|
update_el(mass_el);
|
||
|
|
}
|
||
|
|
if ($$self.$$.dirty & /*cost_el, cost*/
|
||
|
|
10) {
|
||
|
|
update_el(cost_el);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return [mass, cost, mass_el, cost_el, $$scope, slots, div1_binding, div2_binding];
|
||
|
|
}
|
||
|
|
class ShipItem extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$b, create_fragment$b, safe_not_equal, { mass: 0, cost: 1 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "ShipItem",
|
||
|
|
options,
|
||
|
|
id: create_fragment$b.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get mass() {
|
||
|
|
throw new Error("<ShipItem>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set mass(value) {
|
||
|
|
throw new Error("<ShipItem>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get cost() {
|
||
|
|
throw new Error("<ShipItem>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set cost(value) {
|
||
|
|
throw new Error("<ShipItem>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function create_default_slot_1$2(ctx) {
|
||
|
|
let t;
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
t = text("Thingy");
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
t = claim_text(nodes, "Thingy");
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, t, anchor);
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(t);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot_1$2.name,
|
||
|
|
type: "slot",
|
||
|
|
source: "(2:2) <ShipItem {mass} {cost}>",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_default_slot$7(ctx) {
|
||
|
|
let shipitem;
|
||
|
|
let current;
|
||
|
|
shipitem = new ShipItem({
|
||
|
|
props: {
|
||
|
|
mass: (
|
||
|
|
/*mass*/
|
||
|
|
ctx[1]
|
||
|
|
),
|
||
|
|
cost: (
|
||
|
|
/*cost*/
|
||
|
|
ctx[2]
|
||
|
|
),
|
||
|
|
$$slots: { default: [create_default_slot_1$2] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(shipitem.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(shipitem.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(shipitem, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
const shipitem_changes = {};
|
||
|
|
if (dirty & /*mass*/
|
||
|
|
2)
|
||
|
|
shipitem_changes.mass = /*mass*/
|
||
|
|
ctx2[1];
|
||
|
|
if (dirty & /*cost*/
|
||
|
|
4)
|
||
|
|
shipitem_changes.cost = /*cost*/
|
||
|
|
ctx2[2];
|
||
|
|
if (dirty & /*$$scope*/
|
||
|
|
32) {
|
||
|
|
shipitem_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
shipitem.$set(shipitem_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(shipitem.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(shipitem.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(shipitem, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot$7.name,
|
||
|
|
type: "slot",
|
||
|
|
source: "(1:0) <Hst.Story>",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_controls_slot(ctx) {
|
||
|
|
let hst_number0;
|
||
|
|
let updating_value;
|
||
|
|
let t;
|
||
|
|
let hst_number1;
|
||
|
|
let updating_value_1;
|
||
|
|
let current;
|
||
|
|
function hst_number0_value_binding(value) {
|
||
|
|
ctx[3](value);
|
||
|
|
}
|
||
|
|
let hst_number0_props = { title: "Mass" };
|
||
|
|
if (
|
||
|
|
/*mass*/
|
||
|
|
ctx[1] !== void 0
|
||
|
|
) {
|
||
|
|
hst_number0_props.value = /*mass*/
|
||
|
|
ctx[1];
|
||
|
|
}
|
||
|
|
hst_number0 = new /*Hst*/
|
||
|
|
ctx[0].Number({ props: hst_number0_props, $$inline: true });
|
||
|
|
binding_callbacks.push(() => bind(hst_number0, "value", hst_number0_value_binding));
|
||
|
|
function hst_number1_value_binding(value) {
|
||
|
|
ctx[4](value);
|
||
|
|
}
|
||
|
|
let hst_number1_props = { title: "Cost" };
|
||
|
|
if (
|
||
|
|
/*cost*/
|
||
|
|
ctx[2] !== void 0
|
||
|
|
) {
|
||
|
|
hst_number1_props.value = /*cost*/
|
||
|
|
ctx[2];
|
||
|
|
}
|
||
|
|
hst_number1 = new /*Hst*/
|
||
|
|
ctx[0].Number({ props: hst_number1_props, $$inline: true });
|
||
|
|
binding_callbacks.push(() => bind(hst_number1, "value", hst_number1_value_binding));
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(hst_number0.$$.fragment);
|
||
|
|
t = space();
|
||
|
|
create_component(hst_number1.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(hst_number0.$$.fragment, nodes);
|
||
|
|
t = claim_space(nodes);
|
||
|
|
claim_component(hst_number1.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(hst_number0, target, anchor);
|
||
|
|
insert_hydration_dev(target, t, anchor);
|
||
|
|
mount_component(hst_number1, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
const hst_number0_changes = {};
|
||
|
|
if (!updating_value && dirty & /*mass*/
|
||
|
|
2) {
|
||
|
|
updating_value = true;
|
||
|
|
hst_number0_changes.value = /*mass*/
|
||
|
|
ctx2[1];
|
||
|
|
add_flush_callback(() => updating_value = false);
|
||
|
|
}
|
||
|
|
hst_number0.$set(hst_number0_changes);
|
||
|
|
const hst_number1_changes = {};
|
||
|
|
if (!updating_value_1 && dirty & /*cost*/
|
||
|
|
4) {
|
||
|
|
updating_value_1 = true;
|
||
|
|
hst_number1_changes.value = /*cost*/
|
||
|
|
ctx2[2];
|
||
|
|
add_flush_callback(() => updating_value_1 = false);
|
||
|
|
}
|
||
|
|
hst_number1.$set(hst_number1_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(hst_number0.$$.fragment, local);
|
||
|
|
transition_in(hst_number1.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(hst_number0.$$.fragment, local);
|
||
|
|
transition_out(hst_number1.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(hst_number0, detaching);
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(t);
|
||
|
|
destroy_component(hst_number1, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_controls_slot.name,
|
||
|
|
type: "slot",
|
||
|
|
source: '(3:2) <svelte:fragment slot=\\"controls\\">',
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$a(ctx) {
|
||
|
|
let hst_story;
|
||
|
|
let current;
|
||
|
|
hst_story = new /*Hst*/
|
||
|
|
ctx[0].Story({
|
||
|
|
props: {
|
||
|
|
$$slots: {
|
||
|
|
controls: [create_controls_slot],
|
||
|
|
default: [create_default_slot$7]
|
||
|
|
},
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(hst_story.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(hst_story.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(hst_story, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const hst_story_changes = {};
|
||
|
|
if (dirty & /*$$scope, cost, mass*/
|
||
|
|
38) {
|
||
|
|
hst_story_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
hst_story.$set(hst_story_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(hst_story.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(hst_story.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(hst_story, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$a.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$a($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("ShipItem_story", slots, []);
|
||
|
|
let { Hst } = $$props;
|
||
|
|
let mass = 1;
|
||
|
|
let cost = 3;
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (Hst === void 0 && !("Hst" in $$props || $$self.$$.bound[$$self.$$.props["Hst"]])) {
|
||
|
|
console.warn("<ShipItem_story> was created without expected prop 'Hst'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["Hst"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<ShipItem_story> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
function hst_number0_value_binding(value) {
|
||
|
|
mass = value;
|
||
|
|
$$invalidate(1, mass);
|
||
|
|
}
|
||
|
|
function hst_number1_value_binding(value) {
|
||
|
|
cost = value;
|
||
|
|
$$invalidate(2, cost);
|
||
|
|
}
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ Hst, ShipItem, mass, cost });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
if ("mass" in $$props2)
|
||
|
|
$$invalidate(1, mass = $$props2.mass);
|
||
|
|
if ("cost" in $$props2)
|
||
|
|
$$invalidate(2, cost = $$props2.cost);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [Hst, mass, cost, hst_number0_value_binding, hst_number1_value_binding];
|
||
|
|
}
|
||
|
|
class ShipItem_story extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$a, create_fragment$a, safe_not_equal, { Hst: 0 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "ShipItem_story",
|
||
|
|
options,
|
||
|
|
id: create_fragment$a.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get Hst() {
|
||
|
|
throw new Error("<ShipItem_story>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set Hst(value) {
|
||
|
|
throw new Error("<ShipItem_story>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const index_svelte_svelte_type_style_lang = "";
|
||
|
|
const file$4 = "src/lib/components/CostMass/index.svelte";
|
||
|
|
function create_fragment$9(ctx) {
|
||
|
|
let div0;
|
||
|
|
let t0;
|
||
|
|
let img;
|
||
|
|
let img_src_value;
|
||
|
|
let t1;
|
||
|
|
let div1;
|
||
|
|
let t2;
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
div0 = element("div");
|
||
|
|
t0 = text(
|
||
|
|
/*mass*/
|
||
|
|
ctx[0]
|
||
|
|
);
|
||
|
|
img = element("img");
|
||
|
|
t1 = space();
|
||
|
|
div1 = element("div");
|
||
|
|
t2 = text(
|
||
|
|
/*cost*/
|
||
|
|
ctx[1]
|
||
|
|
);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
div0 = claim_element(nodes, "DIV", { class: true });
|
||
|
|
var div0_nodes = children(div0);
|
||
|
|
t0 = claim_text(
|
||
|
|
div0_nodes,
|
||
|
|
/*mass*/
|
||
|
|
ctx[0]
|
||
|
|
);
|
||
|
|
img = claim_element(div0_nodes, "IMG", { src: true, alt: true, class: true });
|
||
|
|
div0_nodes.forEach(detach_dev);
|
||
|
|
t1 = claim_space(nodes);
|
||
|
|
div1 = claim_element(nodes, "DIV", { class: true });
|
||
|
|
var div1_nodes = children(div1);
|
||
|
|
t2 = claim_text(
|
||
|
|
div1_nodes,
|
||
|
|
/*cost*/
|
||
|
|
ctx[1]
|
||
|
|
);
|
||
|
|
div1_nodes.forEach(detach_dev);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
if (!src_url_equal(img.src, img_src_value = base$1 + "/mass.svg"))
|
||
|
|
attr_dev(img, "src", img_src_value);
|
||
|
|
attr_dev(img, "alt", "mass");
|
||
|
|
attr_dev(img, "class", "s-oaXyF42PwCjx");
|
||
|
|
add_location(img, file$4, 0, 24, 24);
|
||
|
|
attr_dev(div0, "class", "mass s-oaXyF42PwCjx");
|
||
|
|
add_location(div0, file$4, 0, 0, 0);
|
||
|
|
attr_dev(div1, "class", "cost s-oaXyF42PwCjx");
|
||
|
|
add_location(div1, file$4, 1, 0, 71);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, div0, anchor);
|
||
|
|
append_hydration_dev(div0, t0);
|
||
|
|
append_hydration_dev(div0, img);
|
||
|
|
insert_hydration_dev(target, t1, anchor);
|
||
|
|
insert_hydration_dev(target, div1, anchor);
|
||
|
|
append_hydration_dev(div1, t2);
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
if (dirty & /*mass*/
|
||
|
|
1)
|
||
|
|
set_data_dev(
|
||
|
|
t0,
|
||
|
|
/*mass*/
|
||
|
|
ctx2[0]
|
||
|
|
);
|
||
|
|
if (dirty & /*cost*/
|
||
|
|
2)
|
||
|
|
set_data_dev(
|
||
|
|
t2,
|
||
|
|
/*cost*/
|
||
|
|
ctx2[1]
|
||
|
|
);
|
||
|
|
},
|
||
|
|
i: noop,
|
||
|
|
o: noop,
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(div0);
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(t1);
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(div1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$9.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$9($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("CostMass", slots, []);
|
||
|
|
let { mass } = $$props;
|
||
|
|
let { cost } = $$props;
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (mass === void 0 && !("mass" in $$props || $$self.$$.bound[$$self.$$.props["mass"]])) {
|
||
|
|
console.warn("<CostMass> was created without expected prop 'mass'");
|
||
|
|
}
|
||
|
|
if (cost === void 0 && !("cost" in $$props || $$self.$$.bound[$$self.$$.props["cost"]])) {
|
||
|
|
console.warn("<CostMass> was created without expected prop 'cost'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["mass", "cost"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<CostMass> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("mass" in $$props2)
|
||
|
|
$$invalidate(0, mass = $$props2.mass);
|
||
|
|
if ("cost" in $$props2)
|
||
|
|
$$invalidate(1, cost = $$props2.cost);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ base: base$1, mass, cost });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("mass" in $$props2)
|
||
|
|
$$invalidate(0, mass = $$props2.mass);
|
||
|
|
if ("cost" in $$props2)
|
||
|
|
$$invalidate(1, cost = $$props2.cost);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [mass, cost];
|
||
|
|
}
|
||
|
|
class CostMass extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$9, create_fragment$9, safe_not_equal, { mass: 0, cost: 1 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "CostMass",
|
||
|
|
options,
|
||
|
|
id: create_fragment$9.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get mass() {
|
||
|
|
throw new Error("<CostMass>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set mass(value) {
|
||
|
|
throw new Error("<CostMass>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get cost() {
|
||
|
|
throw new Error("<CostMass>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set cost(value) {
|
||
|
|
throw new Error("<CostMass>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function create_default_slot$6(ctx) {
|
||
|
|
let costmass;
|
||
|
|
let current;
|
||
|
|
costmass = new CostMass({
|
||
|
|
props: { mass: 12, cost: 21 },
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(costmass.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(costmass.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(costmass, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: noop,
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(costmass.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(costmass.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(costmass, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot$6.name,
|
||
|
|
type: "slot",
|
||
|
|
source: '(1:0) <Hst.Story title=\\"CostMass\\">',
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$8(ctx) {
|
||
|
|
let hst_story;
|
||
|
|
let current;
|
||
|
|
hst_story = new /*Hst*/
|
||
|
|
ctx[0].Story({
|
||
|
|
props: {
|
||
|
|
title: "CostMass",
|
||
|
|
$$slots: { default: [create_default_slot$6] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(hst_story.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(hst_story.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(hst_story, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const hst_story_changes = {};
|
||
|
|
if (dirty & /*$$scope*/
|
||
|
|
2) {
|
||
|
|
hst_story_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
hst_story.$set(hst_story_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(hst_story.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(hst_story.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(hst_story, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$8.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$8($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("CostMass", slots, []);
|
||
|
|
let { Hst } = $$props;
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (Hst === void 0 && !("Hst" in $$props || $$self.$$.bound[$$self.$$.props["Hst"]])) {
|
||
|
|
console.warn("<CostMass> was created without expected prop 'Hst'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["Hst"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<CostMass> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ Hst, CostMass });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [Hst];
|
||
|
|
}
|
||
|
|
class CostMass_1 extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$8, create_fragment$8, safe_not_equal, { Hst: 0 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "CostMass_1",
|
||
|
|
options,
|
||
|
|
id: create_fragment$8.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get Hst() {
|
||
|
|
throw new Error("<CostMass>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set Hst(value) {
|
||
|
|
throw new Error("<CostMass>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const Section_svelte_svelte_type_style_lang = "";
|
||
|
|
const file$3 = "src/lib/components/Section.svelte";
|
||
|
|
function create_fragment$7(ctx) {
|
||
|
|
let div;
|
||
|
|
let h2;
|
||
|
|
let t0;
|
||
|
|
let t1;
|
||
|
|
let hr;
|
||
|
|
let t2;
|
||
|
|
let current;
|
||
|
|
const default_slot_template = (
|
||
|
|
/*#slots*/
|
||
|
|
ctx[2].default
|
||
|
|
);
|
||
|
|
const default_slot = create_slot(
|
||
|
|
default_slot_template,
|
||
|
|
ctx,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx[1],
|
||
|
|
null
|
||
|
|
);
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
div = element("div");
|
||
|
|
h2 = element("h2");
|
||
|
|
t0 = text(
|
||
|
|
/*label*/
|
||
|
|
ctx[0]
|
||
|
|
);
|
||
|
|
t1 = space();
|
||
|
|
hr = element("hr");
|
||
|
|
t2 = space();
|
||
|
|
if (default_slot)
|
||
|
|
default_slot.c();
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
div = claim_element(nodes, "DIV", { class: true });
|
||
|
|
var div_nodes = children(div);
|
||
|
|
h2 = claim_element(div_nodes, "H2", { class: true });
|
||
|
|
var h2_nodes = children(h2);
|
||
|
|
t0 = claim_text(
|
||
|
|
h2_nodes,
|
||
|
|
/*label*/
|
||
|
|
ctx[0]
|
||
|
|
);
|
||
|
|
h2_nodes.forEach(detach_dev);
|
||
|
|
t1 = claim_space(div_nodes);
|
||
|
|
hr = claim_element(div_nodes, "HR", { class: true });
|
||
|
|
div_nodes.forEach(detach_dev);
|
||
|
|
t2 = claim_space(nodes);
|
||
|
|
if (default_slot)
|
||
|
|
default_slot.l(nodes);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(h2, "class", "s-8Wn_PeFn3mR4");
|
||
|
|
add_location(h2, file$3, 1, 2, 8);
|
||
|
|
attr_dev(hr, "class", "s-8Wn_PeFn3mR4");
|
||
|
|
add_location(hr, file$3, 2, 2, 27);
|
||
|
|
attr_dev(div, "class", "s-8Wn_PeFn3mR4");
|
||
|
|
add_location(div, file$3, 0, 0, 0);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, div, anchor);
|
||
|
|
append_hydration_dev(div, h2);
|
||
|
|
append_hydration_dev(h2, t0);
|
||
|
|
append_hydration_dev(div, t1);
|
||
|
|
append_hydration_dev(div, hr);
|
||
|
|
insert_hydration_dev(target, t2, anchor);
|
||
|
|
if (default_slot) {
|
||
|
|
default_slot.m(target, anchor);
|
||
|
|
}
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
if (!current || dirty & /*label*/
|
||
|
|
1)
|
||
|
|
set_data_dev(
|
||
|
|
t0,
|
||
|
|
/*label*/
|
||
|
|
ctx2[0]
|
||
|
|
);
|
||
|
|
if (default_slot) {
|
||
|
|
if (default_slot.p && (!current || dirty & /*$$scope*/
|
||
|
|
2)) {
|
||
|
|
update_slot_base(
|
||
|
|
default_slot,
|
||
|
|
default_slot_template,
|
||
|
|
ctx2,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[1],
|
||
|
|
!current ? get_all_dirty_from_scope(
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[1]
|
||
|
|
) : get_slot_changes(
|
||
|
|
default_slot_template,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[1],
|
||
|
|
dirty,
|
||
|
|
null
|
||
|
|
),
|
||
|
|
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_dev(div);
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(t2);
|
||
|
|
if (default_slot)
|
||
|
|
default_slot.d(detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$7.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$7($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Section", slots, ["default"]);
|
||
|
|
let { label } = $$props;
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (label === void 0 && !("label" in $$props || $$self.$$.bound[$$self.$$.props["label"]])) {
|
||
|
|
console.warn("<Section> was created without expected prop 'label'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["label"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Section> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("label" in $$props2)
|
||
|
|
$$invalidate(0, label = $$props2.label);
|
||
|
|
if ("$$scope" in $$props2)
|
||
|
|
$$invalidate(1, $$scope = $$props2.$$scope);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ label });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("label" in $$props2)
|
||
|
|
$$invalidate(0, label = $$props2.label);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [label, $$scope, slots];
|
||
|
|
}
|
||
|
|
class Section extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$7, create_fragment$7, safe_not_equal, { label: 0 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Section",
|
||
|
|
options,
|
||
|
|
id: create_fragment$7.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get label() {
|
||
|
|
throw new Error("<Section>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set label(value) {
|
||
|
|
throw new Error("<Section>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const Field_svelte_svelte_type_style_lang = "";
|
||
|
|
const file$2 = "src/lib/components/Field.svelte";
|
||
|
|
function create_if_block(ctx) {
|
||
|
|
let label_1;
|
||
|
|
let t;
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
label_1 = element("label");
|
||
|
|
t = text(
|
||
|
|
/*label*/
|
||
|
|
ctx[1]
|
||
|
|
);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
label_1 = claim_element(nodes, "LABEL", { class: true });
|
||
|
|
var label_1_nodes = children(label_1);
|
||
|
|
t = claim_text(
|
||
|
|
label_1_nodes,
|
||
|
|
/*label*/
|
||
|
|
ctx[1]
|
||
|
|
);
|
||
|
|
label_1_nodes.forEach(detach_dev);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(label_1, "class", "s-Q6iX6IPZr4w0");
|
||
|
|
add_location(label_1, file$2, 2, 4, 24);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, label_1, anchor);
|
||
|
|
append_hydration_dev(label_1, t);
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
if (dirty & /*label*/
|
||
|
|
2)
|
||
|
|
set_data_dev(
|
||
|
|
t,
|
||
|
|
/*label*/
|
||
|
|
ctx2[1]
|
||
|
|
);
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(label_1);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_if_block.name,
|
||
|
|
type: "if",
|
||
|
|
source: "(2:2) {#if label}",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function fallback_block(ctx) {
|
||
|
|
let input;
|
||
|
|
let mounted;
|
||
|
|
let dispose;
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
input = element("input");
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
input = claim_element(nodes, "INPUT", { type: true, placeholder: true });
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(input, "type", "text");
|
||
|
|
attr_dev(
|
||
|
|
input,
|
||
|
|
"placeholder",
|
||
|
|
/*placeholder*/
|
||
|
|
ctx[2]
|
||
|
|
);
|
||
|
|
add_location(input, file$2, 5, 4, 68);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, input, anchor);
|
||
|
|
set_input_value(
|
||
|
|
input,
|
||
|
|
/*value*/
|
||
|
|
ctx[0]
|
||
|
|
);
|
||
|
|
if (!mounted) {
|
||
|
|
dispose = [
|
||
|
|
listen_dev(
|
||
|
|
input,
|
||
|
|
"input",
|
||
|
|
/*input_input_handler*/
|
||
|
|
ctx[6]
|
||
|
|
),
|
||
|
|
listen_dev(
|
||
|
|
input,
|
||
|
|
"change",
|
||
|
|
/*change_handler*/
|
||
|
|
ctx[5],
|
||
|
|
false,
|
||
|
|
false,
|
||
|
|
false
|
||
|
|
)
|
||
|
|
];
|
||
|
|
mounted = true;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
if (dirty & /*placeholder*/
|
||
|
|
4) {
|
||
|
|
attr_dev(
|
||
|
|
input,
|
||
|
|
"placeholder",
|
||
|
|
/*placeholder*/
|
||
|
|
ctx2[2]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
if (dirty & /*value*/
|
||
|
|
1 && input.value !== /*value*/
|
||
|
|
ctx2[0]) {
|
||
|
|
set_input_value(
|
||
|
|
input,
|
||
|
|
/*value*/
|
||
|
|
ctx2[0]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(input);
|
||
|
|
mounted = false;
|
||
|
|
run_all(dispose);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: fallback_block.name,
|
||
|
|
type: "fallback",
|
||
|
|
source: "(5:8) ",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$6(ctx) {
|
||
|
|
let div;
|
||
|
|
let t;
|
||
|
|
let current;
|
||
|
|
let if_block = (
|
||
|
|
/*label*/
|
||
|
|
ctx[1] && create_if_block(ctx)
|
||
|
|
);
|
||
|
|
const default_slot_template = (
|
||
|
|
/*#slots*/
|
||
|
|
ctx[4].default
|
||
|
|
);
|
||
|
|
const default_slot = create_slot(
|
||
|
|
default_slot_template,
|
||
|
|
ctx,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx[3],
|
||
|
|
null
|
||
|
|
);
|
||
|
|
const default_slot_or_fallback = default_slot || fallback_block(ctx);
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
div = element("div");
|
||
|
|
if (if_block)
|
||
|
|
if_block.c();
|
||
|
|
t = space();
|
||
|
|
if (default_slot_or_fallback)
|
||
|
|
default_slot_or_fallback.c();
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
div = claim_element(nodes, "DIV", { class: true });
|
||
|
|
var div_nodes = children(div);
|
||
|
|
if (if_block)
|
||
|
|
if_block.l(div_nodes);
|
||
|
|
t = claim_space(div_nodes);
|
||
|
|
if (default_slot_or_fallback)
|
||
|
|
default_slot_or_fallback.l(div_nodes);
|
||
|
|
div_nodes.forEach(detach_dev);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(div, "class", "s-Q6iX6IPZr4w0");
|
||
|
|
add_location(div, file$2, 0, 0, 0);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, div, anchor);
|
||
|
|
if (if_block)
|
||
|
|
if_block.m(div, null);
|
||
|
|
append_hydration_dev(div, t);
|
||
|
|
if (default_slot_or_fallback) {
|
||
|
|
default_slot_or_fallback.m(div, null);
|
||
|
|
}
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
if (
|
||
|
|
/*label*/
|
||
|
|
ctx2[1]
|
||
|
|
) {
|
||
|
|
if (if_block) {
|
||
|
|
if_block.p(ctx2, dirty);
|
||
|
|
} else {
|
||
|
|
if_block = create_if_block(ctx2);
|
||
|
|
if_block.c();
|
||
|
|
if_block.m(div, t);
|
||
|
|
}
|
||
|
|
} else if (if_block) {
|
||
|
|
if_block.d(1);
|
||
|
|
if_block = null;
|
||
|
|
}
|
||
|
|
if (default_slot) {
|
||
|
|
if (default_slot.p && (!current || dirty & /*$$scope*/
|
||
|
|
8)) {
|
||
|
|
update_slot_base(
|
||
|
|
default_slot,
|
||
|
|
default_slot_template,
|
||
|
|
ctx2,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[3],
|
||
|
|
!current ? get_all_dirty_from_scope(
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[3]
|
||
|
|
) : get_slot_changes(
|
||
|
|
default_slot_template,
|
||
|
|
/*$$scope*/
|
||
|
|
ctx2[3],
|
||
|
|
dirty,
|
||
|
|
null
|
||
|
|
),
|
||
|
|
null
|
||
|
|
);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (default_slot_or_fallback && default_slot_or_fallback.p && (!current || dirty & /*placeholder, value*/
|
||
|
|
5)) {
|
||
|
|
default_slot_or_fallback.p(ctx2, !current ? -1 : dirty);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(default_slot_or_fallback, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(default_slot_or_fallback, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(div);
|
||
|
|
if (if_block)
|
||
|
|
if_block.d();
|
||
|
|
if (default_slot_or_fallback)
|
||
|
|
default_slot_or_fallback.d(detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$6.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$6($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Field", slots, ["default"]);
|
||
|
|
let { label = "" } = $$props;
|
||
|
|
let { value = "" } = $$props;
|
||
|
|
let { placeholder = label } = $$props;
|
||
|
|
const writable_props = ["label", "value", "placeholder"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Field> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
function change_handler(event) {
|
||
|
|
bubble.call(this, $$self, event);
|
||
|
|
}
|
||
|
|
function input_input_handler() {
|
||
|
|
value = this.value;
|
||
|
|
$$invalidate(0, value);
|
||
|
|
}
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("label" in $$props2)
|
||
|
|
$$invalidate(1, label = $$props2.label);
|
||
|
|
if ("value" in $$props2)
|
||
|
|
$$invalidate(0, value = $$props2.value);
|
||
|
|
if ("placeholder" in $$props2)
|
||
|
|
$$invalidate(2, placeholder = $$props2.placeholder);
|
||
|
|
if ("$$scope" in $$props2)
|
||
|
|
$$invalidate(3, $$scope = $$props2.$$scope);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ label, value, placeholder });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("label" in $$props2)
|
||
|
|
$$invalidate(1, label = $$props2.label);
|
||
|
|
if ("value" in $$props2)
|
||
|
|
$$invalidate(0, value = $$props2.value);
|
||
|
|
if ("placeholder" in $$props2)
|
||
|
|
$$invalidate(2, placeholder = $$props2.placeholder);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [value, label, placeholder, $$scope, slots, change_handler, input_input_handler];
|
||
|
|
}
|
||
|
|
class Field extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$6, create_fragment$6, safe_not_equal, { label: 1, value: 0, placeholder: 2 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Field",
|
||
|
|
options,
|
||
|
|
id: create_fragment$6.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get label() {
|
||
|
|
throw new Error("<Field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set label(value) {
|
||
|
|
throw new Error("<Field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get value() {
|
||
|
|
throw new Error("<Field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set value(value) {
|
||
|
|
throw new Error("<Field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get placeholder() {
|
||
|
|
throw new Error("<Field>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set placeholder(value) {
|
||
|
|
throw new Error("<Field>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const Engine_svelte_svelte_type_style_lang = "";
|
||
|
|
const file$1 = "src/lib/components/ShipEdit/Propulsion/Engine.svelte";
|
||
|
|
function create_default_slot_1$1(ctx) {
|
||
|
|
let t;
|
||
|
|
let input;
|
||
|
|
let mounted;
|
||
|
|
let dispose;
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
t = text("Well then!\n ");
|
||
|
|
input = element("input");
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
t = claim_text(nodes, "Well then!\n ");
|
||
|
|
input = claim_element(nodes, "INPUT", {
|
||
|
|
class: true,
|
||
|
|
type: true,
|
||
|
|
min: true,
|
||
|
|
max: true,
|
||
|
|
step: true
|
||
|
|
});
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(input, "class", "short s-6wUMfpp2c9lR");
|
||
|
|
attr_dev(input, "type", "number");
|
||
|
|
attr_dev(input, "min", "0");
|
||
|
|
attr_dev(input, "max", "20");
|
||
|
|
attr_dev(input, "step", "1");
|
||
|
|
add_location(input, file$1, 4, 6, 86);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, t, anchor);
|
||
|
|
insert_hydration_dev(target, input, anchor);
|
||
|
|
set_input_value(
|
||
|
|
input,
|
||
|
|
/*rating*/
|
||
|
|
ctx[1]
|
||
|
|
);
|
||
|
|
if (!mounted) {
|
||
|
|
dispose = listen_dev(
|
||
|
|
input,
|
||
|
|
"input",
|
||
|
|
/*input_input_handler*/
|
||
|
|
ctx[4]
|
||
|
|
);
|
||
|
|
mounted = true;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
if (dirty & /*rating*/
|
||
|
|
2 && to_number(input.value) !== /*rating*/
|
||
|
|
ctx2[1]) {
|
||
|
|
set_input_value(
|
||
|
|
input,
|
||
|
|
/*rating*/
|
||
|
|
ctx2[1]
|
||
|
|
);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(t);
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(input);
|
||
|
|
mounted = false;
|
||
|
|
dispose();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot_1$1.name,
|
||
|
|
type: "slot",
|
||
|
|
source: '(3:4) <Field label=\\"thrust rating\\">',
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_default_slot$5(ctx) {
|
||
|
|
let div;
|
||
|
|
let field;
|
||
|
|
let t0;
|
||
|
|
let label;
|
||
|
|
let input;
|
||
|
|
let t1;
|
||
|
|
let current;
|
||
|
|
let mounted;
|
||
|
|
let dispose;
|
||
|
|
field = new Field({
|
||
|
|
props: {
|
||
|
|
label: "thrust rating",
|
||
|
|
$$slots: { default: [create_default_slot_1$1] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
div = element("div");
|
||
|
|
create_component(field.$$.fragment);
|
||
|
|
t0 = space();
|
||
|
|
label = element("label");
|
||
|
|
input = element("input");
|
||
|
|
t1 = text(" advanced");
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
div = claim_element(nodes, "DIV", { class: true });
|
||
|
|
var div_nodes = children(div);
|
||
|
|
claim_component(field.$$.fragment, div_nodes);
|
||
|
|
t0 = claim_space(div_nodes);
|
||
|
|
label = claim_element(div_nodes, "LABEL", { class: true });
|
||
|
|
var label_nodes = children(label);
|
||
|
|
input = claim_element(label_nodes, "INPUT", { type: true, class: true });
|
||
|
|
t1 = claim_text(label_nodes, " advanced");
|
||
|
|
label_nodes.forEach(detach_dev);
|
||
|
|
div_nodes.forEach(detach_dev);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(input, "type", "checkbox");
|
||
|
|
attr_dev(input, "class", "s-6wUMfpp2c9lR");
|
||
|
|
add_location(input, file$1, 14, 11, 249);
|
||
|
|
attr_dev(label, "class", "s-6wUMfpp2c9lR");
|
||
|
|
add_location(label, file$1, 14, 4, 242);
|
||
|
|
attr_dev(div, "class", "s-6wUMfpp2c9lR");
|
||
|
|
add_location(div, file$1, 1, 2, 23);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, div, anchor);
|
||
|
|
mount_component(field, div, null);
|
||
|
|
append_hydration_dev(div, t0);
|
||
|
|
append_hydration_dev(div, label);
|
||
|
|
append_hydration_dev(label, input);
|
||
|
|
input.checked = /*advanced*/
|
||
|
|
ctx[0];
|
||
|
|
append_hydration_dev(label, t1);
|
||
|
|
current = true;
|
||
|
|
if (!mounted) {
|
||
|
|
dispose = listen_dev(
|
||
|
|
input,
|
||
|
|
"change",
|
||
|
|
/*input_change_handler*/
|
||
|
|
ctx[5]
|
||
|
|
);
|
||
|
|
mounted = true;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
const field_changes = {};
|
||
|
|
if (dirty & /*$$scope, rating*/
|
||
|
|
66) {
|
||
|
|
field_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
field.$set(field_changes);
|
||
|
|
if (dirty & /*advanced*/
|
||
|
|
1) {
|
||
|
|
input.checked = /*advanced*/
|
||
|
|
ctx2[0];
|
||
|
|
}
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(field.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(field.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(div);
|
||
|
|
destroy_component(field);
|
||
|
|
mounted = false;
|
||
|
|
dispose();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot$5.name,
|
||
|
|
type: "slot",
|
||
|
|
source: "(1:0) <ShipItem {...reqs}>",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$5(ctx) {
|
||
|
|
let shipitem;
|
||
|
|
let current;
|
||
|
|
const shipitem_spread_levels = [
|
||
|
|
/*reqs*/
|
||
|
|
ctx[2]
|
||
|
|
];
|
||
|
|
let shipitem_props = {
|
||
|
|
$$slots: { default: [create_default_slot$5] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
};
|
||
|
|
for (let i = 0; i < shipitem_spread_levels.length; i += 1) {
|
||
|
|
shipitem_props = assign(shipitem_props, shipitem_spread_levels[i]);
|
||
|
|
}
|
||
|
|
shipitem = new ShipItem({ props: shipitem_props, $$inline: true });
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(shipitem.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(shipitem.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(shipitem, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const shipitem_changes = dirty & /*reqs*/
|
||
|
|
4 ? get_spread_update(shipitem_spread_levels, [get_spread_object(
|
||
|
|
/*reqs*/
|
||
|
|
ctx2[2]
|
||
|
|
)]) : {};
|
||
|
|
if (dirty & /*$$scope, advanced, rating*/
|
||
|
|
67) {
|
||
|
|
shipitem_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
shipitem.$set(shipitem_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(shipitem.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(shipitem.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(shipitem, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$5.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$5($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Engine", slots, []);
|
||
|
|
let { reqs = { cost: 0, mass: 0 } } = $$props;
|
||
|
|
let { advanced = false } = $$props;
|
||
|
|
let { rating = 0 } = $$props;
|
||
|
|
let { api = getContext("api") } = $$props;
|
||
|
|
const writable_props = ["reqs", "advanced", "rating", "api"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Engine> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
function input_input_handler() {
|
||
|
|
rating = to_number(this.value);
|
||
|
|
$$invalidate(1, rating);
|
||
|
|
}
|
||
|
|
function input_change_handler() {
|
||
|
|
advanced = this.checked;
|
||
|
|
$$invalidate(0, advanced);
|
||
|
|
}
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("reqs" in $$props2)
|
||
|
|
$$invalidate(2, reqs = $$props2.reqs);
|
||
|
|
if ("advanced" in $$props2)
|
||
|
|
$$invalidate(0, advanced = $$props2.advanced);
|
||
|
|
if ("rating" in $$props2)
|
||
|
|
$$invalidate(1, rating = $$props2.rating);
|
||
|
|
if ("api" in $$props2)
|
||
|
|
$$invalidate(3, api = $$props2.api);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({
|
||
|
|
getContext,
|
||
|
|
Field,
|
||
|
|
ShipItem,
|
||
|
|
reqs,
|
||
|
|
advanced,
|
||
|
|
rating,
|
||
|
|
api
|
||
|
|
});
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("reqs" in $$props2)
|
||
|
|
$$invalidate(2, reqs = $$props2.reqs);
|
||
|
|
if ("advanced" in $$props2)
|
||
|
|
$$invalidate(0, advanced = $$props2.advanced);
|
||
|
|
if ("rating" in $$props2)
|
||
|
|
$$invalidate(1, rating = $$props2.rating);
|
||
|
|
if ("api" in $$props2)
|
||
|
|
$$invalidate(3, api = $$props2.api);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
$$self.$$.update = () => {
|
||
|
|
var _a;
|
||
|
|
if ($$self.$$.dirty & /*api, rating, advanced*/
|
||
|
|
11) {
|
||
|
|
(_a = api == null ? void 0 : api.dispatch) == null ? void 0 : _a.setEngine({ rating, advanced });
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return [advanced, rating, reqs, api, input_input_handler, input_change_handler];
|
||
|
|
}
|
||
|
|
class Engine extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$5, create_fragment$5, safe_not_equal, { reqs: 2, advanced: 0, rating: 1, api: 3 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Engine",
|
||
|
|
options,
|
||
|
|
id: create_fragment$5.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get reqs() {
|
||
|
|
throw new Error("<Engine>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set reqs(value) {
|
||
|
|
throw new Error("<Engine>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get advanced() {
|
||
|
|
throw new Error("<Engine>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set advanced(value) {
|
||
|
|
throw new Error("<Engine>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get rating() {
|
||
|
|
throw new Error("<Engine>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set rating(value) {
|
||
|
|
throw new Error("<Engine>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get api() {
|
||
|
|
throw new Error("<Engine>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set api(value) {
|
||
|
|
throw new Error("<Engine>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const Ftl_svelte_svelte_type_style_lang = "";
|
||
|
|
const file = "src/lib/components/ShipEdit/Propulsion/Ftl.svelte";
|
||
|
|
function get_each_context(ctx, list, i) {
|
||
|
|
const child_ctx = ctx.slice();
|
||
|
|
child_ctx[6] = list[i];
|
||
|
|
return child_ctx;
|
||
|
|
}
|
||
|
|
function create_each_block(key_1, ctx) {
|
||
|
|
let label;
|
||
|
|
let input;
|
||
|
|
let t0;
|
||
|
|
let t1_value = (
|
||
|
|
/*t*/
|
||
|
|
ctx[6] + ""
|
||
|
|
);
|
||
|
|
let t1;
|
||
|
|
let t2;
|
||
|
|
let mounted;
|
||
|
|
let dispose;
|
||
|
|
const block = {
|
||
|
|
key: key_1,
|
||
|
|
first: null,
|
||
|
|
c: function create() {
|
||
|
|
label = element("label");
|
||
|
|
input = element("input");
|
||
|
|
t0 = space();
|
||
|
|
t1 = text(t1_value);
|
||
|
|
t2 = space();
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
label = claim_element(nodes, "LABEL", { class: true });
|
||
|
|
var label_nodes = children(label);
|
||
|
|
input = claim_element(label_nodes, "INPUT", { type: true });
|
||
|
|
t0 = claim_space(label_nodes);
|
||
|
|
t1 = claim_text(label_nodes, t1_value);
|
||
|
|
t2 = claim_space(label_nodes);
|
||
|
|
label_nodes.forEach(detach_dev);
|
||
|
|
this.h();
|
||
|
|
},
|
||
|
|
h: function hydrate() {
|
||
|
|
attr_dev(input, "type", "radio");
|
||
|
|
input.__value = /*t*/
|
||
|
|
ctx[6];
|
||
|
|
input.value = input.__value;
|
||
|
|
ctx[5][0].push(input);
|
||
|
|
add_location(input, file, 4, 9, 98);
|
||
|
|
attr_dev(label, "class", "s-bMEhkCgfZ263");
|
||
|
|
add_location(label, file, 3, 6, 82);
|
||
|
|
this.first = label;
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
insert_hydration_dev(target, label, anchor);
|
||
|
|
append_hydration_dev(label, input);
|
||
|
|
input.checked = input.__value === /*type*/
|
||
|
|
ctx[0];
|
||
|
|
append_hydration_dev(label, t0);
|
||
|
|
append_hydration_dev(label, t1);
|
||
|
|
append_hydration_dev(label, t2);
|
||
|
|
if (!mounted) {
|
||
|
|
dispose = listen_dev(
|
||
|
|
input,
|
||
|
|
"change",
|
||
|
|
/*input_change_handler*/
|
||
|
|
ctx[4]
|
||
|
|
);
|
||
|
|
mounted = true;
|
||
|
|
}
|
||
|
|
},
|
||
|
|
p: function update(new_ctx, dirty) {
|
||
|
|
ctx = new_ctx;
|
||
|
|
if (dirty & /*type*/
|
||
|
|
1) {
|
||
|
|
input.checked = input.__value === /*type*/
|
||
|
|
ctx[0];
|
||
|
|
}
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(label);
|
||
|
|
ctx[5][0].splice(
|
||
|
|
/*$$binding_groups*/
|
||
|
|
ctx[5][0].indexOf(input),
|
||
|
|
1
|
||
|
|
);
|
||
|
|
mounted = false;
|
||
|
|
dispose();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_each_block.name,
|
||
|
|
type: "each",
|
||
|
|
source: "(3:4) {#each types as t (t)}",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_default_slot_1(ctx) {
|
||
|
|
let each_blocks = [];
|
||
|
|
let each_1_lookup = /* @__PURE__ */ new Map();
|
||
|
|
let each_1_anchor;
|
||
|
|
let each_value = (
|
||
|
|
/*types*/
|
||
|
|
ctx[2]
|
||
|
|
);
|
||
|
|
validate_each_argument(each_value);
|
||
|
|
const get_key = (ctx2) => (
|
||
|
|
/*t*/
|
||
|
|
ctx2[6]
|
||
|
|
);
|
||
|
|
validate_each_keys(ctx, each_value, get_each_context, get_key);
|
||
|
|
for (let i = 0; i < each_value.length; i += 1) {
|
||
|
|
let child_ctx = get_each_context(ctx, each_value, i);
|
||
|
|
let key = get_key(child_ctx);
|
||
|
|
each_1_lookup.set(key, each_blocks[i] = create_each_block(key, child_ctx));
|
||
|
|
}
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
|
|
each_blocks[i].c();
|
||
|
|
}
|
||
|
|
each_1_anchor = empty();
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
|
|
each_blocks[i].l(nodes);
|
||
|
|
}
|
||
|
|
each_1_anchor = empty();
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
|
|
each_blocks[i].m(target, anchor);
|
||
|
|
}
|
||
|
|
insert_hydration_dev(target, each_1_anchor, anchor);
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
if (dirty & /*types, type*/
|
||
|
|
5) {
|
||
|
|
each_value = /*types*/
|
||
|
|
ctx2[2];
|
||
|
|
validate_each_argument(each_value);
|
||
|
|
validate_each_keys(ctx2, each_value, get_each_context, get_key);
|
||
|
|
each_blocks = update_keyed_each(each_blocks, dirty, get_key, 1, ctx2, each_value, each_1_lookup, each_1_anchor.parentNode, destroy_block, create_each_block, each_1_anchor, get_each_context);
|
||
|
|
}
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
for (let i = 0; i < each_blocks.length; i += 1) {
|
||
|
|
each_blocks[i].d(detaching);
|
||
|
|
}
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(each_1_anchor);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot_1.name,
|
||
|
|
type: "slot",
|
||
|
|
source: '(2:2) <Field label=\\"FTL drive\\">',
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_default_slot$4(ctx) {
|
||
|
|
let field;
|
||
|
|
let current;
|
||
|
|
field = new Field({
|
||
|
|
props: {
|
||
|
|
label: "FTL drive",
|
||
|
|
$$slots: { default: [create_default_slot_1] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(field.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(field.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(field, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
const field_changes = {};
|
||
|
|
if (dirty & /*$$scope, type*/
|
||
|
|
513) {
|
||
|
|
field_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
field.$set(field_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(field.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(field.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(field, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot$4.name,
|
||
|
|
type: "slot",
|
||
|
|
source: "(1:0) <ShipItem {...reqs}>",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$4(ctx) {
|
||
|
|
let shipitem;
|
||
|
|
let current;
|
||
|
|
const shipitem_spread_levels = [
|
||
|
|
/*reqs*/
|
||
|
|
ctx[1]
|
||
|
|
];
|
||
|
|
let shipitem_props = {
|
||
|
|
$$slots: { default: [create_default_slot$4] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
};
|
||
|
|
for (let i = 0; i < shipitem_spread_levels.length; i += 1) {
|
||
|
|
shipitem_props = assign(shipitem_props, shipitem_spread_levels[i]);
|
||
|
|
}
|
||
|
|
shipitem = new ShipItem({ props: shipitem_props, $$inline: true });
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(shipitem.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(shipitem.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(shipitem, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const shipitem_changes = dirty & /*reqs*/
|
||
|
|
2 ? get_spread_update(shipitem_spread_levels, [get_spread_object(
|
||
|
|
/*reqs*/
|
||
|
|
ctx2[1]
|
||
|
|
)]) : {};
|
||
|
|
if (dirty & /*$$scope, type*/
|
||
|
|
513) {
|
||
|
|
shipitem_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
shipitem.$set(shipitem_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(shipitem.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(shipitem.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(shipitem, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$4.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$4($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Ftl", slots, []);
|
||
|
|
let { type = "none" } = $$props;
|
||
|
|
let { reqs = { mass: 0, cost: 0 } } = $$props;
|
||
|
|
let { api = getContext("api") } = $$props;
|
||
|
|
const types = ["none", "standard", "advanced"];
|
||
|
|
const writable_props = ["type", "reqs", "api"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Ftl> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
const $$binding_groups = [[]];
|
||
|
|
function input_change_handler() {
|
||
|
|
type = this.__value;
|
||
|
|
$$invalidate(0, type);
|
||
|
|
}
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("type" in $$props2)
|
||
|
|
$$invalidate(0, type = $$props2.type);
|
||
|
|
if ("reqs" in $$props2)
|
||
|
|
$$invalidate(1, reqs = $$props2.reqs);
|
||
|
|
if ("api" in $$props2)
|
||
|
|
$$invalidate(3, api = $$props2.api);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({
|
||
|
|
getContext,
|
||
|
|
ShipItem,
|
||
|
|
Field,
|
||
|
|
type,
|
||
|
|
reqs,
|
||
|
|
api,
|
||
|
|
types
|
||
|
|
});
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("type" in $$props2)
|
||
|
|
$$invalidate(0, type = $$props2.type);
|
||
|
|
if ("reqs" in $$props2)
|
||
|
|
$$invalidate(1, reqs = $$props2.reqs);
|
||
|
|
if ("api" in $$props2)
|
||
|
|
$$invalidate(3, api = $$props2.api);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
$$self.$$.update = () => {
|
||
|
|
if ($$self.$$.dirty & /*api, type*/
|
||
|
|
9) {
|
||
|
|
api == null ? void 0 : api.dispatch.setFtl(type);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
return [type, reqs, types, api, input_change_handler, $$binding_groups];
|
||
|
|
}
|
||
|
|
class Ftl extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$4, create_fragment$4, safe_not_equal, { type: 0, reqs: 1, api: 3 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Ftl",
|
||
|
|
options,
|
||
|
|
id: create_fragment$4.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get type() {
|
||
|
|
throw new Error("<Ftl>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set type(value) {
|
||
|
|
throw new Error("<Ftl>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get reqs() {
|
||
|
|
throw new Error("<Ftl>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set reqs(value) {
|
||
|
|
throw new Error("<Ftl>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
get api() {
|
||
|
|
throw new Error("<Ftl>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set api(value) {
|
||
|
|
throw new Error("<Ftl>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function create_default_slot$3(ctx) {
|
||
|
|
let drive;
|
||
|
|
let t;
|
||
|
|
let ftl;
|
||
|
|
let current;
|
||
|
|
const drive_spread_levels = [
|
||
|
|
/*propulsion*/
|
||
|
|
ctx[0].drive
|
||
|
|
];
|
||
|
|
let drive_props = {};
|
||
|
|
for (let i = 0; i < drive_spread_levels.length; i += 1) {
|
||
|
|
drive_props = assign(drive_props, drive_spread_levels[i]);
|
||
|
|
}
|
||
|
|
drive = new Engine({ props: drive_props, $$inline: true });
|
||
|
|
const ftl_spread_levels = [
|
||
|
|
/*propulsion*/
|
||
|
|
ctx[0].ftl
|
||
|
|
];
|
||
|
|
let ftl_props = {};
|
||
|
|
for (let i = 0; i < ftl_spread_levels.length; i += 1) {
|
||
|
|
ftl_props = assign(ftl_props, ftl_spread_levels[i]);
|
||
|
|
}
|
||
|
|
ftl = new Ftl({ props: ftl_props, $$inline: true });
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(drive.$$.fragment);
|
||
|
|
t = space();
|
||
|
|
create_component(ftl.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(drive.$$.fragment, nodes);
|
||
|
|
t = claim_space(nodes);
|
||
|
|
claim_component(ftl.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(drive, target, anchor);
|
||
|
|
insert_hydration_dev(target, t, anchor);
|
||
|
|
mount_component(ftl, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, dirty) {
|
||
|
|
const drive_changes = dirty & /*propulsion*/
|
||
|
|
1 ? get_spread_update(drive_spread_levels, [get_spread_object(
|
||
|
|
/*propulsion*/
|
||
|
|
ctx2[0].drive
|
||
|
|
)]) : {};
|
||
|
|
drive.$set(drive_changes);
|
||
|
|
const ftl_changes = dirty & /*propulsion*/
|
||
|
|
1 ? get_spread_update(ftl_spread_levels, [get_spread_object(
|
||
|
|
/*propulsion*/
|
||
|
|
ctx2[0].ftl
|
||
|
|
)]) : {};
|
||
|
|
ftl.$set(ftl_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(drive.$$.fragment, local);
|
||
|
|
transition_in(ftl.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(drive.$$.fragment, local);
|
||
|
|
transition_out(ftl.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(drive, detaching);
|
||
|
|
if (detaching)
|
||
|
|
detach_dev(t);
|
||
|
|
destroy_component(ftl, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot$3.name,
|
||
|
|
type: "slot",
|
||
|
|
source: '(1:0) <Section label=\\"propulsion\\">',
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$3(ctx) {
|
||
|
|
let section;
|
||
|
|
let current;
|
||
|
|
section = new Section({
|
||
|
|
props: {
|
||
|
|
label: "propulsion",
|
||
|
|
$$slots: { default: [create_default_slot$3] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(section.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(section.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(section, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const section_changes = {};
|
||
|
|
if (dirty & /*$$scope, propulsion*/
|
||
|
|
3) {
|
||
|
|
section_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
section.$set(section_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(section.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(section.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(section, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$3.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$3($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Propulsion", slots, []);
|
||
|
|
let { propulsion = { drive: {}, ftl: {} } } = $$props;
|
||
|
|
const writable_props = ["propulsion"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Propulsion> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("propulsion" in $$props2)
|
||
|
|
$$invalidate(0, propulsion = $$props2.propulsion);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ Section, Drive: Engine, Ftl, propulsion });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("propulsion" in $$props2)
|
||
|
|
$$invalidate(0, propulsion = $$props2.propulsion);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [propulsion];
|
||
|
|
}
|
||
|
|
class Propulsion extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$3, create_fragment$3, safe_not_equal, { propulsion: 0 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Propulsion",
|
||
|
|
options,
|
||
|
|
id: create_fragment$3.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get propulsion() {
|
||
|
|
throw new Error("<Propulsion>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set propulsion(value) {
|
||
|
|
throw new Error("<Propulsion>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function create_default_slot$2(ctx) {
|
||
|
|
let propulsion;
|
||
|
|
let current;
|
||
|
|
propulsion = new Propulsion({ $$inline: true });
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(propulsion.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(propulsion.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(propulsion, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(propulsion.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(propulsion.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(propulsion, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot$2.name,
|
||
|
|
type: "slot",
|
||
|
|
source: "(1:0) <Hst.Story>",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$2(ctx) {
|
||
|
|
let hst_story;
|
||
|
|
let current;
|
||
|
|
hst_story = new /*Hst*/
|
||
|
|
ctx[0].Story({
|
||
|
|
props: {
|
||
|
|
$$slots: { default: [create_default_slot$2] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(hst_story.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(hst_story.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(hst_story, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const hst_story_changes = {};
|
||
|
|
if (dirty & /*$$scope*/
|
||
|
|
2) {
|
||
|
|
hst_story_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
hst_story.$set(hst_story_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(hst_story.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(hst_story.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(hst_story, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$2.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$2($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Propulsion_story", slots, []);
|
||
|
|
let { Hst } = $$props;
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (Hst === void 0 && !("Hst" in $$props || $$self.$$.bound[$$self.$$.props["Hst"]])) {
|
||
|
|
console.warn("<Propulsion_story> was created without expected prop 'Hst'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["Hst"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Propulsion_story> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ Hst, Propulsion });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [Hst];
|
||
|
|
}
|
||
|
|
class Propulsion_story extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$2, create_fragment$2, safe_not_equal, { Hst: 0 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Propulsion_story",
|
||
|
|
options,
|
||
|
|
id: create_fragment$2.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get Hst() {
|
||
|
|
throw new Error("<Propulsion_story>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set Hst(value) {
|
||
|
|
throw new Error("<Propulsion_story>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const GlobalStyle_svelte_svelte_type_style_lang = "";
|
||
|
|
function create_default_slot$1(ctx) {
|
||
|
|
let engine;
|
||
|
|
let current;
|
||
|
|
engine = new Engine({
|
||
|
|
props: { api: (
|
||
|
|
/*api*/
|
||
|
|
ctx[1]
|
||
|
|
) },
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(engine.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(engine.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(engine, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: noop,
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(engine.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(engine.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(engine, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot$1.name,
|
||
|
|
type: "slot",
|
||
|
|
source: '(1:0) <Hst.Story title=\\"ShipEdit/Propulsion/Engine\\">',
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment$1(ctx) {
|
||
|
|
let hst_story;
|
||
|
|
let current;
|
||
|
|
hst_story = new /*Hst*/
|
||
|
|
ctx[0].Story({
|
||
|
|
props: {
|
||
|
|
title: "ShipEdit/Propulsion/Engine",
|
||
|
|
$$slots: { default: [create_default_slot$1] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(hst_story.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(hst_story.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(hst_story, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const hst_story_changes = {};
|
||
|
|
if (dirty & /*$$scope*/
|
||
|
|
4) {
|
||
|
|
hst_story_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
hst_story.$set(hst_story_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(hst_story.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(hst_story.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(hst_story, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment$1.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance$1($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Engine_story", slots, []);
|
||
|
|
let { Hst } = $$props;
|
||
|
|
const api = {
|
||
|
|
dispatch: {
|
||
|
|
setEngine: (engine) => logEvent("setEngine", { engine })
|
||
|
|
}
|
||
|
|
};
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (Hst === void 0 && !("Hst" in $$props || $$self.$$.bound[$$self.$$.props["Hst"]])) {
|
||
|
|
console.warn("<Engine_story> was created without expected prop 'Hst'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["Hst"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Engine_story> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ Hst, logEvent, api, Engine });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [Hst, api];
|
||
|
|
}
|
||
|
|
class Engine_story extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance$1, create_fragment$1, safe_not_equal, { Hst: 0 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Engine_story",
|
||
|
|
options,
|
||
|
|
id: create_fragment$1.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get Hst() {
|
||
|
|
throw new Error("<Engine_story>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set Hst(value) {
|
||
|
|
throw new Error("<Engine_story>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function create_default_slot(ctx) {
|
||
|
|
let ftl;
|
||
|
|
let current;
|
||
|
|
ftl = new Ftl({
|
||
|
|
props: { api: (
|
||
|
|
/*api*/
|
||
|
|
ctx[1]
|
||
|
|
) },
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(ftl.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(ftl.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(ftl, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: noop,
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(ftl.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(ftl.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(ftl, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_default_slot.name,
|
||
|
|
type: "slot",
|
||
|
|
source: '(1:0) <Hst.Story title=\\"ShipEdit/Propulsion/Ftl\\">',
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function create_fragment(ctx) {
|
||
|
|
let hst_story;
|
||
|
|
let current;
|
||
|
|
hst_story = new /*Hst*/
|
||
|
|
ctx[0].Story({
|
||
|
|
props: {
|
||
|
|
title: "ShipEdit/Propulsion/Ftl",
|
||
|
|
$$slots: { default: [create_default_slot] },
|
||
|
|
$$scope: { ctx }
|
||
|
|
},
|
||
|
|
$$inline: true
|
||
|
|
});
|
||
|
|
const block = {
|
||
|
|
c: function create() {
|
||
|
|
create_component(hst_story.$$.fragment);
|
||
|
|
},
|
||
|
|
l: function claim(nodes) {
|
||
|
|
claim_component(hst_story.$$.fragment, nodes);
|
||
|
|
},
|
||
|
|
m: function mount(target, anchor) {
|
||
|
|
mount_component(hst_story, target, anchor);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
p: function update(ctx2, [dirty]) {
|
||
|
|
const hst_story_changes = {};
|
||
|
|
if (dirty & /*$$scope*/
|
||
|
|
4) {
|
||
|
|
hst_story_changes.$$scope = { dirty, ctx: ctx2 };
|
||
|
|
}
|
||
|
|
hst_story.$set(hst_story_changes);
|
||
|
|
},
|
||
|
|
i: function intro(local) {
|
||
|
|
if (current)
|
||
|
|
return;
|
||
|
|
transition_in(hst_story.$$.fragment, local);
|
||
|
|
current = true;
|
||
|
|
},
|
||
|
|
o: function outro(local) {
|
||
|
|
transition_out(hst_story.$$.fragment, local);
|
||
|
|
current = false;
|
||
|
|
},
|
||
|
|
d: function destroy(detaching) {
|
||
|
|
destroy_component(hst_story, detaching);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
dispatch_dev("SvelteRegisterBlock", {
|
||
|
|
block,
|
||
|
|
id: create_fragment.name,
|
||
|
|
type: "component",
|
||
|
|
source: "",
|
||
|
|
ctx
|
||
|
|
});
|
||
|
|
return block;
|
||
|
|
}
|
||
|
|
function instance($$self, $$props, $$invalidate) {
|
||
|
|
let { $$slots: slots = {}, $$scope } = $$props;
|
||
|
|
validate_slots("Ftl_story", slots, []);
|
||
|
|
let { Hst } = $$props;
|
||
|
|
const api = {
|
||
|
|
dispatch: {
|
||
|
|
setFtl: (ftl) => logEvent("setFtl", { ftl })
|
||
|
|
}
|
||
|
|
};
|
||
|
|
$$self.$$.on_mount.push(function() {
|
||
|
|
if (Hst === void 0 && !("Hst" in $$props || $$self.$$.bound[$$self.$$.props["Hst"]])) {
|
||
|
|
console.warn("<Ftl_story> was created without expected prop 'Hst'");
|
||
|
|
}
|
||
|
|
});
|
||
|
|
const writable_props = ["Hst"];
|
||
|
|
Object.keys($$props).forEach((key) => {
|
||
|
|
if (!~writable_props.indexOf(key) && key.slice(0, 2) !== "$$" && key !== "slot")
|
||
|
|
console.warn(`<Ftl_story> was created with unknown prop '${key}'`);
|
||
|
|
});
|
||
|
|
$$self.$$set = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
$$self.$capture_state = () => ({ Hst, logEvent, api, Ftl });
|
||
|
|
$$self.$inject_state = ($$props2) => {
|
||
|
|
if ("Hst" in $$props2)
|
||
|
|
$$invalidate(0, Hst = $$props2.Hst);
|
||
|
|
};
|
||
|
|
if ($$props && "$$inject" in $$props) {
|
||
|
|
$$self.$inject_state($$props.$$inject);
|
||
|
|
}
|
||
|
|
return [Hst, api];
|
||
|
|
}
|
||
|
|
class Ftl_story extends SvelteComponentDev {
|
||
|
|
constructor(options) {
|
||
|
|
super(options);
|
||
|
|
init(this, options, instance, create_fragment, safe_not_equal, { Hst: 0 });
|
||
|
|
dispatch_dev("SvelteRegisterComponent", {
|
||
|
|
component: this,
|
||
|
|
tagName: "Ftl_story",
|
||
|
|
options,
|
||
|
|
id: create_fragment.name
|
||
|
|
});
|
||
|
|
}
|
||
|
|
get Hst() {
|
||
|
|
throw new Error("<Ftl_story>: Props cannot be read directly from the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
set Hst(value) {
|
||
|
|
throw new Error("<Ftl_story>: Props cannot be set directly on the component instance unless compiling with 'accessors: true' or '<svelte:options accessors/>'");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
let files = [
|
||
|
|
{ "id": "src-lib-components-shipitem-story-svelte", "path": ["ShipItem"], "filePath": "src/lib/components/ShipItem.story.svelte", "story": { "id": "src-lib-components-shipitem-story-svelte", "title": "ShipItem", "group": null, "layout": { "type": "single", "iframe": true }, "icon": null, "iconColor": null, "docsOnly": false, "variants": [{ "id": "_default", "title": "default" }] }, "supportPluginId": "svelte3", "index": 0, component: ShipItem_story, source: () => __vitePreload(() => import("./__resolved__virtual_story-source_src-lib-components-shipitem-story-svelte-ec4622fc.js"), true ? [] : void 0) },
|
||
|
|
{ "id": "src-lib-components-costmass-index-story-svelte", "path": ["CostMass"], "filePath": "src/lib/components/CostMass/index.story.svelte", "story": { "id": "src-lib-components-costmass-index-story-svelte", "title": "CostMass", "group": null, "layout": { "type": "single", "iframe": true }, "icon": null, "iconColor": null, "docsOnly": false, "variants": [{ "id": "_default", "title": "default" }] }, "supportPluginId": "svelte3", "index": 1, component: CostMass_1, source: () => __vitePreload(() => import("./__resolved__virtual_story-source_src-lib-components-costmass-index-story-svelte-fa9c29ac.js"), true ? [] : void 0) },
|
||
|
|
{ "id": "src-lib-components-shipedit-propulsion-story-svelte", "path": ["Propulsion"], "filePath": "src/lib/components/ShipEdit/Propulsion.story.svelte", "story": { "id": "src-lib-components-shipedit-propulsion-story-svelte", "title": "Propulsion", "group": null, "layout": { "type": "single", "iframe": true }, "icon": null, "iconColor": null, "docsOnly": false, "variants": [{ "id": "_default", "title": "default" }] }, "supportPluginId": "svelte3", "index": 2, component: Propulsion_story, source: () => __vitePreload(() => import("./__resolved__virtual_story-source_src-lib-components-shipedit-propulsion-story-svelte-eabfe58a.js"), true ? [] : void 0) },
|
||
|
|
{ "id": "src-lib-components-shipedit-propulsion-engine-story-svelte", "path": ["ShipEdit", "Propulsion", "Engine"], "filePath": "src/lib/components/ShipEdit/Propulsion/Engine.story.svelte", "story": { "id": "src-lib-components-shipedit-propulsion-engine-story-svelte", "title": "Engine", "group": null, "layout": { "type": "single", "iframe": true }, "icon": null, "iconColor": null, "docsOnly": false, "variants": [{ "id": "_default", "title": "default" }] }, "supportPluginId": "svelte3", "index": 3, component: Engine_story, source: () => __vitePreload(() => import("./__resolved__virtual_story-source_src-lib-components-shipedit-propulsion-engine-story-svelte-42e8b729.js"), true ? [] : void 0) },
|
||
|
|
{ "id": "src-lib-components-shipedit-propulsion-ftl-story-svelte", "path": ["ShipEdit", "Propulsion", "Ftl"], "filePath": "src/lib/components/ShipEdit/Propulsion/Ftl.story.svelte", "story": { "id": "src-lib-components-shipedit-propulsion-ftl-story-svelte", "title": "Ftl", "group": null, "layout": { "type": "single", "iframe": true }, "icon": null, "iconColor": null, "docsOnly": false, "variants": [{ "id": "_default", "title": "default" }] }, "supportPluginId": "svelte3", "index": 4, component: Ftl_story, source: () => __vitePreload(() => import("./__resolved__virtual_story-source_src-lib-components-shipedit-propulsion-ftl-story-svelte-df90933e.js"), true ? [] : void 0) }
|
||
|
|
];
|
||
|
|
let tree = [{ "title": "CostMass", "index": 1 }, { "title": "Propulsion", "index": 2 }, { "title": "ShipEdit", "children": [{ "title": "Propulsion", "children": [{ "title": "Engine", "index": 3 }, { "title": "Ftl", "index": 4 }] }] }, { "title": "ShipItem", "index": 0 }];
|
||
|
|
const base = "/";
|
||
|
|
function createRouterHistory() {
|
||
|
|
switch (histoireConfig.routerMode) {
|
||
|
|
case "hash":
|
||
|
|
return createWebHashHistory(base);
|
||
|
|
case "history":
|
||
|
|
default:
|
||
|
|
return createWebHistory(base);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
const router = createRouter({
|
||
|
|
history: createRouterHistory(),
|
||
|
|
routes: [
|
||
|
|
{
|
||
|
|
path: "/",
|
||
|
|
name: "home",
|
||
|
|
component: () => __vitePreload(() => import("./HomeView.vue-2db017c5.js"), true ? ["assets/HomeView.vue-2db017c5.js","assets/vendor-3ab3e533.js"] : void 0)
|
||
|
|
},
|
||
|
|
{
|
||
|
|
path: "/story/:storyId",
|
||
|
|
name: "story",
|
||
|
|
component: () => __vitePreload(() => import("./StoryView.vue-e7ab65e8.js"), true ? ["assets/StoryView.vue-e7ab65e8.js","assets/vendor-3ab3e533.js","assets/story-804dabc9.js","assets/MobileOverlay.vue2-a3503848.js","assets/BaseEmpty.vue-045cbb89.js","assets/state-4b1a79d2.js","assets/events-ae5cec59.js"] : void 0)
|
||
|
|
}
|
||
|
|
]
|
||
|
|
});
|
||
|
|
const copiedFromExistingVariant = [
|
||
|
|
"state",
|
||
|
|
"slots",
|
||
|
|
"source",
|
||
|
|
"responsiveDisabled",
|
||
|
|
"autoPropsDisabled",
|
||
|
|
"setupApp",
|
||
|
|
"configReady",
|
||
|
|
"previewReady"
|
||
|
|
];
|
||
|
|
function mapFile(file2, existingFile) {
|
||
|
|
let result;
|
||
|
|
if (existingFile) {
|
||
|
|
result = existingFile;
|
||
|
|
for (const key in file2) {
|
||
|
|
if (key === "story") {
|
||
|
|
result.story = {
|
||
|
|
...result.story,
|
||
|
|
...file2.story,
|
||
|
|
file: markRaw(result),
|
||
|
|
variants: file2.story.variants.map((v) => mapVariant(v, existingFile.story.variants.find((item) => item.id === v.id)))
|
||
|
|
};
|
||
|
|
} else if (key !== "component") {
|
||
|
|
result[key] = file2[key];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
result = {
|
||
|
|
...file2,
|
||
|
|
component: markRaw(file2.component),
|
||
|
|
story: {
|
||
|
|
...file2.story,
|
||
|
|
title: file2.story.title,
|
||
|
|
file: markRaw(file2),
|
||
|
|
variants: file2.story.variants.map((v) => mapVariant(v)),
|
||
|
|
slots: () => ({})
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function mapVariant(variant, existingVariant) {
|
||
|
|
let result;
|
||
|
|
if (existingVariant) {
|
||
|
|
result = existingVariant;
|
||
|
|
for (const key in variant) {
|
||
|
|
if (!copiedFromExistingVariant.includes(key)) {
|
||
|
|
result[key] = variant[key];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
result = {
|
||
|
|
...variant,
|
||
|
|
state: reactive({
|
||
|
|
_hPropState: {},
|
||
|
|
_hPropDefs: {}
|
||
|
|
}),
|
||
|
|
setupApp: null,
|
||
|
|
slots: () => ({}),
|
||
|
|
previewReady: false
|
||
|
|
};
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
const clientSupportPlugins = {
|
||
|
|
"vanilla": () => __vitePreload(() => import("./vendor-3ab3e533.js").then((n) => n.bl), true ? [] : void 0),
|
||
|
|
"svelte3": () => __vitePreload(() => import("./vendor-3ab3e533.js").then((n) => n.bm), true ? [] : void 0)
|
||
|
|
};
|
||
|
|
const __default__ = {
|
||
|
|
inheritAttrs: false
|
||
|
|
};
|
||
|
|
const _sfc_main = /* @__PURE__ */ defineComponent({
|
||
|
|
...__default__,
|
||
|
|
__name: "GenericMountStory",
|
||
|
|
props: {
|
||
|
|
story: null
|
||
|
|
},
|
||
|
|
setup(__props) {
|
||
|
|
const props = __props;
|
||
|
|
const mountComponent = ref(null);
|
||
|
|
watchEffect(async () => {
|
||
|
|
var _a;
|
||
|
|
const clientPlugin = clientSupportPlugins[(_a = props.story.file) == null ? void 0 : _a.supportPluginId];
|
||
|
|
if (clientPlugin) {
|
||
|
|
const pluginModule = await clientPlugin();
|
||
|
|
mountComponent.value = markRaw(pluginModule.MountStory);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
return (_ctx, _cache) => {
|
||
|
|
return mountComponent.value ? (openBlock(), createBlock(resolveDynamicComponent(mountComponent.value), mergeProps({
|
||
|
|
key: 0,
|
||
|
|
class: "histoire-generic-mount-story",
|
||
|
|
story: __props.story
|
||
|
|
}, _ctx.$attrs), null, 16, ["story"])) : createCommentVNode("", true);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
});
|
||
|
|
export {
|
||
|
|
_sfc_main as _,
|
||
|
|
base as b,
|
||
|
|
clientSupportPlugins as c,
|
||
|
|
files as f,
|
||
|
|
mapFile as m,
|
||
|
|
router as r,
|
||
|
|
tree as t
|
||
|
|
};
|