@selesai/code 0.13.40 → 0.14.3

package/dist/extensions/pi-zentui/test/custom-value-colors.test.ts

@@ -0,0 +1,399 @@
+import { describe, expect, it, vi } from "vitest";
+import type { ColorSource } from "../extensions/zentui/config";
+import {
+	type CustomValueColors,
+	customValueColor,
+	normalizeCustomValueColors,
+	renderCustomValue,
+} from "../extensions/zentui/custom-value-colors";
+import { normalizeTemplateVariables } from "../extensions/zentui/custom-variable-format";
+import { sanitizeCustomVariableText } from "../extensions/zentui/custom-variables";
+import { renderStyleForSource, type ThemeLike } from "../extensions/zentui/style";
+
+const key = "vendor.package/value";
+const theme: ThemeLike = {
+	fg: (color, text) => {
+		const codes: Record<string, number> = { accent: 36, syntaxKeyword: 35, success: 32 };
+		if (!Object.hasOwn(codes, color)) throw new Error(`Unexpected theme token: ${color}`);
+		return `\x1b[${codes[color]}m${text}\x1b[0m`;
+	},
+	bold: (text) => `\x1b[1m${text}\x1b[0m`,
+	italic: (text) => `\x1b[3m${text}\x1b[0m`,
+	underline: (text) => `\x1b[4m${text}\x1b[0m`,
+};
+
+function render(options: Partial<Parameters<typeof renderCustomValue>[0]> = {}): string {
+	return renderCustomValue({
+		key,
+		raw: "\x1b[31mqueue\x1b[0m",
+		mode: "original",
+		theme,
+		source: "terminal",
+		fallbackStyle: "bold blue",
+		...options,
+	});
+}
+
+function unchecked(raw: unknown): CustomValueColors {
+	return raw as CustomValueColors;
+}
+
+describe("normalizeCustomValueColors", () => {
+	it("retains sparse valid styles verbatim, including deliberate empty and whitespace", () => {
+		const raw = {
+			[key]: " bold purple ",
+			"pkg/empty": "",
+			"pkg/whitespace": " \t ",
+			"pkg/theme": "syntaxKeyword",
+			"pkg/hex": "#abc",
+			"pkg/index": "202",
+			"pkg/background": "italic fg:202 bg:#bf5700",
+		};
+		const normalized = normalizeCustomValueColors(raw);
+		expect(normalized).toEqual(raw);
+		expect(Object.getPrototypeOf(normalized)).toBeNull();
+		expect(Object.isFrozen(normalized)).toBe(true);
+		raw[key] = "red";
+		expect(customValueColor(normalized, key)).toBe(" bold purple ");
+	});
+
+	it.each([null, undefined, false, 3, "red", [], ["red"], () => "red"])(
+		"ignores non-record input %s",
+		(raw) => {
+			expect(normalizeCustomValueColors(raw)).toEqual({});
+		},
+	);
+
+	it("ignores invalid specs without coercing or invoking their functions", () => {
+		const callback = vi.fn(() => "red");
+		const raw = {
+			good: "red",
+			unknown: "not-a-style",
+			partial: "bold nope",
+			ansi: "\x1b[31m",
+			index: "fg:256",
+			hex: "#abcd",
+			control: "red\x00",
+			number: 31,
+			object: { toString: callback },
+			function: callback,
+			missing: undefined,
+			nil: null,
+		};
+		expect(normalizeCustomValueColors(raw)).toEqual({ good: "red" });
+		expect(callback).not.toHaveBeenCalled();
+	});
+
+	it("accepts publisher punctuation and exact UTF-16 bounds, not alias-name rules", () => {
+		const maxAscii = "a".repeat(64);
+		const maxUnicode = "😀".repeat(32);
+		const raw = Object.fromEntries(
+			[key, "@scope/pkg:value-1.2", "__proto__/value", "toString", maxAscii, maxUnicode].map(
+				(name) => [name, "green"],
+			),
+		);
+		expect(normalizeCustomValueColors(raw)).toEqual(raw);
+		for (const invalid of [
+			"",
+			`${maxAscii}a`,
+			`${maxUnicode}a`,
+			"has space",
+			"has\tgap",
+			"has\ngap",
+			"a\u00a0b",
+			"a\x00b",
+			"a\x1fb",
+			"a\x7fb",
+			"a\x9fb",
+		]) {
+			expect(normalizeCustomValueColors({ [invalid]: "red" })).toEqual({});
+			expect(customValueColor(unchecked({ [invalid]: "red" }), invalid)).toBeUndefined();
+		}
+	});
+
+	it("rejects prototype-control names and ignores inherited, hidden, symbol and accessor entries", () => {
+		const getter = vi.fn(() => "red");
+		const setter = vi.fn();
+		const inheritedGetter = vi.fn(() => "green");
+		const prototype = Object.defineProperty({ inherited: "red" }, "inheritedGetter", {
+			get: inheritedGetter,
+			enumerable: true,
+		});
+		const raw = Object.create(prototype);
+		Object.defineProperties(raw, {
+			[key]: { value: "blue", enumerable: true },
+			hidden: { value: "red" },
+			accessor: { get: getter, enumerable: true },
+			setter: { set: setter, enumerable: true },
+			["__proto__"]: { get: getter, enumerable: true },
+			constructor: { get: getter, enumerable: true },
+			prototype: { get: getter, enumerable: true },
+		});
+		raw[Symbol("color")] = "purple";
+		expect(normalizeCustomValueColors(raw)).toEqual({ [key]: "blue" });
+		for (const name of [
+			"inherited",
+			"inheritedGetter",
+			"hidden",
+			"accessor",
+			"setter",
+			"__proto__",
+			"constructor",
+			"prototype",
+		]) {
+			expect(customValueColor(raw, name)).toBeUndefined();
+		}
+		expect(getter).not.toHaveBeenCalled();
+		expect(setter).not.toHaveBeenCalled();
+		expect(inheritedGetter).not.toHaveBeenCalled();
+		const forbiddenData = JSON.parse(
+			'{"__proto__":"red","constructor":"green","prototype":"blue"}',
+		);
+		expect(normalizeCustomValueColors(forbiddenData)).toEqual({});
+		for (const name of Object.keys(forbiddenData))
+			expect(customValueColor(forbiddenData, name)).toBeUndefined();
+	});
+
+	it("bounds persistent overrides independently of active protocol capacity, without partial truncation", () => {
+		const raw = Object.fromEntries(
+			Array.from({ length: 1024 }, (_, index) => [`pkg/${index}`, "red"]),
+		);
+		expect(Object.keys(normalizeCustomValueColors(raw))).toHaveLength(1024);
+		raw.overflow = "green";
+		expect(normalizeCustomValueColors(raw)).toEqual({});
+		const hiddenProperties = Object.create(null);
+		for (let index = 0; index < 1025; index++)
+			Object.defineProperty(hiddenProperties, `hidden/${index}`, { value: "red" });
+		expect(normalizeCustomValueColors(hiddenProperties)).toEqual({});
+	});
+
+	it("bounds style-validation input at 4096 code units", () => {
+		const atLimit = `red${" ".repeat(4093)}`;
+		const tooLong = `${atLimit} `;
+		expect(normalizeCustomValueColors({ [key]: atLimit })).toEqual({ [key]: atLimit });
+		expect(customValueColor(unchecked({ [key]: atLimit }), key)).toBe(atLimit);
+		expect(normalizeCustomValueColors({ [key]: tooLong })).toEqual({});
+		expect(customValueColor(unchecked({ [key]: tooLong }), key)).toBeUndefined();
+	});
+
+	it("fails quiet on reflection errors and never returns a partial map", () => {
+		const ownKeysFailure = new Proxy(
+			{},
+			{
+				ownKeys: () => {
+					throw new Error("bad keys");
+				},
+			},
+		);
+		const descriptorFailure = new Proxy(
+			{ good: "red", bad: "green" },
+			{
+				getOwnPropertyDescriptor: (target, name) => {
+					if (name === "bad") throw new Error("bad descriptor");
+					return Object.getOwnPropertyDescriptor(target, name);
+				},
+			},
+		);
+		const revoked = Proxy.revocable({}, {});
+		revoked.revoke();
+		for (const raw of [ownKeysFailure, descriptorFailure, revoked.proxy])
+			expect(normalizeCustomValueColors(raw)).toEqual({});
+		expect(customValueColor(unchecked(descriptorFailure), "bad")).toBeUndefined();
+		expect(customValueColor(unchecked(revoked.proxy), key)).toBeUndefined();
+	});
+});
+
+describe("customValueColor", () => {
+	it("distinguishes absent or invalid inheritance from explicit unstyled overrides", () => {
+		for (const raw of [undefined, null, [], { [key]: "invalid" }, { [key]: 3 }, { other: "red" }])
+			expect(customValueColor(unchecked(raw), key)).toBeUndefined();
+		expect(customValueColor(normalizeCustomValueColors({ [key]: "" }), key)).toBe("");
+		expect(customValueColor(normalizeCustomValueColors({ [key]: " \t " }), key)).toBe(" \t ");
+		expect(customValueColor(normalizeCustomValueColors({ [key]: "blue" }), key)).toBe("blue");
+	});
+
+	it("does not use ordinary prototype indexing or read map accessors", () => {
+		const get = vi.fn(() => "red");
+		const raw = new Proxy({ [key]: "blue" }, { get });
+		expect(customValueColor(raw, key)).toBe("blue");
+		expect(customValueColor(normalizeCustomValueColors({}), "toString")).toBeUndefined();
+		expect(get).not.toHaveBeenCalled();
+	});
+});
+
+describe("renderCustomValue", () => {
+	it.each([
+		"\x1b[31mqueue\x1b[0m",
+		"\x1b[1:2mqueue\x1b[m",
+		"\x1b[38;2;1;2;3mqueue",
+		"\x1b[31ma\x1b[0m\x1b[32mb",
+		"\x1b]8;id=queue;https://example.com\x1b\\link",
+		" \x1b]0;title\x07\x1b]52;c;secret\x07\x1b[2Jqueue\n\t2\x00 ",
+		"界 e\u0301 👩‍💻",
+	])("preserves legacy Original sanitizer bytes without an override: %s", (raw) => {
+		const expected = sanitizeCustomVariableText(raw, "original");
+		for (const source of ["terminal", "theme"] as const) {
+			expect(render({ raw, source })).toBe(expected);
+			expect(render({ raw, source, colors: normalizeCustomValueColors({ other: "red" }) })).toBe(
+				expected,
+			);
+			expect(render({ raw, source, colors: unchecked({ [key]: "bad style" }) })).toBe(expected);
+		}
+	});
+
+	it.each<ColorSource>(["terminal", "theme"])(
+		"retains the exact legacy Zentui fallback with %s source",
+		(source) => {
+			const raw = "\x1b[31m\x1b]8;;https://example.com\x07queue\n2\x1b[0m";
+			const text = sanitizeCustomVariableText(raw, "zentui");
+			const expected = renderStyleForSource(theme, source, "bold blue", text);
+			expect(render({ raw, mode: "zentui", source })).toBe(expected);
+			expect(render({ raw, mode: "zentui", source, colors: unchecked({ [key]: "bad" }) })).toBe(
+				expected,
+			);
+			expect(render({ raw, mode: "zentui", source, fallbackStyle: "" })).toBe(text);
+		},
+	);
+
+	it("explicit foreground and modifiers replace nested publisher SGR, resets and links", () => {
+		const colors = normalizeCustomValueColors({ [key]: "bold underline fg:202 bg:blue" });
+		const raw = "\x1b[31m\x1b]8;;https://example.com\x07queue\x1b[0m\x1b[32m 2\x1b[39m";
+		for (const mode of ["original", "zentui"] as const) {
+			for (const source of ["terminal", "theme"] as const) {
+				expect(render({ raw, colors, mode, source })).toBe("\x1b[1;4;38;5;202;44mqueue 2\x1b[0m");
+			}
+		}
+	});
+
+	it.each(["", " \t "])(
+		"empty override %j is unstyled, while Reset resumes legacy mode",
+		(style) => {
+			const colors = normalizeCustomValueColors({ [key]: style });
+			const raw = "\x1b[31m\x1b]8;;https://example.com\x07queue\x1b[0m";
+			for (const mode of ["original", "zentui"] as const) {
+				for (const source of ["terminal", "theme"] as const)
+					expect(render({ raw, colors, mode, source })).toBe("queue");
+				const reset = { [key]: style };
+				delete (reset as Partial<typeof reset>)[key];
+				expect(render({ raw, mode, colors: normalizeCustomValueColors(reset) })).toBe(
+					render({ raw, mode }),
+				);
+			}
+		},
+	);
+
+	it.each<ColorSource>(["terminal", "theme"])(
+		"uses theme tokens, terminal styles and modifiers through the existing %s renderer",
+		(source) => {
+			for (const style of [
+				"accent",
+				"syntaxKeyword",
+				"green",
+				"bold purple",
+				"italic underline",
+				"#abc",
+				"202",
+				"fg:202 bg:#bf5700",
+			]) {
+				const colors = normalizeCustomValueColors({ [key]: style });
+				expect(render({ source, colors })).toBe(
+					renderStyleForSource(theme, source, style, "queue"),
+				);
+			}
+		},
+	);
+
+	it("keeps all aliases and extension references to a publisher consistent within an owner", () => {
+		const aliases = normalizeTemplateVariables({ queue: key, pending: key }, []);
+		const colors = normalizeCustomValueColors({ [key]: "cyan", queue: "red" });
+		const published = new Map([[key, "\x1b[31mqueue\x1b[0m"]]);
+		const aliasValues = Object.values(aliases).map((publisherKey) =>
+			render({
+				key: publisherKey,
+				raw: published.get(publisherKey) ?? "",
+				colors,
+			}),
+		);
+		const extensionValues = [...published].map(([publisherKey, raw]) =>
+			render({ key: publisherKey, raw, colors }),
+		);
+		expect(aliasValues).toEqual(["\x1b[36mqueue\x1b[0m", "\x1b[36mqueue\x1b[0m"]);
+		expect(extensionValues).toEqual([aliasValues[0]]);
+		expect(render({ colors: normalizeCustomValueColors({ queue: "cyan" }) })).toBe(render());
+	});
+
+	it("keeps owner maps independent across styles and has no shared default palette", () => {
+		const editor = normalizeCustomValueColors({ [key]: "blue" });
+		const footer = normalizeCustomValueColors({ [key]: "green" });
+		expect(render({ colors: editor })).toBe("\x1b[34mqueue\x1b[0m");
+		expect(render({ colors: footer })).toBe("\x1b[32mqueue\x1b[0m");
+		expect(render({ colors: normalizeCustomValueColors({}) })).toBe("\x1b[31mqueue\x1b[0m");
+		expect(customValueColor(editor, key)).toBe("blue");
+	});
+
+	it("does not execute accessor overrides, and invalid overrides inherit Original or Zentui", () => {
+		const get = vi.fn(() => "green");
+		const colors = Object.defineProperty({}, key, { enumerable: true, get });
+		for (const mode of ["original", "zentui"] as const) {
+			expect(render({ mode, colors })).toBe(render({ mode }));
+			expect(render({ mode, colors: unchecked({ [key]: "fg:999" }) })).toBe(render({ mode }));
+		}
+		expect(get).not.toHaveBeenCalled();
+	});
+
+	it("strips terminal controls and normalizes one line without interpreting template-like content", () => {
+		const raw =
+			"\x1b]0;title\x07\x1b]52;c;secret\x07\x1b[2J\x1b[4H\x1b[31m$fill $ci \ue000\n\t界 e\u0301\r\f\v👩‍💻\x00\x7f\x9f";
+		expect(render({ raw, colors: normalizeCustomValueColors({ [key]: "" }) })).toBe(
+			"$fill $ci \ue000 界 e\u0301 👩‍💻",
+		);
+	});
+
+	it("closes styling and links before adjacent frame text", () => {
+		const raw = "\x1b[31m\x1b]8;;https://example.com\x07queue";
+		const adjacent = " | next";
+		expect(render({ raw }) + adjacent).toBe(
+			"\x1b[31m\x1b]8;;https://example.com/\x07queue\x1b]8;;\x07\x1b[0m | next",
+		);
+		for (const mode of ["original", "zentui"] as const) {
+			expect(
+				render({ raw, mode, colors: normalizeCustomValueColors({ [key]: "bold red" }) }) + adjacent,
+			).toBe("\x1b[1;31mqueue\x1b[0m | next");
+			expect(
+				render({
+					raw,
+					mode,
+					source: "theme",
+					colors: normalizeCustomValueColors({ [key]: "accent" }),
+				}) + adjacent,
+			).toBe("\x1b[36mqueue\x1b[0m | next");
+		}
+	});
+
+	it("does not emit styled control-only or empty values", () => {
+		for (const raw of [
+			"",
+			" \n\t ",
+			"\x1b[31m\x1b[0m",
+			"\x1b]8;;https://example.com\x07\x1b]8;;\x07",
+		]) {
+			for (const mode of ["original", "zentui"] as const) {
+				expect(render({ raw, mode })).toBe("");
+				expect(
+					render({ raw, mode, colors: normalizeCustomValueColors({ [key]: "bold red" }) }),
+				).toBe("");
+			}
+		}
+	});
+
+	it("retains the existing renderer's safe fallback when a theme token is unavailable", () => {
+		const unavailable: ThemeLike = {
+			fg: () => {
+				throw new Error("missing theme");
+			},
+		};
+		expect(
+			render({ theme: unavailable, colors: normalizeCustomValueColors({ [key]: "accent" }) }),
+		).toBe("queue");
+	});
+});

package/dist/extensions/pi-zentui/test/custom-variable-alias-prototypes.test.ts

@@ -0,0 +1,177 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { describe, expect, it } from "vitest";
+import { FOOTER_FORMAT_ALIASES, mergeConfig } from "../extensions/zentui/config";
+import {
+	editorDemandsCustomVariable,
+	editorMetadataReferences,
+	footerDemandsCustomVariable,
+} from "../extensions/zentui/custom-variable-demand";
+import { normalizeTemplateVariables } from "../extensions/zentui/custom-variable-format";
+import { installFooter } from "../extensions/zentui/footer";
+import {
+	collectFooterFormatReferences,
+	compiledFooterFormat,
+	parseFooterFormat,
+} from "../extensions/zentui/footer-format";
+import { emptyGitStatus } from "../extensions/zentui/git";
+import { renderMinimalistFrame } from "../extensions/zentui/minimalist-editor";
+import { MINIMALIST_FORMAT_SLOTS } from "../extensions/zentui/minimalist-template";
+import { createInitialState } from "../extensions/zentui/state";
+import { renderPolishedEditorFrame } from "../extensions/zentui/ui";
+
+const names = ["toString", "valueOf", "hasOwnProperty"] as const;
+const theme = {
+	fg: (_color: string, text: string) => text,
+	bold: (text: string) => text,
+	italic: (text: string) => text,
+} as unknown as Theme;
+
+function renderFooter(config: ReturnType<typeof mergeConfig>, values: ReadonlyMap<string, string>) {
+	let component: { render(width: number): string[] } | undefined;
+	installFooter(
+		{
+			cwd: "/tmp/project",
+			getContextUsage: () => null,
+			sessionManager: { getSessionName: () => undefined },
+			ui: {
+				setFooter(factory: (...args: never[]) => typeof component) {
+					component = factory(
+						{ requestRender() {} } as never,
+						theme as never,
+						{ getExtensionStatuses: () => new Map(), onBranchChange: () => () => {} } as never,
+					);
+				},
+			},
+		} as never,
+		createInitialState(emptyGitStatus()),
+		() => config,
+		{ setRequestRender() {}, scheduleProjectRefresh() {}, getCustomVariables: () => values },
+	);
+	if (!component) throw new Error("missing footer");
+	return component.render(100).join("\n");
+}
+
+describe("custom-variable aliases matching Object.prototype names", () => {
+	it.each(names)(
+		"collects string references for $%s without a configured canonical alias",
+		(name) => {
+			const format = `($${name})$wrap$directory$fill\${${name}}`;
+			expect([...collectFooterFormatReferences(parseFooterFormat(format))]).toEqual([
+				name,
+				"directory",
+			]);
+			const compiled = compiledFooterFormat(format, FOOTER_FORMAT_ALIASES);
+			expect(compiled.references).toEqual([name, "cwd"]);
+			expect(compiled.compact.left[0]?.references).toEqual([name]);
+			expect(compiled.compact.right[0]?.references).toEqual([name]);
+		},
+	);
+
+	it.each(names)(
+		"observes own and null-prototype %s alias additions, edits and removals",
+		(name) => {
+			const format = `cache-prototype-${name} $${name}`;
+			for (const aliases of [{}, Object.create(null)] as Record<string, string>[]) {
+				const initial = compiledFooterFormat(format, aliases);
+				expect(initial.references).toEqual([name]);
+				expect(compiledFooterFormat(format, aliases)).toBe(initial);
+				aliases[name] = "cwd";
+				const added = compiledFooterFormat(format, aliases);
+				expect(added.tokens).toBe(initial.tokens);
+				expect(added.references).toEqual(["cwd"]);
+				expect([...collectFooterFormatReferences(added.tokens, aliases)]).toEqual(["cwd"]);
+				aliases[name] = "tokens";
+				expect(compiledFooterFormat(format, aliases).references).toEqual(["tokens"]);
+				delete aliases[name];
+				expect(compiledFooterFormat(format, aliases).references).toEqual([name]);
+			}
+		},
+	);
+
+	it("retains inherited string aliases and observes edits without retaining the map", () => {
+		const prototype = { toString: "cwd", directory: "git_branch" };
+		const aliases = Object.create(prototype) as Record<string, string>;
+		const format = "inherited-string-alias $toString $directory";
+		const initial = compiledFooterFormat(format, aliases);
+		expect(initial.references).toEqual(["cwd", "git_branch"]);
+		expect([...collectFooterFormatReferences(initial.tokens, aliases)]).toEqual([
+			"cwd",
+			"git_branch",
+		]);
+		expect(compiledFooterFormat(format, aliases)).toBe(initial);
+		prototype.toString = "tokens";
+		expect(compiledFooterFormat(format, aliases).references).toEqual(["tokens", "git_branch"]);
+		Reflect.set(aliases, "toString", "cost");
+		expect(compiledFooterFormat(format, aliases).references).toEqual(["cost", "git_branch"]);
+		Reflect.deleteProperty(aliases, "toString");
+		expect(compiledFooterFormat(format, aliases).references).toEqual(["tokens", "git_branch"]);
+	});
+
+	it.each(names)(
+		"keeps configured %s demand and rendering independent for every consumer",
+		(name) => {
+			const key = `plugin.${name}`;
+			const value = `VALUE-${name}`;
+			const variables = { [name]: key };
+			expect(normalizeTemplateVariables(variables, [])).toEqual(variables);
+			const values = new Map([[key, value]]);
+			const format = `($${name})`;
+			for (const style of ["opencode", "opencode-copy-friendly", "minimalist"] as const) {
+				const config = mergeConfig({
+					components: {
+						editor: {
+							style,
+							styles: {
+								[style]: {
+									metadataFormat: format,
+									formats: {
+										...Object.fromEntries(MINIMALIST_FORMAT_SLOTS.map((slot) => [slot, ""])),
+										topLeft: format,
+									},
+									variables,
+								},
+							},
+						},
+						footer: {
+							style: "starship",
+							styles: { starship: { format, compactFormat: format, variables, responsive: false } },
+						},
+					},
+				});
+				expect(editorMetadataReferences(config).has(name)).toBe(true);
+				expect(editorDemandsCustomVariable(config, key)).toBe(true);
+				expect(editorDemandsCustomVariable(config, "unused")).toBe(false);
+				expect(footerDemandsCustomVariable(config, key)).toBe(true);
+				const rows =
+					style === "minimalist"
+						? renderMinimalistFrame({
+								width: 100,
+								editorLines: ["draft"],
+								inputText: "draft",
+								metadata: { cwd: "/repo", customVariables: values },
+								uiTheme: theme,
+								config,
+							})
+						: renderPolishedEditorFrame({
+								width: 100,
+								editorLines: ["draft"],
+								uiTheme: theme,
+								config,
+								modelMeta: { modelLabel: "model", providerLabel: "test", customVariables: values },
+							});
+				expect(rows.join("\n")).toContain(value);
+				expect(renderFooter(config, values)).toContain(value);
+				const starship = config.components.footer.styles.starship;
+				starship.format = "unused";
+				expect(footerDemandsCustomVariable(config, key)).toBe(false);
+				starship.responsive = true;
+				expect(footerDemandsCustomVariable(config, key)).toBe(true);
+				starship.format = `${"long ".repeat(40)}$${name}`;
+				expect(renderFooter(config, values)).toContain(value);
+				config.components.editor.enabled = false;
+				expect(editorDemandsCustomVariable(config, key)).toBe(false);
+				expect(footerDemandsCustomVariable(config, key)).toBe(true);
+			}
+		},
+	);
+});