squarified 0.3.7 → 0.4.0

package/dist/plugin.js

@@ -0,0 +1,399 @@
+"use strict";
+const require_dom_event = require('./dom-event-BPqG0KO2.js');
+
+//#region src/plugins/highlight.ts
+var Highlight = class extends require_dom_event.Schedule {
+	reset() {
+		this.destory();
+		this.update();
+	}
+	get canvas() {
+		return this.render.canvas;
+	}
+	setZIndexForHighlight(zIndex = "-1") {
+		this.canvas.style.zIndex = zIndex;
+	}
+	init() {
+		this.setZIndexForHighlight();
+		this.canvas.style.position = "absolute";
+		this.canvas.style.pointerEvents = "none";
+	}
+};
+const ANIMATION_DURATION = 300;
+const HIGH_LIGHT_OPACITY = .3;
+const fill = {
+	desc: {
+		r: 255,
+		g: 255,
+		b: 255
+	},
+	mode: "rgb"
+};
+const presetHighlightPlugin = require_dom_event.definePlugin({
+	name: "treemap:preset-highlight",
+	onLoad() {
+		const meta = this.getPluginMetadata("treemap:preset-highlight");
+		if (!meta) return;
+		if (!meta.highlight) meta.highlight = new Highlight(this.instance.to);
+	},
+	onDOMEventTriggered(name, _, module$1, { stateManager: state, matrix }) {
+		if (name === "mousemove") {
+			if (state.canTransition("MOVE")) {
+				const meta = this.getPluginMetadata("treemap:preset-highlight");
+				if (!module$1) {
+					meta.highlight?.reset();
+					meta.highlight?.update();
+					meta.highlight?.setZIndexForHighlight();
+					return;
+				}
+				const [x, y, w, h] = module$1.layout;
+				const effectiveRadius = Math.min(module$1.config.rectRadius, w / 4, h / 4);
+				require_dom_event.smoothFrame((_$1, cleanup) => {
+					cleanup();
+					meta.highlight?.reset();
+					const mask = require_dom_event.createRoundBlock(x, y, w, h, {
+						fill,
+						opacity: HIGH_LIGHT_OPACITY,
+						radius: effectiveRadius,
+						padding: 0
+					});
+					meta.highlight?.add(mask);
+					meta.highlight?.setZIndexForHighlight("1");
+					require_dom_event.stackMatrixTransform(mask, matrix.e, matrix.f, matrix.a);
+					meta.highlight?.update();
+				}, { duration: ANIMATION_DURATION });
+			}
+		}
+	},
+	onResize() {
+		const meta = this.getPluginMetadata("treemap:preset-highlight");
+		if (!meta) return;
+		meta.highlight?.render.initOptions({ ...this.instance.render.options });
+		meta.highlight?.reset();
+		meta.highlight?.init();
+	},
+	onDispose() {
+		const meta = this.getPluginMetadata("treemap:preset-highlight");
+		if (meta && meta.highlight) {
+			meta.highlight.destory();
+			meta.highlight = null;
+		}
+	},
+	meta: { highlight: null }
+});
+
+//#endregion
+//#region src/plugins/drag.ts
+const presetDragElementPlugin = require_dom_event.definePlugin({
+	name: "treemap:preset-drag-element",
+	onDOMEventTriggered(name, event, module$1, domEvent) {
+		const { stateManager: state, matrix, component } = domEvent;
+		switch (name) {
+			case "mousemove": {
+				if (state.isInState("DRAGGING")) domEvent.silent("click");
+				else domEvent.active("click");
+				const meta = getDragOptions.call(this);
+				if (!meta) return;
+				if (meta.dragOptions.x === 0 && meta.dragOptions.y === 0) {
+					state.transition("IDLE");
+					return;
+				}
+				state.transition("DRAGGING");
+				if (state.isInState("DRAGGING")) {
+					const highlight = getHighlightInstance.call(this);
+					require_dom_event.smoothFrame((_, cleanup) => {
+						cleanup();
+						const { offsetX, offsetY } = event.native;
+						const drawX = offsetX - meta.dragOptions.x;
+						const drawY = offsetY - meta.dragOptions.y;
+						const lastX = meta.dragOptions.x;
+						const lastY = meta.dragOptions.y;
+						if (highlight?.highlight) {
+							highlight.highlight.reset();
+							highlight.highlight.setZIndexForHighlight();
+						}
+						matrix.translation(drawX, drawY);
+						meta.dragOptions.x = offsetX;
+						meta.dragOptions.y = offsetY;
+						meta.dragOptions.lastX = lastX;
+						meta.dragOptions.lastY = lastY;
+						component.cleanup();
+						component.draw(false, false);
+						require_dom_event.stackMatrixTransformWithGraphAndLayer(component.elements, matrix.e, matrix.f, matrix.a);
+						component.update();
+						return true;
+					}, {
+						duration: ANIMATION_DURATION,
+						deps: [() => state.isInState("IDLE")]
+					});
+				}
+				break;
+			}
+			case "mouseup": {
+				if (state.isInState("PRESSED")) {
+					const meta = getDragOptions.call(this);
+					if (meta && meta.dragOptions) {
+						if (meta.dragOptions.x === meta.dragOptions.lastX && meta.dragOptions.y === meta.dragOptions.lastY) {
+							state.transition("IDLE");
+							return;
+						}
+					}
+				}
+				if (state.isInState("DRAGGING") && state.canTransition("IDLE")) {
+					const highlight = getHighlightInstance.call(this);
+					if (highlight && highlight.highlight) {
+						highlight.highlight.reset();
+						highlight.highlight.setZIndexForHighlight();
+					}
+					const meta = getDragOptions.call(this);
+					if (meta && meta.dragOptions) {
+						meta.dragOptions.x = 0;
+						meta.dragOptions.y = 0;
+						meta.dragOptions.lastX = 0;
+						meta.dragOptions.lastY = 0;
+						state.transition("IDLE");
+					}
+				}
+				break;
+			}
+			case "mousedown": {
+				if (require_dom_event.isScrollWheelOrRightButtonOnMouseupAndDown(event.native)) return;
+				const meta = getDragOptions.call(this);
+				if (!meta) return;
+				meta.dragOptions.x = event.native.offsetX;
+				meta.dragOptions.y = event.native.offsetY;
+				meta.dragOptions.lastX = event.native.offsetX;
+				meta.dragOptions.lastY = event.native.offsetY;
+				state.transition("PRESSED");
+				break;
+			}
+		}
+	},
+	meta: { dragOptions: {
+		x: 0,
+		y: 0,
+		lastX: 0,
+		lastY: 0
+	} },
+	onResize({ matrix, stateManager: state }) {
+		matrix.create(require_dom_event.DEFAULT_MATRIX_LOC);
+		state.reset();
+	}
+});
+function getHighlightInstance() {
+	return this.getPluginMetadata("treemap:preset-highlight");
+}
+function getDragOptions() {
+	const meta = this.getPluginMetadata("treemap:preset-drag-element");
+	return meta;
+}
+
+//#endregion
+//#region src/plugins/preset-color.ts
+const presetColorPlugin = require_dom_event.definePlugin({
+	name: "treemap:preset-color",
+	onModuleInit(modules) {
+		const colorMappings = {};
+		for (let i = 0; i < modules.length; i++) {
+			const module$1 = modules[i];
+			assignColorMappings(colorMappings, module$1, Math.abs(require_dom_event.hashCode(module$1.node.id)) % require_dom_event.PI_2, 0);
+		}
+		return { colorMappings };
+	}
+});
+function assignColorMappings(colorMappings, module$1, ancestorHue, depth) {
+	const hueOffset = Math.abs(require_dom_event.hashCode(module$1.node.id)) % 60 - 30;
+	const hue = (ancestorHue + hueOffset) % 360;
+	const saturation = Math.max(75 - depth * 5, 40);
+	const baseLightness = 55 - depth * 3;
+	const color = adjustColorToComfortableForHumanEye(hue, saturation, baseLightness);
+	colorMappings[module$1.node.id] = color;
+	if (module$1.node.isCombinedNode && module$1.node.originalNodes) for (const combined of module$1.node.originalNodes) colorMappings[combined.id] = color;
+	if (module$1.children && module$1.children.length) {
+		const childCount = module$1.children.length;
+		for (let i = 0; i < childCount; i++) {
+			const childHueOffset = 40 * i / childCount;
+			const childHue = (hue + childHueOffset) % 360;
+			assignColorMappings(colorMappings, module$1.children[i], childHue, depth + 1);
+		}
+	}
+}
+function adjustColorToComfortableForHumanEye(hue, saturation, lightness) {
+	hue = (hue % 360 + 360) % 360;
+	saturation = Math.min(Math.max(saturation, 40), 85);
+	lightness = Math.min(Math.max(lightness, 35), 75);
+	if (hue >= 60 && hue <= 180) {
+		saturation = Math.max(saturation - 10, 40);
+		lightness = Math.min(lightness + 5, 75);
+	} else if (hue >= 200 && hue <= 280) lightness = Math.min(lightness + 8, 75);
+	else if (hue >= 0 && hue <= 30) saturation = Math.max(saturation - 5, 40);
+	return {
+		mode: "hsl",
+		desc: {
+			h: hue,
+			s: saturation,
+			l: lightness
+		}
+	};
+}
+
+//#endregion
+//#region src/plugins/wheel.ts
+function presetScalePlugin(options) {
+	return require_dom_event.definePlugin({
+		name: "treemap:preset-scale",
+		onDOMEventTriggered(_, event, module$1, evt) {
+			if (require_dom_event.isWheelEvent(event)) onWheel(this, event, evt);
+		},
+		meta: { scaleOptions: {
+			scale: 1,
+			minScale: options?.min || .1,
+			maxScale: options?.max || Infinity,
+			scaleFactor: .05
+		} },
+		onResize({ matrix, stateManager: state }) {
+			const meta = getScaleOptions.call(this);
+			if (meta) meta.scaleOptions.scale = 1;
+			matrix.create(require_dom_event.DEFAULT_MATRIX_LOC);
+			state.reset();
+		}
+	});
+}
+function getScaleOptions() {
+	const meta = this.getPluginMetadata("treemap:preset-scale");
+	return meta;
+}
+function onWheel(pluginContext, event, { stateManager: state, component, matrix }) {
+	event.native.preventDefault();
+	const meta = getScaleOptions.call(pluginContext);
+	if (!meta) return;
+	const { scale, minScale, maxScale, scaleFactor } = meta.scaleOptions;
+	const delta = event.native.deltaY < 0 ? scaleFactor : -scaleFactor;
+	const newScale = Math.max(minScale, Math.min(maxScale, scale + delta));
+	if (newScale === scale) return;
+	state.transition("SCALING");
+	const mouseX = event.native.offsetX;
+	const mouseY = event.native.offsetY;
+	const scaleDiff = newScale / scale;
+	meta.scaleOptions.scale = newScale;
+	const highlight = getHighlightInstance.apply(pluginContext);
+	require_dom_event.smoothFrame((_, cleanup) => {
+		cleanup();
+		if (highlight && highlight.highlight) {
+			highlight.highlight.reset();
+			highlight.highlight.setZIndexForHighlight();
+		}
+		matrix.scale(scaleDiff, scaleDiff);
+		matrix.e = mouseX - (mouseX - matrix.e) * scaleDiff;
+		matrix.f = mouseY - (mouseY - matrix.f) * scaleDiff;
+		component.cleanup();
+		const { width, height } = component.render.options;
+		component.layoutNodes = component.calculateLayoutNodes(component.data, {
+			w: width,
+			h: height,
+			x: 0,
+			y: 0
+		}, matrix.a);
+		component.draw(true, false);
+		require_dom_event.stackMatrixTransformWithGraphAndLayer(component.elements, matrix.e, matrix.f, newScale);
+		component.update();
+		if (state.canTransition("IDLE")) state.transition("IDLE");
+		return true;
+	}, { duration: ANIMATION_DURATION });
+}
+
+//#endregion
+//#region src/plugins/zoomable.ts
+const MAX_SCALE_MULTIPLIER = 2;
+const presetZoomablePlugin = require_dom_event.definePlugin({
+	name: "treemap:preset-zoomable",
+	onLoad(treemap, { stateManager: state, matrix }) {
+		return require_dom_event.mixinWithParams(treemap, [{
+			name: "zoom",
+			fn: () => (id) => {
+				const meta = this.getPluginMetadata("treemap:preset-zoomable");
+				if (!meta || state.isInState("ZOOMING")) return;
+				const targetModule = this.resolveModuleById(id);
+				if (!targetModule) return;
+				meta.previousMatrixState = {
+					e: matrix.e,
+					f: matrix.f,
+					a: matrix.a,
+					d: matrix.d
+				};
+				const component = this.instance;
+				state.transition("ZOOMING");
+				const [nodeX, nodeY, nodeW, nodeH] = targetModule.layout;
+				const { width, height } = component.render.options;
+				const currentScale = matrix.a;
+				const scaleX = width / nodeW;
+				const scaleY = height / nodeH;
+				const fullScale = Math.min(scaleX, scaleY) * .9;
+				const targetScale = Math.min(fullScale, currentScale * MAX_SCALE_MULTIPLIER);
+				const scale = targetScale;
+				const nodeCenterX = nodeX + nodeW / 2;
+				const nodeCenterY = nodeY + nodeH / 2;
+				const viewCenterX = width / 2;
+				const viewCenterY = height / 2;
+				const targetE = viewCenterX - nodeCenterX * scale;
+				const targetF = viewCenterY - nodeCenterY * scale;
+				const scaleMeta = getScaleOptions.call(this);
+				if (scaleMeta) scaleMeta.scaleOptions.scale = scale;
+				const highlight = getHighlightInstance.call(this);
+				const dragMeta = getDragOptions.call(this);
+				if (dragMeta) {
+					dragMeta.dragOptions.x = 0;
+					dragMeta.dragOptions.y = 0;
+					dragMeta.dragOptions.lastX = 0;
+					dragMeta.dragOptions.lastY = 0;
+				}
+				const startMatrix = {
+					e: matrix.e,
+					f: matrix.f,
+					a: matrix.a,
+					d: matrix.d
+				};
+				require_dom_event.smoothFrame((progress) => {
+					const easedProgress = require_dom_event.easing.cubicInOut(progress);
+					const currentE = startMatrix.e + (targetE - startMatrix.e) * easedProgress;
+					const currentF = startMatrix.f + (targetF - startMatrix.f) * easedProgress;
+					const currentA = startMatrix.a + (scale - startMatrix.a) * easedProgress;
+					const currentD = startMatrix.d + (scale - startMatrix.d) * easedProgress;
+					matrix.create(require_dom_event.DEFAULT_MATRIX_LOC);
+					matrix.e = currentE;
+					matrix.f = currentF;
+					matrix.a = currentA;
+					matrix.d = currentD;
+					if (highlight?.highlight) {
+						highlight.highlight.reset();
+						highlight.highlight.setZIndexForHighlight();
+					}
+					component.cleanup();
+					const { width: width$1, height: height$1 } = component.render.options;
+					component.layoutNodes = component.calculateLayoutNodes(component.data, {
+						w: width$1,
+						h: height$1,
+						x: 0,
+						y: 0
+					}, matrix.a);
+					component.draw(true, false);
+					require_dom_event.stackMatrixTransformWithGraphAndLayer(component.elements, matrix.e, matrix.f, matrix.a);
+					component.update();
+				}, {
+					duration: ANIMATION_DURATION,
+					onStop: () => {
+						state.reset();
+					}
+				});
+			}
+		}]);
+	},
+	meta: { isZooming: false }
+});
+
+//#endregion
+exports.presetColorPlugin = presetColorPlugin
+exports.presetDragElementPlugin = presetDragElementPlugin
+exports.presetHighlightPlugin = presetHighlightPlugin
+exports.presetScalePlugin = presetScalePlugin
+exports.presetZoomablePlugin = presetZoomablePlugin