@astryx-vue/core 0.1.1 → 0.1.3

package/dist/composables-CVfjp9h4.js

@@ -0,0 +1,502 @@
+import { t as useMediaQuery } from "./useMediaQuery-GMmgp28-.js";
+import { computed, onBeforeUnmount, onMounted, reactive, ref, toValue, watch } from "vue";
+//#region src/composables/useControllableState.ts
+/**
+* 受控或自己管的 v-model。
+*
+* Astryx 没有同名 hook。各组件原来各自判断「外面传了值就听外面的，没传就自己记」，
+* 这里收成一个函数，方便以后的 v-model 共用。
+*/
+function useControllableState(options) {
+	const { modelValue, onChange } = options;
+	const controlled = modelValue.value !== void 0;
+	const local = ref(toValue(options.defaultValue));
+	const isControlled = computed(() => controlled);
+	const value = computed(() => controlled ? modelValue.value : local.value);
+	function setValue(next) {
+		if (Object.is(value.value, next)) return;
+		if (controlled) modelValue.value = next;
+		else local.value = next;
+		onChange?.(next);
+	}
+	return {
+		isControlled,
+		setValue,
+		value
+	};
+}
+//#endregion
+//#region src/composables/useResizable.ts
+const DEFAULT_SIZE = 250;
+const DEFAULT_MIN = 50;
+const DEFAULT_COLLAPSED_SIZE = 40;
+const SNAP_DISTANCE = 8;
+const UNMEASURED_BASIS = 1200;
+const STORAGE_PREFIX = "astryx-resizable:";
+function percent(value, options) {
+	return {
+		type: "percent",
+		value,
+		...options
+	};
+}
+function readBasis(container, direction) {
+	if (container) {
+		const px = direction === "horizontal" ? container.clientWidth : container.clientHeight;
+		if (px > 0) return {
+			px,
+			measured: true
+		};
+		return {
+			px: UNMEASURED_BASIS,
+			measured: false
+		};
+	}
+	if (typeof window === "undefined") return {
+		px: UNMEASURED_BASIS,
+		measured: false
+	};
+	const px = direction === "horizontal" ? window.innerWidth : window.innerHeight;
+	return {
+		px: px > 0 ? px : UNMEASURED_BASIS,
+		measured: px > 0
+	};
+}
+function parseSize(value, basis, fallback) {
+	if (value == null) return fallback;
+	if (typeof value === "number") return value;
+	if (typeof value === "string") {
+		const text = value.trim();
+		if (text.endsWith("%")) return Number(text.slice(0, -1)) / 100 * basis;
+		if (text.endsWith("px")) return Number(text.slice(0, -2));
+		const asNumber = Number(text);
+		return Number.isFinite(asNumber) ? asNumber : fallback;
+	}
+	if (value.type === "pixel") return value.value;
+	const px = value.value / 100 * basis;
+	if (value.min) return Math.max(px, value.min.value);
+	if (value.max) return Math.min(px, value.max.value);
+	return px;
+}
+function clampSize(size, min, max, snaps) {
+	const clamped = Math.min(max, Math.max(min, size));
+	if (snaps.length === 0) return clamped;
+	let nearest = snaps[0] ?? clamped;
+	let nearestDist = Math.abs(clamped - nearest);
+	for (let index = 1; index < snaps.length; index += 1) {
+		const snap = snaps[index] ?? nearest;
+		const dist = Math.abs(clamped - snap);
+		if (dist < nearestDist) {
+			nearest = snap;
+			nearestDist = dist;
+		}
+	}
+	if (nearestDist > SNAP_DISTANCE) return clamped;
+	return Math.min(max, Math.max(min, nearest));
+}
+function loadPersistedState(key) {
+	if (typeof window === "undefined") return null;
+	try {
+		const raw = localStorage.getItem(STORAGE_PREFIX + key);
+		if (raw == null) return null;
+		const parsed = JSON.parse(raw);
+		if (typeof parsed === "number" && Number.isFinite(parsed)) return parsed === 0 ? {
+			size: null,
+			isCollapsed: true
+		} : {
+			size: parsed,
+			isCollapsed: null
+		};
+		if (typeof parsed === "object" && parsed != null) {
+			const record = parsed;
+			const hasSize = typeof record.size === "number" && Number.isFinite(record.size) && record.size > 0;
+			if (hasSize || record.isCollapsed === true) return {
+				size: hasSize ? record.size : null,
+				isCollapsed: record.isCollapsed === true
+			};
+		}
+	} catch {
+		return null;
+	}
+	return null;
+}
+function useSingleRegion(options, cascade) {
+	const direction = options.direction ?? "horizontal";
+	const collapsible = options.collapsible ?? false;
+	const collapsedSize = options.collapsedSize ?? DEFAULT_COLLAPSED_SIZE;
+	const snaps = options.snaps ?? [];
+	const size = ref(DEFAULT_SIZE);
+	const expandedSize = ref(DEFAULT_SIZE);
+	const isCollapsed = ref(false);
+	const basisMeasured = ref(true);
+	const controlledCollapse = computed(() => options.isCollapsed);
+	let origin = DEFAULT_SIZE;
+	let settledDefault = false;
+	let dragging = false;
+	let dragLimits = null;
+	function currentBasis() {
+		return readBasis(options.containerRef?.value, direction);
+	}
+	function limits() {
+		const basis = currentBasis();
+		basisMeasured.value = basis.measured || options.containerRef == null;
+		return {
+			min: parseSize(options.minSize, basis.px, DEFAULT_MIN),
+			max: parseSize(options.maxSize, basis.px, Number.POSITIVE_INFINITY)
+		};
+	}
+	function applySize(next, collapsed) {
+		const { min, max } = limits();
+		if (collapsed && collapsible) {
+			isCollapsed.value = true;
+			size.value = 0;
+			return;
+		}
+		const clamped = clampSize(next, min, max, snaps);
+		isCollapsed.value = false;
+		size.value = clamped;
+		expandedSize.value = clamped;
+	}
+	function restore() {
+		const basis = currentBasis();
+		const initial = parseSize(options.defaultSize, basis.px, DEFAULT_SIZE);
+		const saved = options.autoSaveId ? loadPersistedState(options.autoSaveId) : null;
+		const collapsed = controlledCollapse.value ?? saved?.isCollapsed ?? (collapsible && options.defaultIsCollapsed === true);
+		const starting = saved?.size ?? initial;
+		if (options.containerRef != null && !basis.measured) {
+			basisMeasured.value = false;
+			applySize(starting, Boolean(collapsed));
+			return;
+		}
+		settledDefault = true;
+		basisMeasured.value = true;
+		expandedSize.value = starting;
+		applySize(starting, Boolean(collapsed));
+	}
+	restore();
+	function persist() {
+		if (!options.autoSaveId || !basisMeasured.value) return;
+		try {
+			localStorage.setItem(STORAGE_PREFIX + options.autoSaveId, JSON.stringify({
+				size: expandedSize.value,
+				isCollapsed: isCollapsed.value
+			}));
+		} catch {}
+	}
+	function setCollapsed(next) {
+		if (!collapsible && next) return;
+		if (options.isCollapsed != null) {
+			options.onCollapseChange?.(next);
+			return;
+		}
+		applySize(next ? 0 : expandedSize.value, next);
+		options.onCollapseChange?.(next);
+		persist();
+		cascade?.settle();
+	}
+	function resize(next) {
+		applySize(next, false);
+		cascade?.settle();
+		options.onSizeChange?.(size.value);
+		persist();
+	}
+	function paintDrag(next, collapsed) {
+		const bounds = dragLimits ?? limits();
+		if (collapsed && collapsible) {
+			isCollapsed.value = true;
+			size.value = 0;
+			return;
+		}
+		const clamped = clampSize(next, bounds.min, bounds.max, snaps);
+		isCollapsed.value = false;
+		size.value = clamped;
+		expandedSize.value = clamped;
+	}
+	function onResizeStart() {
+		dragging = true;
+		origin = isCollapsed.value ? 0 : size.value;
+		dragLimits = limits();
+	}
+	function onResizeMove(delta) {
+		const raw = origin + delta;
+		if (collapsible && raw < collapsedSize) {
+			if (!isCollapsed.value) {
+				paintDrag(0, true);
+				options.onCollapseChange?.(true);
+				options.onSizeChange?.(0);
+			}
+			return;
+		}
+		const wasCollapsed = isCollapsed.value;
+		paintDrag(raw, false);
+		if (wasCollapsed) options.onCollapseChange?.(false);
+		options.onSizeChange?.(size.value);
+	}
+	function onResizeEnd() {
+		dragging = false;
+		dragLimits = null;
+		persist();
+		cascade?.settle();
+	}
+	function applyDisplay(next) {
+		if (isCollapsed.value) return;
+		size.value = next;
+	}
+	const props = computed(() => {
+		const { min, max } = limits();
+		return {
+			_size: size.value,
+			_isCollapsed: isCollapsed.value,
+			_onResizeStart: onResizeStart,
+			_onResizeMove: onResizeMove,
+			_onResizeEnd: onResizeEnd,
+			_onResizeCancel: onResizeEnd,
+			_minSizePx: min,
+			_maxSizePx: max,
+			_snaps: snaps,
+			_collapsedSize: collapsedSize,
+			_collapsible: collapsible,
+			_direction: direction,
+			_isResizableProps: true
+		};
+	});
+	function measureDefault() {
+		if (settledDefault || options.containerRef == null) return;
+		const basis = currentBasis();
+		if (!basis.measured) return;
+		settledDefault = true;
+		basisMeasured.value = true;
+		if (options.autoSaveId && loadPersistedState(options.autoSaveId)) return;
+		const initial = parseSize(options.defaultSize, basis.px, size.value);
+		expandedSize.value = initial;
+		if (!isCollapsed.value) applySize(initial, false);
+		cascade?.settle();
+	}
+	let observer;
+	onMounted(() => {
+		measureDefault();
+		const element = options.containerRef?.value;
+		if (element == null || typeof ResizeObserver === "undefined") return;
+		observer = new ResizeObserver(() => measureDefault());
+		observer.observe(element);
+	});
+	onBeforeUnmount(() => observer?.disconnect());
+	watch(controlledCollapse, (next) => {
+		if (next != null) {
+			applySize(next ? 0 : expandedSize.value, next);
+			cascade?.settle();
+		}
+	});
+	cascade?.register({
+		preferred: () => expandedSize.value,
+		isCollapsed: () => isCollapsed.value,
+		min: () => limits().min,
+		isDragging: () => dragging,
+		applyDisplay
+	});
+	return reactive({
+		size,
+		isCollapsed,
+		collapse: () => setCollapsed(true),
+		expand: () => setCollapsed(false),
+		resize,
+		props
+	});
+}
+function useResizable(options) {
+	if ("regions" in options && options.regions != null) {
+		const direction = options.direction ?? "horizontal";
+		const entries = [];
+		let ready = false;
+		function reflow() {
+			if (!ready || entries.length === 0 || !entries.some((entry) => entry.order != null)) return;
+			if (entries.some((entry) => entry.api.isDragging())) return;
+			const element = options.containerRef?.value;
+			if (element == null) return;
+			const basis = readBasis(element, direction);
+			if (!basis.measured) return;
+			const active = entries.filter((entry) => !entry.api.isCollapsed());
+			const sizes = new Map(active.map((entry) => [entry.key, entry.api.preferred()]));
+			let overflow = active.reduce((sum, entry) => sum + entry.api.preferred(), 0) - basis.px;
+			if (overflow > 0) {
+				const order = [...active].sort((left, right) => {
+					return (left.order ?? Number.POSITIVE_INFINITY) - (right.order ?? Number.POSITIVE_INFINITY) || entries.indexOf(left) - entries.indexOf(right);
+				});
+				for (const entry of order) {
+					if (overflow <= 0) break;
+					const current = sizes.get(entry.key) ?? 0;
+					const room = Math.max(0, current - entry.api.min());
+					const take = Math.min(room, overflow);
+					sizes.set(entry.key, current - take);
+					overflow -= take;
+				}
+			}
+			for (const entry of active) {
+				const next = sizes.get(entry.key);
+				if (next != null) entry.api.applyDisplay(next);
+			}
+		}
+		const regions = {};
+		for (const key of Object.keys(options.regions)) {
+			const config = options.regions[key];
+			regions[key] = useSingleRegion({
+				...config,
+				direction,
+				containerRef: options.containerRef,
+				autoSaveId: options.autoSaveId ? `${options.autoSaveId}:${key}` : void 0
+			}, {
+				register: (api) => {
+					entries.push({
+						key,
+						order: config?.shrinkOrder,
+						api
+					});
+				},
+				settle: reflow
+			});
+		}
+		ready = true;
+		let observer;
+		onMounted(() => {
+			reflow();
+			const element = options.containerRef?.value;
+			if (element == null || typeof ResizeObserver === "undefined") return;
+			observer = new ResizeObserver(() => reflow());
+			observer.observe(element);
+		});
+		onBeforeUnmount(() => observer?.disconnect());
+		return regions;
+	}
+	return useSingleRegion(options);
+}
+//#endregion
+//#region src/composables/useScrollOverflow.ts
+/**
+* 观察一个横向滚动容器，报告起始边和结束边有没有被挡住。
+* 容差 1px，滚动和尺寸变化都会重新量。
+*/
+function useScrollOverflow() {
+	const element = ref(null);
+	const overflowStart = ref(false);
+	const overflowEnd = ref(false);
+	const hasOverflow = ref(false);
+	let observer;
+	function measure() {
+		const node = element.value;
+		if (node == null) return;
+		const tolerance = 1;
+		const maxScroll = node.scrollWidth - node.clientWidth;
+		const nextStart = Math.abs(node.scrollLeft) > tolerance;
+		const nextEnd = Math.abs(node.scrollLeft) < maxScroll - tolerance;
+		const nextHas = node.scrollWidth > node.clientWidth + tolerance;
+		overflowStart.value = nextStart;
+		overflowEnd.value = nextEnd;
+		hasOverflow.value = nextHas;
+	}
+	function scrollRef(node) {
+		element.value?.removeEventListener("scroll", measure);
+		observer?.disconnect();
+		element.value = node;
+		if (node == null) return;
+		node.addEventListener("scroll", measure, { passive: true });
+		if (typeof ResizeObserver !== "undefined") {
+			observer = new ResizeObserver(measure);
+			observer.observe(node);
+		}
+		measure();
+	}
+	onBeforeUnmount(() => {
+		element.value?.removeEventListener("scroll", measure);
+		observer?.disconnect();
+	});
+	return {
+		scrollRef,
+		overflowStart,
+		overflowEnd,
+		hasOverflow
+	};
+}
+//#endregion
+//#region src/composables/useStreamingText.ts
+const CHARS_PER_TICK = {
+	natural: 10,
+	fast: 4,
+	instant: Number.POSITIVE_INFINITY
+};
+const FALLBACK_DURATION_MS = 95;
+function parseCssDuration(value) {
+	const milliseconds = /^([\d.]+)ms$/.exec(value.trim());
+	if (milliseconds?.[1] != null) return Number(milliseconds[1]);
+	const seconds = /^([\d.]+)s$/.exec(value.trim());
+	if (seconds?.[1] != null) return Number(seconds[1]) * 1e3;
+	return null;
+}
+function motionDuration() {
+	if (typeof document === "undefined") return FALLBACK_DURATION_MS;
+	return parseCssDuration(getComputedStyle(document.documentElement).getPropertyValue("--astryx-duration-fast-min")) ?? FALLBACK_DURATION_MS;
+}
+function tickInterval(speed) {
+	if (speed === "instant") return 0;
+	const duration = motionDuration();
+	const tick = speed === "fast" ? duration / 20 : duration / 10;
+	return Math.max(4, Math.round(tick));
+}
+const graphemeSegmenter = typeof Intl.Segmenter === "function" ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+function isLowSurrogate(codeUnit) {
+	return codeUnit >= 56320 && codeUnit <= 57343;
+}
+/**
+* Move `offset` back to the start of the grapheme it lands inside, so a slice
+* never cuts a surrogate pair, a flag, or a ZWJ sequence in half.
+*/
+function snapToGraphemeBoundary(text, offset) {
+	if (offset <= 0 || offset >= text.length) return offset;
+	if (graphemeSegmenter != null) return graphemeSegmenter.segment(text).containing(offset)?.index ?? offset;
+	return isLowSurrogate(text.charCodeAt(offset)) ? offset - 1 : offset;
+}
+/**
+* Smooth a burst of streamed text into a steady reveal.
+* While `isStreaming` is false, or the user prefers reduced motion, the full
+* source is returned. The reveal steps by UTF-16 units and then snaps back to
+* a grapheme boundary.
+*/
+function useStreamingText(targetText, isStreaming = false, options) {
+	const displayedLen = ref(0);
+	const prefersReducedMotion = useMediaQuery("(prefers-reduced-motion: reduce)");
+	const target = computed(() => toValue(targetText));
+	const streaming = computed(() => toValue(isStreaming));
+	const speed = computed(() => toValue(options)?.speed ?? "natural");
+	const instant = computed(() => !streaming.value || speed.value === "instant" || prefersReducedMotion.value);
+	watch(target, (next, previous) => {
+		if (next.length === 0 && (previous?.length ?? 0) > 0) displayedLen.value = 0;
+	});
+	watch(streaming, (next) => {
+		if (!next) displayedLen.value = target.value.length;
+	});
+	watch(instant, (isInstant, _, onCleanup) => {
+		if (isInstant) return;
+		let frame = 0;
+		let lastTick = 0;
+		const tick = (now) => {
+			const interval = tickInterval(speed.value);
+			if (now - lastTick >= interval) {
+				lastTick = now;
+				const goal = target.value.length;
+				if (displayedLen.value < goal) {
+					const step = CHARS_PER_TICK[speed.value];
+					displayedLen.value = Math.min(displayedLen.value + step, goal);
+				}
+			}
+			frame = requestAnimationFrame(tick);
+		};
+		frame = requestAnimationFrame(tick);
+		onCleanup(() => cancelAnimationFrame(frame));
+	}, { immediate: true });
+	return computed(() => {
+		const text = target.value;
+		if (instant.value) return text;
+		return text.slice(0, snapToGraphemeBoundary(text, displayedLen.value));
+	});
+}
+//#endregion
+export { useResizable as a, percent as i, useStreamingText as n, useControllableState as o, useScrollOverflow as r, snapToGraphemeBoundary as t };

package/dist/context-BjNya0v8.js

@@ -0,0 +1,19 @@
+import { computed, inject, ref } from "vue";
+//#region src/SideNav/context.ts
+const sideNavRenderModeKey = Symbol("astryx-side-nav-render-mode");
+const defaultRenderMode = computed(() => "default");
+function useSideNavRenderMode() {
+	return inject(sideNavRenderModeKey, defaultRenderMode);
+}
+const sideNavCollapseKey = Symbol("astryx-side-nav-collapse");
+const fallbackCollapse = {
+	isCollapsed: ref(false),
+	isCollapsible: ref(false),
+	navId: "",
+	toggle: () => {}
+};
+function useSideNavCollapse() {
+	return inject(sideNavCollapseKey, fallbackCollapse);
+}
+//#endregion
+export { useSideNavRenderMode as i, sideNavRenderModeKey as n, useSideNavCollapse as r, sideNavCollapseKey as t };

package/dist/context-Cfjh8te1.js

@@ -0,0 +1,29 @@
+import { computed, inject } from "vue";
+//#region src/FormLayout/context.ts
+const formLayoutKey = Symbol("astryx-form-layout");
+function useFormLayout() {
+	return inject(formLayoutKey, computed(() => null));
+}
+/**
+* 没有 FormLayout 时保持原来的 aria-required。
+* 有默认必填时，没标 optional 的字段也要报必填，但不写原生 required。
+* 两个标记同时出现时，optional 优先。
+*/
+function ariaRequired(isRequired, isOptional, optionality) {
+	if (isOptional) return void 0;
+	if (optionality == null) return isRequired ? true : void 0;
+	if (optionality === "required" || isRequired) return true;
+}
+function useAriaRequired(props) {
+	const layout = useFormLayout();
+	return computed(() => ariaRequired(props.isRequired, props.isOptional, layout.value?.defaultOptionality));
+}
+function showsOptionalIndicator(isOptional, _isRequired, optionality) {
+	return Boolean(isOptional) && optionality !== "optional";
+}
+function showsRequiredIndicator(isRequired, isOptional, optionality) {
+	if (isOptional) return false;
+	return Boolean(isRequired) && optionality !== "required";
+}
+//#endregion
+export { useFormLayout as a, useAriaRequired as i, showsOptionalIndicator as n, showsRequiredIndicator as r, formLayoutKey as t };

package/dist/{context-BshXcNYX.js → context-D6ECRdc5.js}

@@ -73,6 +73,36 @@ const citationMessages = {
 	"zh-CN": { label: (number, title) => `引用 ${number}：${title}` }
 };
 //#endregion
+//#region src/locale/messages/command-palette.ts
+const commandPaletteMessages = {
+	"en": {
+		label: "Command palette",
+		emptySearch: "No results",
+		emptyBootstrap: "Type to search",
+		placeholder: "Search…",
+		listLabel: "Commands",
+		loading: "Loading",
+		noResultsFor: (query) => `No results for ${query}`,
+		resultCount: (count) => `${count} ${count === 1 ? "result" : "results"}`,
+		navigate: "Navigate",
+		select: "Select",
+		close: "Close"
+	},
+	"zh-CN": {
+		label: "命令面板",
+		emptySearch: "没有结果",
+		emptyBootstrap: "输入以搜索",
+		placeholder: "搜索…",
+		listLabel: "命令",
+		loading: "正在加载",
+		noResultsFor: (query) => `没有与 ${query} 匹配的结果`,
+		resultCount: (count) => `${count} 个结果`,
+		navigate: "移动",
+		select: "选择",
+		close: "关闭"
+	}
+};
+//#endregion
 //#region src/locale/messages/shared.ts
 function clearLabel(label, fallback, prefix) {
 	return label != null && label !== "" ? `${prefix}${label}` : fallback;
@@ -150,6 +180,22 @@ const fileInputMessages = {
 	}
 };
 //#endregion
+//#region src/locale/messages/layout.ts
+const layoutMessages = {
+	"en": {
+		skipToContent: "Skip to content",
+		resizeHandle: "Resize handle",
+		collapsed: "Collapsed",
+		mobileNavigation: "Navigation"
+	},
+	"zh-CN": {
+		skipToContent: "跳到正文",
+		resizeHandle: "拖拽分隔条",
+		collapsed: "已收起",
+		mobileNavigation: "导航"
+	}
+};
+//#endregion
 //#region src/locale/messages/markdown.ts
 const markdownMessages = {
 	"en": {
@@ -209,6 +255,7 @@ const navMessages = {
 		collapseSidebar: "Collapse sidebar",
 		expandSidebar: "Expand sidebar",
 		openMenu: "Open menu",
+		openNavigation: "Open navigation",
 		close: "Close",
 		more: "More",
 		moreItems: (count) => `${count} more`,
@@ -223,6 +270,7 @@ const navMessages = {
 		collapseSidebar: "收起侧边栏",
 		expandSidebar: "展开侧边栏",
 		openMenu: "打开菜单",
+		openNavigation: "打开导航",
 		close: "关闭",
 		more: "更多",
 		moreItems: (count) => `还有 ${count} 项`,
@@ -286,6 +334,36 @@ const selectorMessages = {
 	}
 };
 //#endregion
+//#region src/locale/messages/stepper.ts
+const stepperMessages = {
+	"en": {
+		progress: "Progress",
+		optional: "Optional",
+		previous: "Previous step",
+		next: "Next step",
+		goToStep: (step) => `Go to step ${step}`,
+		goToStepWithStatus: (step, status) => `Go to step ${step}, ${status}`,
+		status: {
+			completed: "Completed",
+			warning: "Warning",
+			error: "Error"
+		}
+	},
+	"zh-CN": {
+		progress: "进度",
+		optional: "可选",
+		previous: "上一步",
+		next: "下一步",
+		goToStep: (step) => `转到第 ${step} 步`,
+		goToStepWithStatus: (step, status) => `转到第 ${step} 步，${status}`,
+		status: {
+			completed: "已完成",
+			warning: "警告",
+			error: "错误"
+		}
+	}
+};
+//#endregion
 //#region src/locale/messages/table.ts
 const tableMessages = {
 	"en": {
@@ -444,10 +522,12 @@ const astryxMessages = {
 		calendar: calendarMessages.en,
 		chat: chatMessages.en,
 		citation: citationMessages.en,
+		commandPalette: commandPaletteMessages.en,
 		dateInput: dateInputMessages.en,
 		dateRangeInput: dateRangeInputMessages.en,
 		dateTimeInput: dateTimeInputMessages.en,
 		fileInput: fileInputMessages.en,
+		layout: layoutMessages.en,
 		markdown: markdownMessages.en,
 		metadataList: metadataListMessages.en,
 		multiSelector: multiSelectorMessages.en,
@@ -455,6 +535,7 @@ const astryxMessages = {
 		numberInput: numberInputMessages.en,
 		pagination: paginationMessages.en,
 		selector: selectorMessages.en,
+		stepper: stepperMessages.en,
 		table: tableMessages.en,
 		thumbnail: thumbnailMessages.en,
 		timeInput: timeInputMessages.en,
@@ -468,10 +549,12 @@ const astryxMessages = {
 		calendar: calendarMessages["zh-CN"],
 		chat: chatMessages["zh-CN"],
 		citation: citationMessages["zh-CN"],
+		commandPalette: commandPaletteMessages["zh-CN"],
 		dateInput: dateInputMessages["zh-CN"],
 		dateRangeInput: dateRangeInputMessages["zh-CN"],
 		dateTimeInput: dateTimeInputMessages["zh-CN"],
 		fileInput: fileInputMessages["zh-CN"],
+		layout: layoutMessages["zh-CN"],
 		markdown: markdownMessages["zh-CN"],
 		metadataList: metadataListMessages["zh-CN"],
 		multiSelector: multiSelectorMessages["zh-CN"],
@@ -479,6 +562,7 @@ const astryxMessages = {
 		numberInput: numberInputMessages["zh-CN"],
 		pagination: paginationMessages["zh-CN"],
 		selector: selectorMessages["zh-CN"],
+		stepper: stepperMessages["zh-CN"],
 		table: tableMessages["zh-CN"],
 		thumbnail: thumbnailMessages["zh-CN"],
 		timeInput: timeInputMessages["zh-CN"],