@mapsight/vector-style-compiler 8.0.3 → 10.0.0

package/src/js/rulesToTree.ts

@@ -1,83 +0,0 @@
-import deepExtend from "@mapsight/lib-js/object/deep-extend";
-
-import type {Rules} from "./cssToRules.ts";
-import type {DeclarationNode} from "./cssToRules/mapDeclaration.ts";
-import type {Check} from "./cssToRules/mapSelectorPart.ts";
-
-export type TreeLeaf = {
-	declarations?: DeclarationNode;
-	children: Child[];
-	stylePropExpressions?: Array<string>;
-};
-
-export type Child = {
-	conditions: Array<Array<Check>>;
-	declarations?: DeclarationNode;
-	stylePropExpressions?: Array<string>;
-};
-
-export type Tree = {
-	[style: string]: {
-		[state: string]: TreeLeaf;
-	};
-};
-
-export default function rulesToTree(rules: Rules["rules"]) {
-	const tree: Tree = {};
-
-	rules.forEach((rule) => {
-		const ruleTree: Record<
-			string,
-			Record<string, Array<Array<Check>>>
-		> = {};
-
-		rule.conditions.forEach((condition) => {
-			const style = condition.style || "default";
-			const state = condition.state || "default";
-
-			ruleTree[style] ??= {};
-			ruleTree[style][state] ??= [];
-
-			if (condition.checks) {
-				ruleTree[style][state].push(condition.checks);
-			}
-		});
-
-		Object.keys(ruleTree).forEach((style) => {
-			const sub = ruleTree[style];
-			if (!sub) {
-				return;
-			}
-
-			const styleTree = tree[style] || {};
-			Object.keys(sub).forEach((state) => {
-				const stateTree: Tree[string][string] = styleTree[state] ?? {
-					children: [],
-				};
-
-				const conditions = sub[state];
-				if (conditions?.length) {
-					stateTree.children.push({
-						conditions: conditions,
-						declarations: rule.declarations,
-						stylePropExpressions: rule.__meta.stylePropExpressions,
-					});
-					return;
-				}
-				stateTree.stylePropExpressions = (
-					stateTree.stylePropExpressions || []
-				).concat(rule.__meta.stylePropExpressions);
-
-				stateTree.declarations = deepExtend(
-					stateTree.declarations || {},
-					rule.declarations,
-				);
-
-				styleTree[state] = stateTree;
-			});
-			tree[style] = styleTree;
-		});
-	});
-
-	return tree;
-}

package/src/js/template.source.js

@@ -1,56 +0,0 @@
-import get from "@mapsight/lib-js/object/getPath";
-import replace from "@mapsight/lib-js/string/replaceRegex";
-import createCachedStyleFunction from "@mapsight/lib-ol/style/createCachedStyleFunction";
-/* styleImports-start: */
-import __vectorStyle_circle from "ol/style/Circle";
-
-/* :styleImports-end */
-
-/** @type {(value: unknown) => string} */
-const createHash = /* @__PURE__ */ (value) =>
-	/* @__PURE__ */ JSON.stringify(value);
-/** @type {import('@mapsight/lib-ol/style/createCachedStyleFunction').StyleFunctionOptions} */
-const styleOptions = {
-	constructorsMap: /* constructorMap-start: */ {
-		circle: __vectorStyle_circle,
-	} /* :constructorMap-end */,
-	allowedStyles: /* styleNames-start: */ [] /* :styleNames-end */,
-	allowedProps: /* styleProps-start: */ ["test"] /* :styleProps-end */,
-	declarationHashFunction: (env, props, hashPrefix, geometryType, style) => {
-		/** @type {Array<string|number>} */
-		const hash = [hashPrefix, geometryType];
-		// noinspection UnnecessaryLocalVariableJS
-		/** @type {(a: string|number) => void} */
-		const h = (a) => {
-			hash.push(a);
-		};
-
-		/* program1-start: */
-		h(1);
-		h("@" + createHash(style));
-		h("@" + createHash(props["test"]));
-		h("@" + createHash(env["test"]));
-		h("@" + createHash(get(props, ["path", "to", "test"])));
-		/* :program1-end */
-
-		return hash.join("|");
-	},
-	declarationFunction: (env, props, geometryType, style) => {
-		/** @type {Record<string, unknown>} */
-		const d = {};
-
-		/* program2-start: */
-		d.zIndex = 1;
-		d.calcTest = {value: "" + replace("a", "e", "hallo") + ""};
-		d.a = env.a;
-		d.b = props.b;
-		d.geometryType = geometryType;
-		d.style = style;
-		d.test = "foo";
-		/* :program2-end */
-
-		return d;
-	},
-};
-
-export default createCachedStyleFunction(styleOptions);

package/src/js/template.ts

@@ -1,50 +0,0 @@
-import {readFileSync} from "node:fs";
-import {resolve} from "node:path";
-
-import createModulesMapFromDependencies from "./helpers/createModulesMapFromDependencies.ts";
-
-export type TemplateArgs<
-	TAdditionalData extends Record<string, unknown> = Record<string, unknown>,
-> = TAdditionalData & {
-	__meta: {
-		styleNames: string[];
-		stateNames: string[];
-		groupNames: string[];
-		declarationNames: string[];
-		styleProps: string[];
-		stylePropExpressions: string[];
-	};
-	program1: string;
-	program2: string;
-};
-export type Template<
-	TAdditionalData extends Record<string, unknown> = Record<string, unknown>,
-> = (args: TemplateArgs<TAdditionalData>) => string;
-
-const templateSource = readFileSync(
-	resolve(import.meta.dirname, "template.source.js"),
-	"utf8",
-);
-
-const replaceTag = (content: string, tag: string, value: string) => {
-	const pattern = `\\/\\*\\s*${tag}-start:\\s*\\*\\/[\\s\\S]*?\\/\\*\\s*:${tag}-end\\s*\\*\\/`;
-	return content.replace(new RegExp(pattern, "g"), () => value);
-};
-
-const defaultTemplate = ({__meta, program1, program2}: TemplateArgs) => {
-	const {declarationNames, styleProps, styleNames} = __meta;
-	const {map: constructorMap, imports: styleImports} =
-		createModulesMapFromDependencies(declarationNames);
-
-	let result = "// @ts-nocheck\n" + templateSource;
-	result = replaceTag(result, "styleImports", styleImports);
-	result = replaceTag(result, "constructorMap", constructorMap);
-	result = replaceTag(result, "styleNames", JSON.stringify(styleNames));
-	result = replaceTag(result, "styleProps", JSON.stringify(styleProps));
-	result = replaceTag(result, "program1", program1);
-	result = replaceTag(result, "program2", program2);
-
-	return result;
-};
-
-export default defaultTemplate;

package/src/js/treeToProgram.ts

@@ -1,220 +0,0 @@
-import type {
-	DeclarationLeaf,
-	DeclarationNode,
-} from "./cssToRules/mapDeclaration.ts";
-import type {Check} from "./cssToRules/mapSelectorPart.ts";
-import {
-	type BlockTree,
-	compileDeclarationBlock,
-} from "./helpers/compileDeclarationBlock.ts";
-import pathToExpression from "./helpers/pathToExpression.ts";
-import type {Child, Tree, TreeLeaf} from "./rulesToTree.ts";
-
-const dict = "abcdefghijklmnopqrstuvwxyz";
-function aliasName(n: number): string {
-	if (n < 1) throw new Error("n must be greater than 0");
-
-	let result = "";
-	let i = n;
-
-	while (i > 0) {
-		const j = (i - 1) % dict.length;
-
-		// Prepend the character to fix the read-order direction
-		result = dict[j] + result;
-
-		// Divide instead of subtract to shift to the next base digit
-		i = Math.floor((i - 1) / dict.length);
-	}
-	return `$${result}`;
-}
-
-function indent(depth: number = 0): [string, string, string] {
-	return [
-		"\n" + "\t".repeat(depth),
-		"\n" + "\t".repeat(depth + 1),
-		"\n" + "\t".repeat(depth + 2),
-	];
-}
-
-function encodeDeclarationNode(
-	node: DeclarationNode | DeclarationLeaf | null | undefined,
-): BlockTree | null {
-	if (!node) {
-		return null;
-	}
-
-	return Object.fromEntries(
-		Object.entries(node).map(([key, node]) => {
-			if (node === null) {
-				return ["value", null];
-			}
-			return [
-				key,
-				typeof node === "object"
-					? encodeDeclarationNode(
-							node as DeclarationNode | DeclarationLeaf,
-						)
-					: node,
-			];
-		}),
-	);
-}
-
-function checkToExpression(check: Check, aliases?: Map<string, string>) {
-	switch (check.type) {
-		case "js":
-			return check.expression;
-		case "geometryType":
-			return `geometryType == ${check.value}`;
-		case "value": {
-			let property = pathToExpression(check.target, check.path);
-			if (aliases) {
-				if (aliases.has(property)) {
-					property = aliases.get(property)!;
-				} else {
-					const alias = aliasName(aliases.size + 1);
-					aliases.set(property, alias);
-					property = alias;
-				}
-			}
-
-			return "value" in check
-				? `${property} == ${check.value}`
-				: property;
-		}
-	}
-}
-
-function checkToExpressionWithAlias(
-	check: Check,
-	aliases: Map<string, string>,
-): string {
-	const expression = checkToExpression(check, aliases);
-	if (aliases.has(expression)) {
-		return aliases.get(expression)!;
-	}
-	const alias = aliasName(aliases.size + 1);
-	aliases.set(expression, alias);
-	return alias;
-}
-
-function buildConditionExpression(child: Child, aliases: Map<string, string>) {
-	const expressions = child.conditions.map((checks) => {
-		const checkExpression = checks.map((check) => {
-			const expression = checkToExpressionWithAlias(check, aliases);
-			return check.negate ? `!${expression}` : expression;
-		});
-
-		return checkExpression.length > 1
-			? `(${checkExpression.join(" && ")})`
-			: checkExpression[0];
-	});
-
-	return expressions.length > 1
-		? `(${expressions.join(" || ")})`
-		: expressions[0];
-}
-
-export default function treeToProgram(
-	tree: Tree,
-	target = "declaration",
-	baseIndent = 0,
-) {
-	let declarationCounter = 0;
-
-	function programDeclarationBody(
-		subTree: Child | TreeLeaf,
-		depth: number,
-		aliases: Map<string, string>,
-	) {
-		const [_] = indent(depth);
-
-		let result = "";
-		declarationCounter++;
-
-		if (target === "hash") {
-			result += `${_}h(${declarationCounter});`;
-
-			if (subTree.stylePropExpressions) {
-				subTree.stylePropExpressions.forEach((stylePropExpression) => {
-					let alias: string;
-					if (aliases.has(stylePropExpression)) {
-						alias = aliases.get(stylePropExpression)!;
-					} else {
-						alias = aliasName(aliases.size + 1);
-						aliases.set(stylePropExpression, alias);
-					}
-
-					result += `${_}h('@' + createHash(${alias}));`;
-				});
-			}
-		}
-
-		if (target === "declaration") {
-			const block = encodeDeclarationNode(subTree.declarations);
-			if (block) {
-				result += compileDeclarationBlock(block, "d", _);
-			}
-		}
-
-		return result;
-	}
-
-	function stateToProgram(subTree: Tree[string][string], depth = 0) {
-		const [_] = indent(depth);
-		const aliases = new Map<string, string>();
-		let program = "";
-		if (subTree.declarations) {
-			program += programDeclarationBody(subTree, depth, aliases);
-		}
-
-		if (subTree.children) {
-			const programParts = subTree.children.map((child): string => {
-				const expression = buildConditionExpression(child, aliases);
-				return `if (${expression}) {${programDeclarationBody(child, depth + 2, aliases)}${_}}`;
-			});
-
-			if (programParts.length) {
-				program += `${_}${programParts.join(_)}`;
-			}
-		}
-
-		const aliasesPrograms = Array.from(aliases.entries()).map(
-			([expression, alias]) =>
-				`const ${alias} = /* @__PURE__ */${expression};`,
-		);
-
-		if (aliasesPrograms.length) {
-			program = `${_}{${_}${aliasesPrograms.join(_)}${_}${program}${_}}`;
-		}
-
-		return program;
-	}
-
-	function styleToProgram(subTree: Tree[string], depth = 0) {
-		const cases = Object.keys(subTree).filter((a) => a !== "default");
-		const [_, __, ___] = indent(depth);
-
-		return (
-			(subTree.default ? stateToProgram(subTree.default, depth) : "") +
-			(cases.length
-				? `${_}switch (state) {${cases.map((a) => `${__}case '${a}':${stateToProgram(subTree[a]!, depth + 2)}${___}break;`).join("")}${_}}`
-				: "")
-		);
-	}
-
-	function stylesToProgram(rootTree: Tree, depth = 0) {
-		const cases = Object.keys(rootTree).filter((a) => a !== "default");
-		const [_, __, ___] = indent(depth);
-
-		return (
-			(rootTree.default ? styleToProgram(rootTree.default, depth) : "") +
-			(cases.length
-				? `${_}switch (style) {${cases.map((a) => `${__}case '${a}':${styleToProgram(rootTree[a]!, depth + 2)}${___}break;`).join("")}${_}}`
-				: "")
-		);
-	}
-
-	return stylesToProgram(tree, baseIndent);
-}