@realsee/dnalogel 2.0.0-alpha.1 → 2.0.0-alpha.10

package/libs/floorplan/Components/RoomMaterials/RoomMaterial.js

@@ -0,0 +1,328 @@
+/* generated by Svelte v3.47.0 */
+import {
+	SvelteComponent,
+	append_styles,
+	attr,
+	check_outros,
+	create_component,
+	destroy_component,
+	destroy_each,
+	detach,
+	element,
+	group_outros,
+	init,
+	insert,
+	mount_component,
+	safe_not_equal,
+	svg_element,
+	transition_in,
+	transition_out
+} from "svelte/internal";
+
+import formatFloorplanPoint from '../../utils/formatPosition';
+import RoomMaterial_0 from './RoomMaterial_0';
+import RoomMaterial_1 from './RoomMaterial_1';
+import RoomMaterial_2 from './RoomMaterial_2';
+
+function add_css(target) {
+	append_styles(target, "svelte-1b0icjc", "svg.svelte-1b0icjc{position:absolute;width:100%;height:100%;overflow:visible}");
+}
+
+function get_each_context(ctx, list, i) {
+	const child_ctx = ctx.slice();
+	child_ctx[4] = list[i];
+	return child_ctx;
+}
+
+// (21:6) {:else}
+function create_else_block(ctx) {
+	let roommaterial_1;
+	let current;
+	roommaterial_1 = new RoomMaterial_1({ props: { path: /*room*/ ctx[4].path } });
+
+	return {
+		c() {
+			create_component(roommaterial_1.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component(roommaterial_1, target, anchor);
+			current = true;
+		},
+		p(ctx, dirty) {
+			const roommaterial_1_changes = {};
+			if (dirty & /*rooms*/ 1) roommaterial_1_changes.path = /*room*/ ctx[4].path;
+			roommaterial_1.$set(roommaterial_1_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(roommaterial_1.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(roommaterial_1.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component(roommaterial_1, detaching);
+		}
+	};
+}
+
+// (19:37) 
+function create_if_block_1(ctx) {
+	let roommaterial_2;
+	let current;
+	roommaterial_2 = new RoomMaterial_2({ props: { path: /*room*/ ctx[4].path } });
+
+	return {
+		c() {
+			create_component(roommaterial_2.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component(roommaterial_2, target, anchor);
+			current = true;
+		},
+		p(ctx, dirty) {
+			const roommaterial_2_changes = {};
+			if (dirty & /*rooms*/ 1) roommaterial_2_changes.path = /*room*/ ctx[4].path;
+			roommaterial_2.$set(roommaterial_2_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(roommaterial_2.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(roommaterial_2.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component(roommaterial_2, detaching);
+		}
+	};
+}
+
+// (17:6) {#if room.floorType === 1}
+function create_if_block(ctx) {
+	let roommaterial_0;
+	let current;
+	roommaterial_0 = new RoomMaterial_0({ props: { path: /*room*/ ctx[4].path } });
+
+	return {
+		c() {
+			create_component(roommaterial_0.$$.fragment);
+		},
+		m(target, anchor) {
+			mount_component(roommaterial_0, target, anchor);
+			current = true;
+		},
+		p(ctx, dirty) {
+			const roommaterial_0_changes = {};
+			if (dirty & /*rooms*/ 1) roommaterial_0_changes.path = /*room*/ ctx[4].path;
+			roommaterial_0.$set(roommaterial_0_changes);
+		},
+		i(local) {
+			if (current) return;
+			transition_in(roommaterial_0.$$.fragment, local);
+			current = true;
+		},
+		o(local) {
+			transition_out(roommaterial_0.$$.fragment, local);
+			current = false;
+		},
+		d(detaching) {
+			destroy_component(roommaterial_0, detaching);
+		}
+	};
+}
+
+// (15:2) {#each rooms as room}
+function create_each_block(ctx) {
+	let svg;
+	let current_block_type_index;
+	let if_block;
+	let current;
+	const if_block_creators = [create_if_block, create_if_block_1, create_else_block];
+	const if_blocks = [];
+
+	function select_block_type(ctx, dirty) {
+		if (/*room*/ ctx[4].floorType === 1) return 0;
+		if (/*room*/ ctx[4].floorType === 0) return 1;
+		return 2;
+	}
+
+	current_block_type_index = select_block_type(ctx, -1);
+	if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+
+	return {
+		c() {
+			svg = svg_element("svg");
+			if_block.c();
+			attr(svg, "class", "svelte-1b0icjc");
+		},
+		m(target, anchor) {
+			insert(target, svg, anchor);
+			if_blocks[current_block_type_index].m(svg, null);
+			current = true;
+		},
+		p(ctx, dirty) {
+			let previous_block_index = current_block_type_index;
+			current_block_type_index = select_block_type(ctx, dirty);
+
+			if (current_block_type_index === previous_block_index) {
+				if_blocks[current_block_type_index].p(ctx, dirty);
+			} else {
+				group_outros();
+
+				transition_out(if_blocks[previous_block_index], 1, 1, () => {
+					if_blocks[previous_block_index] = null;
+				});
+
+				check_outros();
+				if_block = if_blocks[current_block_type_index];
+
+				if (!if_block) {
+					if_block = if_blocks[current_block_type_index] = if_block_creators[current_block_type_index](ctx);
+					if_block.c();
+				} else {
+					if_block.p(ctx, dirty);
+				}
+
+				transition_in(if_block, 1);
+				if_block.m(svg, null);
+			}
+		},
+		i(local) {
+			if (current) return;
+			transition_in(if_block);
+			current = true;
+		},
+		o(local) {
+			transition_out(if_block);
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(svg);
+			if_blocks[current_block_type_index].d();
+		}
+	};
+}
+
+function create_fragment(ctx) {
+	let div;
+	let current;
+	let each_value = /*rooms*/ ctx[0];
+	let each_blocks = [];
+
+	for (let i = 0; i < each_value.length; i += 1) {
+		each_blocks[i] = create_each_block(get_each_context(ctx, each_value, i));
+	}
+
+	const out = i => transition_out(each_blocks[i], 1, 1, () => {
+		each_blocks[i] = null;
+	});
+
+	return {
+		c() {
+			div = element("div");
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].c();
+			}
+
+			attr(div, "class", "floorplan-plugin__room-material");
+		},
+		m(target, anchor) {
+			insert(target, div, anchor);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				each_blocks[i].m(div, null);
+			}
+
+			current = true;
+		},
+		p(ctx, [dirty]) {
+			if (dirty & /*rooms*/ 1) {
+				each_value = /*rooms*/ ctx[0];
+				let i;
+
+				for (i = 0; i < each_value.length; i += 1) {
+					const child_ctx = get_each_context(ctx, each_value, i);
+
+					if (each_blocks[i]) {
+						each_blocks[i].p(child_ctx, dirty);
+						transition_in(each_blocks[i], 1);
+					} else {
+						each_blocks[i] = create_each_block(child_ctx);
+						each_blocks[i].c();
+						transition_in(each_blocks[i], 1);
+						each_blocks[i].m(div, null);
+					}
+				}
+
+				group_outros();
+
+				for (i = each_value.length; i < each_blocks.length; i += 1) {
+					out(i);
+				}
+
+				check_outros();
+			}
+		},
+		i(local) {
+			if (current) return;
+
+			for (let i = 0; i < each_value.length; i += 1) {
+				transition_in(each_blocks[i]);
+			}
+
+			current = true;
+		},
+		o(local) {
+			each_blocks = each_blocks.filter(Boolean);
+
+			for (let i = 0; i < each_blocks.length; i += 1) {
+				transition_out(each_blocks[i]);
+			}
+
+			current = false;
+		},
+		d(detaching) {
+			if (detaching) detach(div);
+			destroy_each(each_blocks, detaching);
+		}
+	};
+}
+
+function instance($$self, $$props, $$invalidate) {
+	let rooms;
+	let { floorIndex } = $$props;
+	let { pxmm } = $$props;
+	let { floorplanData } = $$props;
+
+	$$self.$$set = $$props => {
+		if ('floorIndex' in $$props) $$invalidate(1, floorIndex = $$props.floorIndex);
+		if ('pxmm' in $$props) $$invalidate(2, pxmm = $$props.pxmm);
+		if ('floorplanData' in $$props) $$invalidate(3, floorplanData = $$props.floorplanData);
+	};
+
+	$$self.$$.update = () => {
+		if ($$self.$$.dirty & /*floorplanData, floorIndex, pxmm*/ 14) {
+			$: $$invalidate(0, rooms = floorplanData.floorDatas[floorIndex].rooms.map(room => ({
+				...room,
+				path: room.path.map(p => formatFloorplanPoint(p, pxmm, floorplanData.bounding))
+			})));
+		}
+	};
+
+	return [rooms, floorIndex, pxmm, floorplanData];
+}
+
+class Component extends SvelteComponent {
+	constructor(options) {
+		super();
+		init(this, options, instance, create_fragment, safe_not_equal, { floorIndex: 1, pxmm: 2, floorplanData: 3 }, add_css);
+	}
+}
+
+export default Component;

package/libs/floorplan/Components/RoomMaterials/RoomMaterial_0.js

@@ -0,0 +1,64 @@
+/* generated by Svelte v3.47.0 */
+import {
+	SvelteComponent,
+	attr,
+	detach,
+	init,
+	insert,
+	noop,
+	safe_not_equal,
+	svg_element
+} from "svelte/internal";
+
+import { pathD } from '../../utils/formatPosition';
+
+function create_fragment(ctx) {
+	let path_1;
+
+	return {
+		c() {
+			path_1 = svg_element("path");
+			attr(path_1, "d", /*d*/ ctx[0]);
+			attr(path_1, "fill", "#2F313A");
+		},
+		m(target, anchor) {
+			insert(target, path_1, anchor);
+		},
+		p(ctx, [dirty]) {
+			if (dirty & /*d*/ 1) {
+				attr(path_1, "d", /*d*/ ctx[0]);
+			}
+		},
+		i: noop,
+		o: noop,
+		d(detaching) {
+			if (detaching) detach(path_1);
+		}
+	};
+}
+
+function instance($$self, $$props, $$invalidate) {
+	let d;
+	let { path } = $$props;
+
+	$$self.$$set = $$props => {
+		if ('path' in $$props) $$invalidate(1, path = $$props.path);
+	};
+
+	$$self.$$.update = () => {
+		if ($$self.$$.dirty & /*path*/ 2) {
+			$: $$invalidate(0, d = pathD(path, { needZ: true }));
+		}
+	};
+
+	return [d, path];
+}
+
+class Component extends SvelteComponent {
+	constructor(options) {
+		super();
+		init(this, options, instance, create_fragment, safe_not_equal, { path: 1 });
+	}
+}
+
+export default Component;

package/libs/floorplan/Components/RoomMaterials/RoomMaterial_1.js

@@ -0,0 +1,103 @@
+/* generated by Svelte v3.47.0 */
+import {
+	SvelteComponent,
+	append,
+	attr,
+	detach,
+	init,
+	insert,
+	noop,
+	safe_not_equal,
+	space,
+	svg_element
+} from "svelte/internal";
+
+import { pathD } from '../../utils/formatPosition';
+
+function create_fragment(ctx) {
+	let defs;
+	let pattern;
+	let rect;
+	let path0;
+	let t;
+	let path1;
+
+	return {
+		c() {
+			defs = svg_element("defs");
+			pattern = svg_element("pattern");
+			rect = svg_element("rect");
+			path0 = svg_element("path");
+			t = space();
+			path1 = svg_element("path");
+			attr(rect, "x", "0");
+			attr(rect, "y", "0");
+			attr(rect, "width", /*width*/ ctx[1]);
+			attr(rect, "height", /*width*/ ctx[1]);
+			attr(rect, "fill", "#323747");
+			attr(path0, "d", /*patternPathD*/ ctx[2]);
+			attr(path0, "stroke", "#ffffff");
+			attr(path0, "stroke-opacity", "0.06");
+			attr(path0, "stroke-width", "0.5");
+			attr(path0, "fill", "none");
+			attr(pattern, "id", "fpm-room-pattern-0");
+			attr(pattern, "x", "0");
+			attr(pattern, "y", "0");
+			attr(pattern, "width", /*width*/ ctx[1]);
+			attr(pattern, "height", /*width*/ ctx[1]);
+			attr(pattern, "patternUnits", "userSpaceOnUse");
+			attr(path1, "d", /*d*/ ctx[0]);
+			attr(path1, "fill", "url(#fpm-room-pattern-0)");
+		},
+		m(target, anchor) {
+			insert(target, defs, anchor);
+			append(defs, pattern);
+			append(pattern, rect);
+			append(pattern, path0);
+			insert(target, t, anchor);
+			insert(target, path1, anchor);
+		},
+		p(ctx, [dirty]) {
+			if (dirty & /*d*/ 1) {
+				attr(path1, "d", /*d*/ ctx[0]);
+			}
+		},
+		i: noop,
+		o: noop,
+		d(detaching) {
+			if (detaching) detach(defs);
+			if (detaching) detach(t);
+			if (detaching) detach(path1);
+		}
+	};
+}
+
+const halfWidth = 6;
+
+function instance($$self, $$props, $$invalidate) {
+	let d;
+	let { path } = $$props;
+	const width = halfWidth * 2;
+	const patternPathD = `M0 ${halfWidth} h ${width} M${halfWidth} 0 v ${width}`;
+
+	$$self.$$set = $$props => {
+		if ('path' in $$props) $$invalidate(3, path = $$props.path);
+	};
+
+	$$self.$$.update = () => {
+		if ($$self.$$.dirty & /*path*/ 8) {
+			$: $$invalidate(0, d = pathD(path, { needZ: true }));
+		}
+	};
+
+	return [d, width, patternPathD, path];
+}
+
+class Component extends SvelteComponent {
+	constructor(options) {
+		super();
+		init(this, options, instance, create_fragment, safe_not_equal, { path: 3 });
+	}
+}
+
+export default Component;

package/libs/floorplan/Components/RoomMaterials/RoomMaterial_2.js

@@ -0,0 +1,140 @@
+/* generated by Svelte v3.47.0 */
+import {
+	SvelteComponent,
+	append,
+	attr,
+	detach,
+	init,
+	insert,
+	noop,
+	safe_not_equal,
+	space,
+	svg_element
+} from "svelte/internal";
+
+import { pathD } from '../../utils/formatPosition';
+
+function create_fragment(ctx) {
+	let defs;
+	let pattern0;
+	let rect0;
+	let pattern1;
+	let rect1;
+	let t0;
+	let path0;
+	let t1;
+	let path1;
+	let t2;
+	let path2;
+
+	return {
+		c() {
+			defs = svg_element("defs");
+			pattern0 = svg_element("pattern");
+			rect0 = svg_element("rect");
+			pattern1 = svg_element("pattern");
+			rect1 = svg_element("rect");
+			t0 = space();
+			path0 = svg_element("path");
+			t1 = space();
+			path1 = svg_element("path");
+			t2 = space();
+			path2 = svg_element("path");
+			attr(rect0, "x", "0.5");
+			attr(rect0, "y", "0.5");
+			attr(rect0, "width", "6");
+			attr(rect0, "height", "50");
+			attr(rect0, "fill", "none");
+			attr(rect0, "stroke", "#4B4B57");
+			attr(rect0, "stroke-width", "0.5");
+			attr(pattern0, "id", "room-material-pattern-1");
+			attr(pattern0, "x", "0");
+			attr(pattern0, "y", "0");
+			attr(pattern0, "width", "13");
+			attr(pattern0, "height", "51");
+			attr(pattern0, "patternUnits", "userSpaceOnUse");
+			attr(rect1, "x", "0.5");
+			attr(rect1, "y", "0.5");
+			attr(rect1, "width", "6");
+			attr(rect1, "height", "50");
+			attr(rect1, "fill", "none");
+			attr(rect1, "stroke", "#4B4B57");
+			attr(rect1, "stroke-width", "0.5");
+			attr(pattern1, "id", "room-material-pattern-2");
+			attr(pattern1, "x", "7");
+			attr(pattern1, "y", "25");
+			attr(pattern1, "width", "13");
+			attr(pattern1, "height", "51");
+			attr(pattern1, "patternUnits", "userSpaceOnUse");
+			attr(path0, "d", /*d*/ ctx[0]);
+			attr(path0, "fill", "#43434D");
+			attr(path1, "d", /*d*/ ctx[0]);
+			attr(path1, "fill", "url(#room-material-pattern-1)");
+			attr(path2, "d", /*d*/ ctx[0]);
+			attr(path2, "fill", "url(#room-material-pattern-2)");
+		},
+		m(target, anchor) {
+			insert(target, defs, anchor);
+			append(defs, pattern0);
+			append(pattern0, rect0);
+			append(defs, pattern1);
+			append(pattern1, rect1);
+			insert(target, t0, anchor);
+			insert(target, path0, anchor);
+			insert(target, t1, anchor);
+			insert(target, path1, anchor);
+			insert(target, t2, anchor);
+			insert(target, path2, anchor);
+		},
+		p(ctx, [dirty]) {
+			if (dirty & /*d*/ 1) {
+				attr(path0, "d", /*d*/ ctx[0]);
+			}
+
+			if (dirty & /*d*/ 1) {
+				attr(path1, "d", /*d*/ ctx[0]);
+			}
+
+			if (dirty & /*d*/ 1) {
+				attr(path2, "d", /*d*/ ctx[0]);
+			}
+		},
+		i: noop,
+		o: noop,
+		d(detaching) {
+			if (detaching) detach(defs);
+			if (detaching) detach(t0);
+			if (detaching) detach(path0);
+			if (detaching) detach(t1);
+			if (detaching) detach(path1);
+			if (detaching) detach(t2);
+			if (detaching) detach(path2);
+		}
+	};
+}
+
+function instance($$self, $$props, $$invalidate) {
+	let d;
+	let { path } = $$props;
+
+	$$self.$$set = $$props => {
+		if ('path' in $$props) $$invalidate(1, path = $$props.path);
+	};
+
+	$$self.$$.update = () => {
+		if ($$self.$$.dirty & /*path*/ 2) {
+			$: $$invalidate(0, d = pathD(path, { needZ: true }));
+		}
+	};
+
+	return [d, path];
+}
+
+class Component extends SvelteComponent {
+	constructor(options) {
+		super();
+		init(this, options, instance, create_fragment, safe_not_equal, { path: 1 });
+	}
+}
+
+export default Component;

package/libs/floorplan/Components/SvgImage.js

@@ -0,0 +1,83 @@
+/* generated by Svelte v3.47.0 */
+import {
+	HtmlTag,
+	SvelteComponent,
+	append,
+	append_styles,
+	attr,
+	detach,
+	element,
+	init,
+	insert,
+	noop,
+	safe_not_equal,
+	space
+} from "svelte/internal";
+
+function add_css(target) {
+	append_styles(target, "svelte-1qqy56u", ".floorplan-plugin__base-image.svelte-1qqy56u{width:100%;height:100%}");
+}
+
+function create_fragment(ctx) {
+	let div;
+	let html_tag;
+	let t;
+	let html_tag_1;
+
+	return {
+		c() {
+			div = element("div");
+			html_tag = new HtmlTag();
+			t = space();
+			html_tag_1 = new HtmlTag();
+			html_tag.a = t;
+			html_tag_1.a = null;
+			attr(div, "class", "floorplan-plugin__base-image svelte-1qqy56u");
+		},
+		m(target, anchor) {
+			insert(target, div, anchor);
+			html_tag.m(/*svgStyle*/ ctx[1], div);
+			append(div, t);
+			html_tag_1.m(/*content*/ ctx[0], div);
+		},
+		p(ctx, [dirty]) {
+			if (dirty & /*content*/ 1) html_tag_1.p(/*content*/ ctx[0]);
+		},
+		i: noop,
+		o: noop,
+		d(detaching) {
+			if (detaching) detach(div);
+		}
+	};
+}
+
+function instance($$self, $$props, $$invalidate) {
+	let { content } = $$props;
+
+	const svgStyle = `
+    <style>
+      svg [type='lineGroup'] path {
+        fill: #ffffff;
+        stroke: #ffffff;
+      }
+      svg [type='lineItemGroup'] g g g g {
+        stroke: #ffffff;
+      }
+    </style>
+  `;
+
+	$$self.$$set = $$props => {
+		if ('content' in $$props) $$invalidate(0, content = $$props.content);
+	};
+
+	return [content, svgStyle];
+}
+
+class Component extends SvelteComponent {
+	constructor(options) {
+		super();
+		init(this, options, instance, create_fragment, safe_not_equal, { content: 0 }, add_css);
+	}
+}
+
+export default Component;