@tmagic/form 1.8.0-beta.25 → 1.8.0-beta.27

package/dist/es/utils/collectFields.js

@@ -0,0 +1,407 @@
+import { getFieldInnerConfig } from "./fieldInnerConfig.js";
+import { getFieldMountValueEffect, isLeafFieldType } from "./fieldValueEffects.js";
+import { appendProp, display, filterFunction, getItemProp, getNativeRules, isValidName, resolveItemType } from "./form.js";
+import { getGroupListRowConfig, isGroupListType, isTableColumnRendered, makeTableColumnConfig, toGroupListConfig, toTableConfig } from "./tableGroupList.js";
+import { toLine } from "@tmagic/utils";
+//#region packages/form/src/utils/collectFields.ts
+/** 已登记的 innerConfig 回调自身抛错时抛出（机制故障，不是漏登记） */
+var FieldInnerConfigError = class extends Error {
+	code = "FIELD_INNER_CONFIG";
+	type;
+	prop;
+	constructor(type, prop, cause) {
+		const reason = cause instanceof Error ? cause.message : String(cause);
+		super(`[MForm] innerConfig for "${type}" at "${prop}" failed: ${reason}`);
+		this.name = "FieldInnerConfigError";
+		this.type = type;
+		this.prop = prop;
+		if (cause instanceof Error) this.cause = cause;
+	}
+};
+var isFieldInnerConfigError = (error) => error instanceof FieldInnerConfigError || typeof error === "object" && error !== null && error.code === "FIELD_INNER_CONFIG";
+/** `effects` 模式下遍历全部配置，不受 display / 折叠状态影响 */
+var ignoresDisplay = (ctx) => ctx.mode === "effects";
+var extraContainerWalkers = /* @__PURE__ */ new Map();
+var builtInContainerWalkers = /* @__PURE__ */ new Map();
+var registerContainerWalker = (type, walker, builtIn = false) => {
+	if (typeof type !== "string" || !type || typeof walker !== "function") return;
+	const key = toLine(type);
+	if (builtIn) {
+		builtInContainerWalkers.set(key, walker);
+		return;
+	}
+	extraContainerWalkers.set(key, walker);
+};
+var getContainerWalker = (type) => {
+	const key = toLine(type);
+	return extraContainerWalkers.get(key) ?? builtInContainerWalkers.get(key);
+};
+var deleteContainerWalker = (type) => extraContainerWalkers.delete(toLine(type));
+var clearContainerWalkers = () => extraContainerWalkers.clear();
+var getItems = (config) => config?.items;
+/**
+* `resolveItemType` 的静态版本：不求值函数型 `type`，由调用方按「未知」处理。
+*
+* 两者必须保持一致，否则预扫描判定的 type 与实际遍历的不同，会漏执行 effect。
+*/
+var staticItemType = (config) => {
+	const type = "type" in config ? config.type : "";
+	if (type === "form" || type === "container") return "";
+	return `${type || ""}`.replace(/([A-Z])/g, "-$1").toLowerCase() || (config.items ? "" : "text");
+};
+/**
+* 静态预判一份配置子树是否可能触发值初始化写入。
+*
+* 只有「确定不会」时才返回 false。函数型 `type`、`itemsFunction`、业务登记的容器遍历器、
+* 登记了 innerConfig 的复合字段，其运行期结构静态看不出来，一律按可能触发处理。
+*
+* 只用在同一份 `items` 会被逐行 / 逐标签页重复展开的地方（table、group-list、dynamic tab）：
+* 预判成本是 O(子项数)，跳过省下的是 O(行数 × 子项数)，无 effect 的多行表格能省一个量级。
+* 其余位置不做预判——扫描与遍历的单节点成本相当，扫完再遍历只会更慢。
+*
+* 只看 `items`：table / group-list 只遍历当前形态的子项，另一形态的
+* `tableItems` / `groupItems` 不参与遍历，判定范围与遍历保持一致。
+*/
+var mayRunEffects = (config) => {
+	if (!config) return false;
+	if (typeof config.type === "function" || typeof config.itemsFunction === "function") return true;
+	const type = staticItemType(config);
+	if (type === "hidden") return false;
+	if (type) {
+		const key = toLine(type);
+		if (extraContainerWalkers.has(key)) return true;
+		if (!builtInContainerWalkers.has(key)) {
+			if (getFieldInnerConfig(type) || getFieldMountValueEffect(type)) return true;
+			if (isLeafFieldType(type)) return false;
+		}
+	}
+	return itemsMayRunEffects(config.items);
+};
+var itemsMayRunEffects = (items) => Array.isArray(items) && items.some((item) => mayRunEffects(item));
+/**
+* 复刻 `Container.vue` 的 `display`。
+*
+* 与渲染的唯一差异：`display: 'expand'`（「展开更多配置」按钮背后的字段）在此视为可见。
+* 「是否已展开」纯粹是交互状态，不改变字段是否属于这份配置，无渲染校验按配置声明的范围校验。
+*/
+var resolveDisplay = (ctx, config, nodeProps) => {
+	if (ignoresDisplay(ctx)) return true;
+	const value = display(ctx.mForm, config?.display, nodeProps);
+	if (value === "expand") return true;
+	return Boolean(value);
+};
+var addField = (ctx, node, itemProp, nodeProps) => {
+	if (ctx.mode !== "collect") return;
+	const rules = getNativeRules(ctx.mForm, node.config.rules, nodeProps, ctx.typeMatchValid);
+	if (!rules.length) return;
+	ctx.fields.push({
+		prop: itemProp,
+		rules,
+		config: node.config,
+		model: node.model
+	});
+};
+var walkChildren = (ctx, items, model, prop) => {
+	if (!Array.isArray(items)) return;
+	for (const item of items) {
+		if (!item) continue;
+		walkNode(ctx, {
+			config: item,
+			model,
+			prop
+		});
+	}
+};
+var getContainerScope = (node) => {
+	const { config, model } = node;
+	const name = config.name || "";
+	return {
+		config,
+		model,
+		name,
+		items: getItems(config),
+		childModel: name ? model?.[name] : model
+	};
+};
+/** containers/Tabs.vue */
+var expandTab = (ctx, node, itemProp) => {
+	const { config, model, name, items, childModel } = getContainerScope(node);
+	const tabsProps = {
+		model,
+		config,
+		prop: itemProp
+	};
+	if (config.dynamic) {
+		if (!name) return;
+		const tabs = model?.[name] || [];
+		if (!tabs.length) return;
+		if (ctx.mode === "effects" && !itemsMayRunEffects(items)) return;
+		tabs.forEach((_tab, tabIndex) => {
+			walkChildren(ctx, items, childModel?.[tabIndex], appendProp(itemProp, tabIndex));
+		});
+		return;
+	}
+	const tabs = ignoresDisplay(ctx) ? items || [] : (items || []).filter((item) => display(ctx.mForm, item?.display, tabsProps));
+	for (const tab of tabs) {
+		const tabName = tab.name;
+		walkChildren(ctx, getItems(tab), tabName ? childModel?.[tabName] : childModel, tabName ? appendProp(itemProp, tabName) : itemProp);
+	}
+};
+/** containers/Row.vue → Col.vue：col 用 v-show 控制显隐，始终渲染 */
+var expandRow = (ctx, node, itemProp) => {
+	const { items, childModel } = getContainerScope(node);
+	walkChildren(ctx, items, childModel, itemProp);
+};
+/** containers/Fieldset.vue */
+var expandFieldset = (ctx, node, itemProp) => {
+	const { config, items, childModel } = getContainerScope(node);
+	if (!childModel) return;
+	const { checkbox } = config;
+	const checkboxName = typeof checkbox === "object" && typeof checkbox.name === "string" ? checkbox.name : "value";
+	const checkboxTrueValue = typeof checkbox === "object" && typeof checkbox.trueValue !== "undefined" ? checkbox.trueValue : 1;
+	if (!ignoresDisplay(ctx) && config.expand && childModel?.[checkboxName] !== checkboxTrueValue) return;
+	walkChildren(ctx, items, childModel, itemProp);
+};
+/** containers/Panel.vue：折叠仅 display:none，子项照常渲染 */
+var expandPanel = (ctx, node, itemProp) => {
+	const { items, childModel } = getContainerScope(node);
+	if (!items?.length) return;
+	walkChildren(ctx, items, childModel, itemProp);
+};
+/** containers/Step.vue：非当前步仅 v-show 隐藏，子项照常渲染；prop 基准被重置为 step.name */
+var expandStep = (ctx, node, _itemProp) => {
+	const { model, items } = getContainerScope(node);
+	for (const step of items || []) {
+		const stepName = step?.name;
+		walkChildren(ctx, getItems(step), stepName ? model?.[stepName] : model, `${stepName}`);
+	}
+};
+/**
+* 遍历 table / group-list。
+*
+* `TableGroupList.vue` 按原始 `config.type` 决定初始展示形态（table 或 groupList），
+* 两种形态的子项结构不同，这里分别复刻（形态间的配置派生复用 `utils/tableGroupList`，
+* 与渲染式实现同源）：
+* - table：逐列（跳过 hidden 列与 display 为假的列）× 逐行渲染 Container，行 prop 为 `${prop}.${index}`；
+* - groupList：逐行渲染一个 row 容器，包含 `items` 全部字段。
+*
+* 与渲染的差异：不做分页截断（table）、不跳过折叠行（groupList）。二者都是列表的视图状态，
+* 与「这些行的值是否合法」无关，无渲染校验覆盖全部行。
+*/
+var expandTableGroupList = (ctx, node, itemProp) => {
+	const { config, model } = node;
+	const name = config.name || "";
+	const rows = model?.[name];
+	if (!Array.isArray(rows) || !rows.length) return;
+	if (isGroupListType(config.type)) {
+		const groupListConfig = toGroupListConfig(config);
+		if (ctx.mode === "effects" && !itemsMayRunEffects(groupListConfig.items)) return;
+		rows.forEach((row, index) => {
+			walkNode(ctx, {
+				config: getGroupListRowConfig(groupListConfig, index, ctx.mForm?.keyProp),
+				model: row,
+				prop: appendProp(itemProp, index)
+			});
+		});
+		return;
+	}
+	const tableItems = toTableConfig(config).items;
+	if (!Array.isArray(tableItems)) return;
+	if (ctx.mode === "effects" && !itemsMayRunEffects(tableItems)) return;
+	const tableProps = {
+		model,
+		config,
+		prop: itemProp
+	};
+	const evalDisplay = (display$1) => display(ctx.mForm, display$1, tableProps);
+	const isRendered = (column) => ignoresDisplay(ctx) || isTableColumnRendered(column, evalDisplay);
+	rows.forEach((row, index) => {
+		for (const column of tableItems) {
+			if (!column || !isRendered(column)) continue;
+			walkNode(ctx, {
+				config: makeTableColumnConfig(column, row),
+				model: row,
+				prop: appendProp(itemProp, index)
+			});
+		}
+	});
+};
+/**
+* 执行某个叶子字段登记的值初始化写入。
+*
+* 跑在表单初始化路径上，单个字段的 effect 抛错不应该让整张表单渲染不出来，因此只记录并继续。
+*/
+var runMountValueEffect = (ctx, type, node, itemProp) => {
+	const effect = getFieldMountValueEffect(type);
+	if (!effect) return;
+	try {
+		effect({
+			config: node.config,
+			model: node.model,
+			prop: itemProp,
+			mForm: ctx.mForm,
+			values: ctx.values
+		});
+	} catch (e) {
+		console.error(`[MForm] mount value effect for "${type}" at "${itemProp}" failed:`, e);
+	}
+};
+/**
+* 遍历已登记 innerConfig 的复合字段。
+*
+* `collect` 模式下回调抛错视为机制故障，包装成 `FieldInnerConfigError` 抛出，由校验流程暴露。
+* `effects` 模式跑在表单初始化路径上，抛出会让整张表单渲染不出来，因此只记录并跳过该子树。
+*/
+var walkInnerConfig = (ctx, type, node, itemProp) => {
+	const resolve = getFieldInnerConfig(type);
+	if (!resolve) return false;
+	let result;
+	try {
+		result = resolve({
+			config: node.config,
+			model: node.model,
+			prop: itemProp,
+			parentProp: node.prop,
+			mForm: ctx.mForm
+		});
+	} catch (e) {
+		if (ctx.mode === "collect") throw new FieldInnerConfigError(type, itemProp, e);
+		console.error(new FieldInnerConfigError(type, itemProp, e));
+		return true;
+	}
+	if (!result) return true;
+	const innerModel = result.model ?? node.model;
+	const innerProp = result.prop ?? itemProp;
+	walkChildren(ctx, Array.isArray(result.config) ? result.config : [result.config], innerModel, innerProp);
+	return true;
+};
+/**
+* 遍历一个 Container 节点，分支顺序与 `Container.vue` 的模板保持一致。
+*
+* 对比模式（`isCompare`）在此被忽略：它只改变同一个 prop 渲染几份 FormItem，
+* 规则与取值完全相同，对校验结果没有影响。
+*/
+var walkNode = (ctx, node) => {
+	const { config, prop } = node;
+	const model = node.model ?? {};
+	const nodeProps = {
+		model,
+		config,
+		prop
+	};
+	const name = config.name || "";
+	const items = getItems(config);
+	const type = resolveItemType(ctx.mForm, config, nodeProps);
+	const itemProp = getItemProp(prop, name);
+	const text = filterFunction(ctx.mForm, config.text, nodeProps);
+	if (type === "hidden") {
+		addField(ctx, {
+			...node,
+			model
+		}, itemProp, nodeProps);
+		return;
+	}
+	const display = resolveDisplay(ctx, config, nodeProps);
+	if (items && !text && type && display) {
+		dispatchByType(ctx, type, {
+			...node,
+			model
+		}, itemProp);
+		return;
+	}
+	if (type && display) {
+		addField(ctx, {
+			...node,
+			model
+		}, itemProp, nodeProps);
+		dispatchByType(ctx, type, {
+			...node,
+			model
+		}, itemProp);
+		return;
+	}
+	if (items && display) {
+		const childModel = isValidName(name) ? model[name] : model;
+		if (!childModel) return;
+		walkChildren(ctx, items, childModel, itemProp);
+	}
+};
+/**
+* 按 type 分派：已登记 walk 的容器 → 按容器模板遍历；
+* `effects` 模式下先执行本字段的 effect（可与 innerConfig 并存，如 `code-select` 先归一化再下钻）；
+* 登记了 innerConfig 的复合字段 → 遍历其内部配置；叶子字段无子树。
+*
+* 未登记的 type：配置里若有 `items` 则按普通容器下钻；否则视为没有嵌套表单项。
+* 自身 rules 已在 FormItem 分支收集，有 rules 就会校验。
+*/
+var dispatchByType = (ctx, type, node, itemProp) => {
+	const walkContainer = getContainerWalker(type);
+	if (walkContainer) {
+		walkContainer(ctx, node, itemProp);
+		return;
+	}
+	if (ctx.mode === "effects") runMountValueEffect(ctx, type, node, itemProp);
+	if (walkInnerConfig(ctx, type, node, itemProp)) return;
+	if (isLeafFieldType(type)) return;
+	const items = getItems(node.config);
+	if (items?.length) {
+		const { childModel } = getContainerScope(node);
+		walkChildren(ctx, items, childModel, itemProp);
+	}
+};
+/**
+* 纯逻辑收集「一份 config + 一份 values」中所有参与校验的字段。
+*
+* 遍历规则与 `Container.vue` 及各容器组件的模板一一对应，因此产出的 prop / rules
+* 与渲染式校验（挂载 MForm 后调用 `validate()`）等价，无需任何 DOM 或组件实例。
+*
+* 本函数只读不写。字段的值初始化副作用由 `applyMountValueEffects` 负责，
+* 调用方需在初始化表单值之后、收集字段之前执行一次（`validateValues` 已经这么做）。
+*
+* @param mForm - 表单状态；无渲染时由 `createHeadlessFormState` 构造
+* @param config - 表单配置
+* @param values - 表单值
+* @param [typeMatchValid] - 是否自动注入 typeMatch 规则；为 true 时，未显式声明
+*   `typeMatch` 的字段会补上 `{ typeMatch: true }`，按字段 type 校验值形态
+* @returns 带规则的字段列表
+*/
+var collectValidatableFields = (mForm, config, values, typeMatchValid) => {
+	const ctx = {
+		mForm,
+		typeMatchValid,
+		fields: [],
+		values,
+		mode: "collect"
+	};
+	if (Array.isArray(config)) walkChildren(ctx, config, values, "");
+	return ctx.fields;
+};
+/**
+* 执行「一份 config + 一份 values」中所有叶子字段登记的值初始化写入，就地改写 `values`。
+*
+* 渲染与无渲染两条链路共用的唯一执行点：字段组件自身不再在 setup 里改写 model，
+* 由持有完整表单值的一方（`Form.vue` / `validateValues`）在表单值初始化完成、
+* 且已挂到 `mForm.values` 之后调用一次。这样 effect 与动态 `type` 回调读到的
+* `formValue` 就是最新值，而不是上一轮的旧值。
+*
+* 与 `collectValidatableFields` 的差异：不看 `display`（`display: false` 的字段也会规整）。
+* `type: 'hidden'` 会在该节点停止遍历，内部字段不执行 effect。
+*
+* `prop` 与 `values` 都以传入的 `values` 为根，因此也可以用于 tab / table 新增行这类
+* 「先构造一份子树的值，再挂到表单上」的场景：传入子树配置与该行的值即可。
+*
+* @param mForm - 表单状态；无渲染时由 `createHeadlessFormState` 构造
+* @param config - 表单配置
+* @param values - 表单值（会被就地修改）
+*/
+var applyMountValueEffects = (mForm, config, values) => {
+	if (!Array.isArray(config)) return;
+	walkChildren({
+		mForm,
+		fields: [],
+		values,
+		mode: "effects"
+	}, config, values, "");
+};
+//#endregion
+export { FieldInnerConfigError, applyMountValueEffects, clearContainerWalkers, collectValidatableFields, deleteContainerWalker, expandFieldset, expandPanel, expandRow, expandStep, expandTab, expandTableGroupList, getContainerWalker, isFieldInnerConfigError, registerContainerWalker };

package/dist/es/utils/config.js

@@ -7,12 +7,5 @@ var setConfig = (option) => {
 	isGlobalFlat.value = option.flat ?? false;
 };
 var getConfig = (key) => $MAGIC_FORM[key];
-var fieldRegistry = /* @__PURE__ */ new Map();
-var registerField = (tagName, component) => {
-	if (fieldRegistry.has(tagName)) return;
-	fieldRegistry.set(tagName, component);
-};
-var getField = (tagName) => fieldRegistry.get(tagName);
-var deleteField = (tagName) => fieldRegistry.delete(tagName);
 //#endregion
-export { deleteField, getConfig, getField, isGlobalFlat, registerField, setConfig };
+export { getConfig, isGlobalFlat, setConfig };

package/dist/es/utils/fieldInnerConfig.js

@@ -0,0 +1,42 @@
+import { toLine } from "@tmagic/utils";
+//#region packages/form/src/utils/fieldInnerConfig.ts
+/** 内置内部配置（由 `registerBuiltInFields` 写入；`clearFields` 不会清掉） */
+var builtInInnerConfigs = /* @__PURE__ */ new Map();
+/** 业务侧登记的内部配置 */
+var extraInnerConfigs = /* @__PURE__ */ new Map();
+/**
+* 登记复合字段的内部配置：无渲染校验遇到该 type 时，用返回值继续遍历内部字段。
+*
+* `type` 会按 Container 的规则归一化为中划线形式（`codeSelect` 与 `code-select` 等价）。
+* 重复登记以最后一次为准，便于业务侧覆盖内置实现。
+* `builtIn` 登记不受 `deleteFieldInnerConfig` / `clearFieldInnerConfigs` 影响。
+*
+* @param type - 字段 type
+* @param resolve - innerConfig 回调
+* @param [builtIn=false] - 是否写入内置表
+*/
+var registerFieldInnerConfig = (type, resolve, builtIn = false) => {
+	if (typeof type !== "string" || !type || typeof resolve !== "function") return;
+	(builtIn ? builtInInnerConfigs : extraInnerConfigs).set(toLine(type), resolve);
+};
+/**
+* 获取指定 type 的 innerConfig 回调（业务侧优先于内置）。
+*
+* @param type - 字段 type
+* @returns innerConfig 回调；未登记则为 `undefined`
+*/
+var getFieldInnerConfig = (type) => {
+	const key = toLine(type);
+	return extraInnerConfigs.get(key) ?? builtInInnerConfigs.get(key);
+};
+/**
+* 删除业务侧登记的 innerConfig（不影响内置）。
+*
+* @param type - 字段 type
+* @returns 是否删除成功
+*/
+var deleteFieldInnerConfig = (type) => extraInnerConfigs.delete(toLine(type));
+/** 清空业务侧登记的 innerConfig（不影响内置；主要用于单测）。 */
+var clearFieldInnerConfigs = () => extraInnerConfigs.clear();
+//#endregion
+export { clearFieldInnerConfigs, deleteFieldInnerConfig, getFieldInnerConfig, registerFieldInnerConfig };

package/dist/es/utils/fieldValueEffects.js

@@ -0,0 +1,80 @@
+import { toLine } from "@tmagic/utils";
+//#region packages/form/src/utils/fieldValueEffects.ts
+/**
+* @fileoverview 叶子字段登记表：哪些 type 是叶子，以及该字段对表单值的初始化写入。
+*
+* 无渲染校验据此判定该 type 没有属于父表单的嵌套字段。
+* 业务自定义字段通过 `registerField` / `registerFields` 登记。
+* 内置叶子字段由 `MagicForm.install` 的 `registerBuiltInFields` 写入。
+* 未登记且没有 innerConfig 的 type：有 `items` 会下钻子项，自身有 `rules` 会校验自身。
+*
+* 这里只是登记表。各字段的 effect 写在对应组件同目录的 `fields/<Field>/effect.ts`，
+* 执行收口在 `collectFields` 的 `applyMountValueEffects`：渲染（`Form.vue`）
+* 与无渲染（`validateValues`）都在表单值初始化完成后调用它一次，
+* 字段组件自身不再在 setup 里改写 model。
+*
+* @module fieldValueEffects
+*/
+/** 内置叶子字段（由 `MagicForm.install` 写入；clearFields 不会清掉） */
+var builtInLeafFieldTypes = /* @__PURE__ */ new Set();
+var builtInMountValueEffects = /* @__PURE__ */ new Map();
+/** 业务侧登记的叶子字段与其挂载副作用 */
+var extraLeafFieldTypes = /* @__PURE__ */ new Set();
+var extraMountValueEffects = /* @__PURE__ */ new Map();
+/**
+* 登记一个叶子字段 type。由 `registerField` 调用，业务侧请走 `registerField`。
+*
+* 传了 `effect` 会覆盖该 type 已有的 extra effect（含覆盖内置）；不传则清掉 extra effect，
+* 内置 effect 仍生效。
+*
+* @param type - 字段 type
+* @param [effect] - 挂载时改写 model 的副作用
+* @param [builtIn=false] - 是否写入内置表
+*/
+var registerLeafFieldType = (type, effect, builtIn = false) => {
+	if (typeof type !== "string" || !type) return;
+	const key = toLine(type);
+	const types = builtIn ? builtInLeafFieldTypes : extraLeafFieldTypes;
+	const effects = builtIn ? builtInMountValueEffects : extraMountValueEffects;
+	types.add(key);
+	if (typeof effect === "function") effects.set(key, effect);
+	else if (!builtIn) effects.delete(key);
+};
+/**
+* 是否为叶子字段 type（内置 ∪ 已登记）。
+*
+* @param type - 字段 type
+* @returns 是否为叶子
+*/
+var isLeafFieldType = (type) => {
+	const key = toLine(type);
+	return extraLeafFieldTypes.has(key) || builtInLeafFieldTypes.has(key);
+};
+/**
+* 获取指定 type 挂载时改写 model 的副作用（已登记的优先于内置）。
+*
+* @param type - 字段 type
+* @returns 副作用函数；未登记则为 `undefined`
+*/
+var getFieldMountValueEffect = (type) => {
+	const key = toLine(type);
+	return extraMountValueEffects.get(key) ?? builtInMountValueEffects.get(key);
+};
+/**
+* 删除业务侧登记的叶子字段（不影响内置；主要用于单测）。
+*
+* @param type - 字段 type
+* @returns 是否删除成功
+*/
+var deleteLeafFieldType = (type) => {
+	const key = toLine(type);
+	extraMountValueEffects.delete(key);
+	return extraLeafFieldTypes.delete(key);
+};
+/** 清空业务侧登记的叶子字段（不影响内置；主要用于单测）。 */
+var clearLeafFieldTypes = () => {
+	extraLeafFieldTypes.clear();
+	extraMountValueEffects.clear();
+};
+//#endregion
+export { clearLeafFieldTypes, deleteLeafFieldType, getFieldMountValueEffect, isLeafFieldType, registerLeafFieldType };