@dineug/erd-editor 4.2.0 → 5.0.1

package/dist/r-html/dist/parser/html/index.js

@@ -0,0 +1,101 @@
+import { VNode, VNodeType } from "../vNode.js";
+import { tokenizer } from "./tokenizer.js";
+import { addAttr, addChild, isEmptyTag, isEmptyTagName, isEndCommentTag, isEndTag, isEqualToken, isGtToken, isLtToken, isSkipEndTag, isStartCommentTag, isStartTag, isStringToken, isWhiteSpaceToken } from "./helper.js";
+//#region ../r-html/dist/parser/html/index.js
+function parser(tokens) {
+	const ast = new VNode({
+		type: VNodeType.element,
+		value: "template",
+		children: []
+	});
+	let pos = 0;
+	const isToken = () => pos < tokens.length;
+	const startTag = isStartTag(tokens);
+	const endTag = isEndTag(tokens);
+	const skipEndTag = isSkipEndTag(tokens);
+	const emptyTag = isEmptyTag(tokens);
+	const startCommentTag = isStartCommentTag(tokens);
+	const endCommentTag = isEndCommentTag(tokens);
+	const ltToken = isLtToken(tokens);
+	const gtToken = isGtToken(tokens);
+	const equalToken = isEqualToken(tokens);
+	const whiteSpaceToken = isWhiteSpaceToken(tokens);
+	const stringToken = isStringToken(tokens);
+	const walkAttr = () => {
+		let token = tokens[pos];
+		const attr = { name: token.value };
+		token = tokens[++pos];
+		if (equalToken(pos)) {
+			token = tokens[++pos];
+			if (stringToken(pos)) {
+				attr.value = token.value;
+				pos++;
+			}
+		}
+		return attr;
+	};
+	const walkNode = (parent) => {
+		let token = tokens[pos];
+		if (whiteSpaceToken(pos) || stringToken(pos)) {
+			let value = token.value;
+			token = tokens[++pos];
+			while (isToken() && !ltToken(pos)) {
+				value += token.value;
+				token = tokens[++pos];
+			}
+			value = value.trim();
+			return value.length ? new VNode({
+				parent,
+				type: VNodeType.text,
+				value
+			}) : null;
+		}
+		if (startCommentTag(pos)) {
+			let value = "";
+			pos += 2;
+			token = tokens[pos];
+			while (isToken() && !endCommentTag(pos)) {
+				value += token.value;
+				token = tokens[++pos];
+			}
+			if (endCommentTag(pos)) pos += 2;
+			return new VNode({
+				parent,
+				type: VNodeType.comment,
+				value
+			});
+		}
+		if (startTag(pos)) {
+			token = tokens[++pos];
+			const hasEmptyTag = isEmptyTagName(token.value);
+			const node = new VNode({
+				parent,
+				type: VNodeType.element,
+				value: token.value.toLowerCase()
+			});
+			pos++;
+			while (isToken() && !gtToken(pos) && !emptyTag(pos)) {
+				if (stringToken(pos)) {
+					addAttr(node)(walkAttr());
+					continue;
+				}
+				pos++;
+			}
+			if (emptyTag(pos)) {
+				pos += 2;
+				return node;
+			}
+			token = tokens[++pos];
+			while (isToken() && !endTag(pos) && !skipEndTag(pos) && !hasEmptyTag) addChild(node)(walkNode(node));
+			if (endTag(pos) || skipEndTag(pos)) pos += 4;
+			return node;
+		}
+		pos++;
+		return null;
+	};
+	while (isToken()) addChild(ast)(walkNode(ast));
+	return ast;
+}
+var htmlParser = (source) => parser(tokenizer(source));
+//#endregion
+export { htmlParser, parser };

package/dist/r-html/dist/parser/html/tokenizer.js

@@ -0,0 +1,161 @@
+//#region ../r-html/dist/parser/html/tokenizer.js
+var TokenType = /* @__PURE__ */ function(TokenType) {
+	TokenType["string"] = "string";
+	TokenType["whiteSpace"] = "whiteSpace";
+	TokenType["lt"] = "lt";
+	TokenType["gt"] = "gt";
+	TokenType["slash"] = "slash";
+	TokenType["equal"] = "equal";
+	return TokenType;
+}({});
+var pattern = {
+	doubleQuote: `"`,
+	singleQuote: `'`,
+	whiteSpace: /\s/,
+	string: /\S/,
+	breakString: /<|>|=/,
+	lt: "<",
+	gt: ">",
+	slash: "/",
+	equal: "=",
+	hyphen: "-",
+	exclamationPoint: "!"
+};
+var createEqual = (type) => (char) => type === char;
+var createTest = (regexp) => (char) => regexp.test(char);
+var match = {
+	doubleQuote: createEqual(pattern.doubleQuote),
+	singleQuote: createEqual(pattern.singleQuote),
+	whiteSpace: createTest(pattern.whiteSpace),
+	string: createTest(pattern.string),
+	breakString: createTest(pattern.breakString),
+	lt: createEqual(pattern.lt),
+	gt: createEqual(pattern.gt),
+	slash: createEqual(pattern.slash),
+	equal: createEqual(pattern.equal),
+	hyphen: createEqual(pattern.hyphen),
+	exclamationPoint: createEqual(pattern.exclamationPoint)
+};
+var isStartCommentTag = (source) => (pos) => match.lt(source[pos]) && match.exclamationPoint(source[pos + 1]) && match.hyphen(source[pos + 2]) && match.hyphen(source[pos + 3]);
+function tokenizer(source) {
+	const tokens = [];
+	let pos = 0;
+	const isChar = () => pos < source.length;
+	const startCommentTag = isStartCommentTag(source);
+	const walk = (nodeType = "text") => {
+		while (isChar()) {
+			let char = source[pos];
+			if (match.whiteSpace(char)) {
+				let value = "";
+				while (isChar() && match.whiteSpace(char)) {
+					value += char;
+					char = source[++pos];
+				}
+				nodeType !== "element" && tokens.push({
+					type: "whiteSpace",
+					value
+				});
+				continue;
+			}
+			if (nodeType === "element") {
+				if (match.lt(char)) {
+					tokens.push({
+						type: "lt",
+						value: char
+					});
+					pos++;
+					continue;
+				}
+				if (match.gt(char)) {
+					tokens.push({
+						type: "gt",
+						value: char
+					});
+					pos++;
+					break;
+				}
+				if (match.slash(char)) {
+					tokens.push({
+						type: "slash",
+						value: char
+					});
+					pos++;
+					continue;
+				}
+				if (match.equal(char)) {
+					tokens.push({
+						type: "equal",
+						value: char
+					});
+					pos++;
+					continue;
+				}
+				if (match.doubleQuote(char)) {
+					let value = "";
+					char = source[++pos];
+					while (isChar() && !match.doubleQuote(char)) {
+						value += char;
+						char = source[++pos];
+					}
+					tokens.push({
+						type: "string",
+						value
+					});
+					pos++;
+					continue;
+				}
+				if (match.singleQuote(char)) {
+					let value = "";
+					char = source[++pos];
+					while (isChar() && !match.singleQuote(char)) {
+						value += char;
+						char = source[++pos];
+					}
+					tokens.push({
+						type: "string",
+						value
+					});
+					pos++;
+					continue;
+				}
+			} else if (nodeType === "comment") {
+				if (match.lt(char)) {
+					tokens.push({
+						type: "lt",
+						value: char
+					});
+					pos++;
+					continue;
+				}
+				if (match.gt(char)) {
+					tokens.push({
+						type: "gt",
+						value: char
+					});
+					pos++;
+					break;
+				}
+			} else if (match.lt(char)) {
+				walk(startCommentTag(pos) ? "comment" : "element");
+				continue;
+			}
+			if (match.string(char)) {
+				let value = "";
+				while (isChar() && match.string(char) && !match.breakString(char)) {
+					value += char;
+					char = source[++pos];
+				}
+				tokens.push({
+					type: "string",
+					value
+				});
+				continue;
+			}
+			pos++;
+		}
+	};
+	walk();
+	return tokens;
+}
+//#endregion
+export { TokenType, tokenizer };

package/dist/r-html/dist/parser/vNode.js

@@ -0,0 +1,32 @@
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js";
+//#region ../r-html/dist/parser/vNode.js
+var _Symbol$iterator;
+var VNodeType = /* @__PURE__ */ function(VNodeType) {
+	VNodeType["element"] = "element";
+	VNodeType["text"] = "text";
+	VNodeType["comment"] = "comment";
+	return VNodeType;
+}({});
+_Symbol$iterator = Symbol.iterator;
+var VNode = class {
+	constructor(node = {}) {
+		_defineProperty(this, "type", "comment");
+		_defineProperty(this, "value", "");
+		_defineProperty(this, "attrs", void 0);
+		_defineProperty(this, "parent", null);
+		_defineProperty(this, "children", void 0);
+		Object.assign(this, node);
+	}
+	*iterParent() {
+		yield this;
+		if (!this.parent) return;
+		yield* this.parent.iterParent();
+	}
+	*[_Symbol$iterator]() {
+		yield this;
+		if (!this.children) return;
+		for (const node of this.children) yield* node;
+	}
+};
+//#endregion
+export { VNode, VNodeType };

package/dist/r-html/dist/render/directives/attribute/ref.js

@@ -0,0 +1,18 @@
+import { createAttributeDirective } from "../attributeDirective.js";
+//#region ../r-html/dist/render/directives/attribute/ref.js
+var createRef = (value) => ({ value });
+var ref = createAttributeDirective((refObject) => refObject, ({ node }) => {
+	let prevRefObject = null;
+	const destroy = () => {
+		if (!prevRefObject) return;
+		prevRefObject.value = null;
+	};
+	return (refObject) => {
+		if (prevRefObject === refObject) return destroy;
+		refObject.value = node;
+		prevRefObject = refObject;
+		return destroy;
+	};
+});
+//#endregion
+export { createRef, ref };

package/dist/r-html/dist/render/directives/attributeDirective.js

@@ -0,0 +1,7 @@
+import { DirectiveType, createDirectiveTuple } from "./index.js";
+//#region ../r-html/dist/render/directives/attributeDirective.js
+function createAttributeDirective(f, directive) {
+	return (...args) => createDirectiveTuple(DirectiveType.attribute, [f(...args), directive]);
+}
+//#endregion
+export { createAttributeDirective };

package/dist/r-html/dist/render/directives/index.js

@@ -0,0 +1,13 @@
+import { DIRECTIVE } from "../../constants.js";
+//#region ../r-html/dist/render/directives/index.js
+var DirectiveType = /* @__PURE__ */ function(DirectiveType) {
+	DirectiveType["node"] = "node";
+	DirectiveType["attribute"] = "attribute";
+	return DirectiveType;
+}({});
+function createDirectiveTuple(type, tuple) {
+	Reflect.set(tuple, DIRECTIVE, type);
+	return tuple;
+}
+//#endregion
+export { DirectiveType, createDirectiveTuple };

package/dist/r-html/dist/render/directives/node/cache.js

@@ -0,0 +1,56 @@
+import { createNodeDirective } from "../nodeDirective.js";
+import { isTemplateLiterals } from "../../../template/helper.js";
+import { domHelper } from "../../helper.js";
+import { createPart, getPartType } from "../../part/node/text/helper.js";
+//#region ../r-html/dist/render/directives/node/cache.js
+var cache = createNodeDirective((value) => value, ({ startNode, endNode, helper = domHelper }) => {
+	const rootNode = helper.getRoot(startNode);
+	let cache = /* @__PURE__ */ new Map();
+	let prevValue = null;
+	const getKey = (value) => {
+		return isTemplateLiterals(value) ? value.strings : value;
+	};
+	const getPart = (value) => {
+		const key = getKey(value);
+		return cache.has(key) ? cache.get(key) : null;
+	};
+	const setPart = (value, cachePart) => {
+		cache.set(getKey(value), cachePart);
+	};
+	const create = (value) => {
+		const type = getPartType(value);
+		const part = createPart(type, startNode, endNode, helper);
+		const fragment = helper.createFragment();
+		const unbridge = helper.bridgeFragment(fragment, rootNode);
+		return {
+			part,
+			fragment,
+			destroy: () => {
+				unbridge();
+				part.destroy?.();
+			}
+		};
+	};
+	const destroy = () => {
+		cache.forEach(({ destroy }) => destroy());
+		cache = /* @__PURE__ */ new Map();
+		helper.removeRange(startNode, endNode);
+	};
+	return (value) => {
+		const currentCachePart = getPart(prevValue);
+		const oldCachePart = getPart(value);
+		if (currentCachePart && getKey(prevValue) !== getKey(value)) helper.rangeNodes(startNode, endNode).forEach((node) => helper.appendChild(currentCachePart.fragment, node));
+		if (oldCachePart) {
+			if (getKey(prevValue) !== getKey(value)) helper.insertBeforeNode(oldCachePart.fragment, endNode);
+			oldCachePart.part.commit(value);
+		} else {
+			const newCachePart = create(value);
+			setPart(value, newCachePart);
+			newCachePart.part.commit(value);
+		}
+		prevValue = value;
+		return destroy;
+	};
+});
+//#endregion
+export { cache };

package/dist/r-html/dist/render/directives/node/innerHTML.js

@@ -0,0 +1,20 @@
+import { createNodeDirective } from "../nodeDirective.js";
+import { insertBeforeNode, removeRange } from "../../helper.js";
+//#region ../r-html/dist/render/directives/node/innerHTML.js
+var innerHTML = createNodeDirective((value) => value, ({ startNode, endNode }) => {
+	let prevValue = null;
+	const destroy = () => {
+		removeRange(startNode, endNode);
+	};
+	return (value) => {
+		if (prevValue === value) return destroy;
+		destroy();
+		const template = document.createElement("template");
+		template.innerHTML = value;
+		insertBeforeNode(template.content, endNode);
+		prevValue = value;
+		return destroy;
+	};
+});
+//#endregion
+export { innerHTML };

package/dist/r-html/dist/render/directives/node/repeat.js

@@ -0,0 +1,124 @@
+import _classPrivateFieldInitSpec from "../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldInitSpec.js";
+import _classPrivateFieldSet2 from "../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldSet2.js";
+import _classPrivateFieldGet2 from "../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/classPrivateFieldGet2.js";
+import { createNodeDirective } from "../nodeDirective.js";
+import _defineProperty from "../../../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js";
+import { domHelper } from "../../helper.js";
+import { Action, difference } from "../../part/node/text/arrayDiff.js";
+import { createPart, getPartType } from "../../part/node/text/helper.js";
+//#region ../r-html/dist/render/directives/node/repeat.js
+var repeat = createNodeDirective((list, getKey, getResult) => {
+	list.length;
+	return [
+		list,
+		getKey,
+		getResult
+	];
+}, ({ startNode, endNode, helper = domHelper }) => {
+	let parts = [];
+	const destroy = () => {
+		parts.forEach((part) => part.destroy());
+	};
+	return ([list, getKey, getResult]) => {
+		const newDiffValue = valuesToDiffItems(list, getKey, getResult);
+		const values = newDiffValue.values;
+		const diff = difference(partsToDiffItems(parts), newDiffValue, { strict: true });
+		const arrayLike = { length: values.length };
+		diff.update.forEach(({ action, from, to }) => {
+			switch (action) {
+				case Action.create:
+					const node = helper.createMarker("");
+					to === 0 ? helper.insertAfterNode(node, startNode) : parts.length ? helper.insertAfterNode(node, arrayLike[to - 1] ? arrayLike[to - 1].endNode : parts[to - 1].endNode) : helper.insertBeforeNode(node, endNode);
+					arrayLike[to] = new ItemPart(node, values[to].value, values[to].key, helper);
+					break;
+				case Action.move:
+					arrayLike[to] = parts[from];
+					if (to === from) return;
+					to === 0 ? parts[from].insert("after", startNode) : parts[from].insert("after", arrayLike[to - 1] ? arrayLike[to - 1].endNode : parts[to - 1].endNode);
+			}
+		});
+		diff.delete.forEach(({ from }) => parts[from].destroy());
+		parts = Array.from(arrayLike);
+		parts.forEach((part, index) => part.commit(values[index].value));
+		return destroy;
+	};
+});
+var _part = /* @__PURE__ */ new WeakMap();
+var _helper = /* @__PURE__ */ new WeakMap();
+var ItemPart = class {
+	constructor(node, value, key, helper = domHelper) {
+		_classPrivateFieldInitSpec(this, _part, void 0);
+		_classPrivateFieldInitSpec(this, _helper, void 0);
+		_defineProperty(this, "startNode", void 0);
+		_defineProperty(this, "endNode", void 0);
+		_defineProperty(this, "type", void 0);
+		_defineProperty(this, "key", void 0);
+		_classPrivateFieldSet2(_helper, this, helper);
+		this.startNode = helper.createMarker("");
+		this.endNode = helper.createMarker("");
+		helper.insertBeforeNode(this.startNode, node);
+		helper.insertAfterNode(this.endNode, node);
+		helper.removeNode(node);
+		this.key = key;
+		this.type = getPartType(value);
+		_classPrivateFieldSet2(_part, this, createPart(this.type, this.startNode, this.endNode, helper));
+	}
+	commit(value) {
+		_classPrivateFieldGet2(_part, this).commit(value);
+	}
+	insert(position, refChild) {
+		const nodes = [
+			this.startNode,
+			..._classPrivateFieldGet2(_helper, this).rangeNodes(this.startNode, this.endNode),
+			this.endNode
+		];
+		position === "before" ? nodes.forEach((node) => _classPrivateFieldGet2(_helper, this).insertBeforeNode(node, refChild)) : nodes.reverse().forEach((node) => _classPrivateFieldGet2(_helper, this).insertAfterNode(node, refChild));
+	}
+	destroy() {
+		_classPrivateFieldGet2(_part, this).destroy?.();
+		_classPrivateFieldGet2(_helper, this).removeRange(this.startNode, this.endNode);
+		_classPrivateFieldGet2(_helper, this).removeNode(this.startNode);
+		_classPrivateFieldGet2(_helper, this).removeNode(this.endNode);
+	}
+};
+function partsToDiffItems(parts) {
+	const items = [];
+	const itemToIndex = /* @__PURE__ */ new Map();
+	parts.forEach(({ type, key }, index) => {
+		const item = {
+			type,
+			key
+		};
+		items.push(item);
+		itemToIndex.set(item, index);
+	});
+	return {
+		items,
+		itemToIndex
+	};
+}
+function valuesToDiffItems(list, getKey, getResult) {
+	const items = [];
+	const itemToIndex = /* @__PURE__ */ new Map();
+	const values = [];
+	list.forEach((value, index, array) => {
+		const newValue = {
+			key: getKey(value),
+			value: getResult(value, index, array)
+		};
+		const item = {
+			type: getPartType(newValue.value),
+			key: newValue.key
+		};
+		values.push(newValue);
+		items.push(item);
+		itemToIndex.set(item, index);
+	});
+	return {
+		items,
+		itemToIndex,
+		values
+	};
+}
+//#endregion
+export { repeat };

package/dist/r-html/dist/render/directives/nodeDirective.js

@@ -0,0 +1,15 @@
+import { DirectiveType, createDirectiveTuple } from "./index.js";
+//#region ../r-html/dist/render/directives/nodeDirective.js
+function createNodeDirectiveProps(startNode, endNode, helper) {
+	const props = {
+		startNode,
+		endNode
+	};
+	Reflect.defineProperty(props, "helper", { value: helper });
+	return props;
+}
+function createNodeDirective(f, directive) {
+	return (...args) => createDirectiveTuple(DirectiveType.node, [f(...args), directive]);
+}
+//#endregion
+export { createNodeDirective, createNodeDirectiveProps };

package/dist/r-html/dist/render/domAdapter.js

@@ -0,0 +1,74 @@
+import { fragmentContextBridge } from "../context/createContext.js";
+import { fragmentHostBridge, getFragmentHost } from "./host.js";
+import { safeToString } from "./value.js";
+//#region ../r-html/dist/render/domAdapter.js
+var domAdapter = {
+	createElement: (name, isSvg = false) => isSvg ? document.createElementNS("http://www.w3.org/2000/svg", name) : document.createElement(name),
+	createText: (value) => document.createTextNode(value),
+	createMarker: (value) => document.createComment(value),
+	createFragment: () => document.createDocumentFragment(),
+	createEventBus: () => document.createElement("div"),
+	insertBefore(newChild, refChild) {
+		const parent = refChild.parentNode;
+		if (!parent) return;
+		parent.insertBefore(newChild, refChild);
+	},
+	appendChild(parent, newChild) {
+		parent.appendChild(newChild);
+	},
+	prependChild(parent, newChild) {
+		parent.prepend(newChild);
+	},
+	removeChild(node) {
+		node.parentNode?.removeChild(node);
+	},
+	parentOf: (node) => node.parentNode,
+	nextSiblingOf: (node) => node.nextSibling,
+	setText(node, value) {
+		node.data = value;
+	},
+	setAttribute(node, name, value, isSingleMarker) {
+		node.setAttribute(name, isSingleMarker ? safeToString(value).trim() : value);
+	},
+	removeAttribute(node, name) {
+		node.removeAttribute(name);
+	},
+	isHostNode: (value) => value instanceof Node,
+	isMarker: (value) => value instanceof Comment,
+	isText: (value) => value instanceof Text,
+	isElement: (value) => value instanceof Element,
+	isFragment: (value) => value instanceof DocumentFragment,
+	addEventListener(node, type, listener, options) {
+		node.addEventListener(type, listener, options);
+	},
+	removeEventListener(node, type, listener, options) {
+		node.removeEventListener(type, listener, options);
+	},
+	getRoot: (node) => node.getRootNode(),
+	createComponentContext(startNode, eventBus) {
+		const ctx = {
+			host: document.body,
+			get parentElement() {
+				return startNode.parentElement;
+			},
+			dispatchEvent: (event) => eventBus.dispatchEvent(event)
+		};
+		const rootNode = startNode.getRootNode();
+		if (rootNode instanceof ShadowRoot) ctx.host = rootNode.host;
+		else if (rootNode instanceof DocumentFragment) {
+			const host = getFragmentHost(rootNode);
+			if (host) ctx.host = host;
+		}
+		return ctx;
+	},
+	bridgeFragment(fragment, root) {
+		const contextBridgeDestroy = fragmentContextBridge(fragment, root);
+		const hostBridgeDestroy = fragmentHostBridge(fragment, root);
+		return () => {
+			contextBridgeDestroy();
+			hostBridgeDestroy();
+		};
+	}
+};
+//#endregion
+export { domAdapter };