f3e21c6b98
Accumulated uncommitted work: GHOST Web backend, WebGL/GPU web layer, web workflow engine and protocol, tooling, docs and task records. Large generated evidence, user-testing archives, build snapshots and imported test assets remain untracked. Co-Authored-By: Claude Code <noreply@anthropic.com>
1704 lines
140 KiB
TypeScript
1704 lines
140 KiB
TypeScript
import { blockedGate, capabilityIssue, readyGate, type CapabilityGateResult } from "./capability-gates";
|
|
import type { ErrorCode } from "./error";
|
|
import type {NativeUVPackOptions} from './uv-pack-options';
|
|
import {parseNativeUVPackTarget,type NativeUVPackTarget} from './uv-pack-target';
|
|
import {parseNativeUVBounds,type NativeUVBounds,type NativeUVCustomRegion} from './uv-custom-region';
|
|
import type { NativeViewportState } from './viewport-camera';
|
|
import { isModifierCurveProfile } from './modifier';
|
|
|
|
export const EDITOR_WORKFLOW_SCHEMA = 1 as const;
|
|
export const EDITOR_WORKFLOW_BUDGET = { maxWorkspaces: 64, maxAreas: 1_024, maxRegions: 4_096, maxSelection: 100_000, maxKeymaps: 4_096, maxPropertiesDataFields: 128 } as const;
|
|
export const EDITOR_TYPES = ["VIEW_3D", "OUTLINER", "PROPERTIES", "UV_IMAGE", "NODE", "GRAPH", "DOPE_SHEET", "NLA", "SPREADSHEET", "TIMELINE", "CLIP", "MASK", "SEQUENCER", "TEXT", "CONSOLE", "INFO", "FILE_BROWSER", "PREFERENCES", "TOPBAR", "STATUSBAR", "UNSUPPORTED"] as const;
|
|
export type EditorTypeIR = typeof EDITOR_TYPES[number];
|
|
export type EditorRegionKind = "HEADER" | "MAIN" | "TOOLBAR" | "SIDEBAR" | "FOOTER" | "OTHER";
|
|
export const EDITOR_MODES = ["OBJECT", "EDIT", "POSE", "SCULPT", "TEXTURE_PAINT", "VERTEX_PAINT", "WEIGHT_PAINT"] as const;
|
|
export type EditorMode = typeof EDITOR_MODES[number];
|
|
export const GRAPH_INTERPOLATION_MODES = [
|
|
["CONSTANT", "Constant", "Interpolation"], ["LINEAR", "Linear", "Interpolation"], ["BEZIER", "Bézier", "Interpolation"],
|
|
["SINE", "Sinusoidal", "Easing (by strength)"], ["QUAD", "Quadratic", "Easing (by strength)"],
|
|
["CUBIC", "Cubic", "Easing (by strength)"], ["QUART", "Quartic", "Easing (by strength)"], ["QUINT", "Quintic", "Easing (by strength)"],
|
|
["EXPO", "Exponential", "Easing (by strength)"], ["CIRC", "Circular", "Easing (by strength)"],
|
|
["BACK", "Back", "Dynamic Effects"], ["BOUNCE", "Bounce", "Dynamic Effects"], ["ELASTIC", "Elastic", "Dynamic Effects"],
|
|
] as const;
|
|
export type GraphInterpolation = typeof GRAPH_INTERPOLATION_MODES[number][0];
|
|
|
|
export interface EditorRegionIR { id: string; kind: EditorRegionKind; visible: boolean; active?: boolean; quadView?: boolean; toggleable?: boolean; flippable?: boolean; alignment?: 'TOP' | 'BOTTOM' | 'LEFT' | 'RIGHT' | 'OTHER' }
|
|
export interface TextCursorIR { line: number; column: number }
|
|
export const UV_UNWRAP_METHODS = ['ANGLE_BASED', 'CONFORMAL', 'MINIMUM_STRETCH'] as const;
|
|
export type NativeUVTransform = { mode: 'TRANSLATE'; value: [number,number] } | (({ mode: 'SCALE'; value: [number,number] } | { mode: 'ROTATE'; angle: number }) & { center?: [number,number] });
|
|
export const UV_SELECTION_MODES = ['VERTEX', 'EDGE', 'FACE'] as const;
|
|
export const UV_STICKY_MODES = ['DISABLED', 'SHARED_LOCATION', 'SHARED_VERTEX'] as const;
|
|
export type NativeUVEdit = { operation: 'SET_PACK_TILE'; tile: number } | { operation: 'CUSTOM_REGION_SET'; bounds: NativeUVBounds } | { operation: 'CUSTOM_REGION_ENABLE'; enabled: boolean } | { operation: 'PACK_ISLANDS'; options: NativeUVPackOptions } | { operation: 'SELECT_STICKY'; mode: typeof UV_STICKY_MODES[number] } | { operation: 'SELECT_MODE'; mode: typeof UV_SELECTION_MODES[number] } | { operation: 'SELECT_SYNC' | 'SELECT_ISLAND'; enabled: boolean } |
|
|
{ operation: 'SELECT'; location: [number, number]; pixelsPerUV: number; toggle?: boolean } | { operation: 'SELECT_ALL' | 'DESELECT_ALL' | 'INVERT_SELECTION' | 'PIN' | 'UNPIN' | 'INVERT_PIN' } | { operation: 'UNWRAP'; options: NativeUVUnwrapOptions } | { operation: 'TRANSFORM'; transform: NativeUVTransform } | { operation: 'STITCH'; options: NativeUVStitchOptions };
|
|
export const UV_STITCH_BOOLEANS = ['use_limit','snap_islands','midpoint_snap','clear_seams'] as const;
|
|
export type NativeUVStitchOptions = Partial<Record<typeof UV_STITCH_BOOLEANS[number],boolean> & {mode:'VERTEX'|'EDGE';limit:number;static_island:number;active_object_index:number}>;
|
|
export const UV_UNWRAP_MARGIN_METHODS = ['SCALED', 'ADD', 'FRACTION'] as const;
|
|
export const UV_UNWRAP_BOOLEANS = ['fill_holes', 'correct_aspect', 'use_subsurf_data', 'use_original_bounds', 'no_flip', 'use_weights'] as const;
|
|
export type NativeUVUnwrapOptions = Partial<Record<typeof UV_UNWRAP_BOOLEANS[number], boolean> & {
|
|
method: typeof UV_UNWRAP_METHODS[number]; margin_method: typeof UV_UNWRAP_MARGIN_METHODS[number];
|
|
margin: number; iterations: number; weight_factor: number; weight_group: string;
|
|
}>;
|
|
export interface TextSelectionIR { anchor: TextCursorIR; focus: TextCursorIR }
|
|
export interface NativeTextEdit { operation: 'INDENT' | 'UNINDENT' | 'DUPLICATE_LINE' | 'COMMENT_TOGGLE' | 'COMMENT' | 'UNCOMMENT' | 'LINE_BREAK' | 'WHITESPACE_SPACES' | 'WHITESPACE_TABS' | 'DELETE_PREVIOUS_CHARACTER' | 'DELETE_NEXT_CHARACTER' | 'DELETE_PREVIOUS_WORD' | 'DELETE_NEXT_WORD'; dataId: string; source: string; selection: TextSelectionIR }
|
|
export interface NativeImageView { zoom: number; offsetX: number; offsetY: number; width: number; height: number; aspectX: number; aspectY: number }
|
|
export const PROPERTIES_OBJECT_BOOLEAN_FIELDS = ['hide_viewport', 'hide_render', 'hide_select',
|
|
'show_name', 'show_axis', 'show_wire', 'show_all_edges', 'show_bounds', 'use_camera_lock_parent'] as const;
|
|
export const PROPERTIES_OBJECT_ENUM_FIELDS = ['display_type', 'display_bounds_type', 'rotation_mode', 'track_axis', 'up_axis'] as const;
|
|
export const PROPERTIES_OBJECT_RELATION_FIELDS = ['use_camera_lock_parent', 'track_axis', 'up_axis'] as const;
|
|
export type PropertiesObjectRelationField = typeof PROPERTIES_OBJECT_RELATION_FIELDS[number];
|
|
export type PropertiesObjectField = typeof PROPERTIES_OBJECT_BOOLEAN_FIELDS[number] | typeof PROPERTIES_OBJECT_ENUM_FIELDS[number];
|
|
export const PROPERTIES_OBJECT_TRANSFORM_LENGTHS = {
|
|
location: 3, rotation_euler: 3, rotation_quaternion: 4, rotation_axis_angle: 4, scale: 3, dimensions: 3,
|
|
delta_location: 3, delta_rotation_euler: 3, delta_rotation_quaternion: 4, delta_scale: 3,
|
|
} as const;
|
|
export type PropertiesObjectTransform = keyof typeof PROPERTIES_OBJECT_TRANSFORM_LENGTHS;
|
|
export const PROPERTIES_OBJECT_LOCK_LENGTHS = {
|
|
lock_location: 3, lock_rotation: 3, lock_scale: 3, lock_rotation_w: 1, lock_rotations_4d: 1,
|
|
} as const;
|
|
export type PropertiesObjectLock = keyof typeof PROPERTIES_OBJECT_LOCK_LENGTHS;
|
|
export interface NativePropertiesLock {
|
|
id: PropertiesObjectLock;
|
|
label: string;
|
|
values: boolean[];
|
|
editable: boolean[];
|
|
}
|
|
export interface NativePropertiesTransform {
|
|
id: PropertiesObjectTransform;
|
|
label: string;
|
|
values: number[];
|
|
editable: boolean[];
|
|
minimum: number;
|
|
maximum: number;
|
|
}
|
|
export type PropertiesParentSetting = 'parent_vertices' | 'use_parent_final_indices' | 'parent_bone_head_tail_factor';
|
|
export interface NativePropertiesParentSetting {
|
|
id: PropertiesParentSetting;
|
|
index: number;
|
|
label: string;
|
|
value: number | boolean;
|
|
minimum: number;
|
|
maximum: number;
|
|
editable: boolean;
|
|
}
|
|
export interface NativePropertiesObject {
|
|
id: string;
|
|
name: string;
|
|
meshId?: string | null;
|
|
fields: Array<{ id: PropertiesObjectField; label: string; editable: boolean;
|
|
value: boolean | string; items: Array<{ id: string; label: string }> }>;
|
|
transforms?: NativePropertiesTransform[];
|
|
deltaTransforms?: NativePropertiesTransform[];
|
|
dimensions?: NativePropertiesTransform[];
|
|
locks?: NativePropertiesLock[];
|
|
relations?: {
|
|
parentId: string | null;
|
|
parentName: string | null;
|
|
editable: boolean;
|
|
candidates: Array<{ id: string; name: string }>;
|
|
truncated: boolean;
|
|
parenting?: {
|
|
type: string | null;
|
|
types: Array<{ id: string; label: string }>;
|
|
typeEditable: boolean;
|
|
bone: string;
|
|
boneEditable: boolean;
|
|
bones: string[];
|
|
bonesTruncated: boolean;
|
|
settings?: NativePropertiesParentSetting[];
|
|
};
|
|
};
|
|
modifiers?: Array<{
|
|
uuid: string;
|
|
type: string;
|
|
name: string;
|
|
enabled: boolean;
|
|
showViewport: boolean;
|
|
showRender: boolean;
|
|
showEditMode?: boolean;
|
|
showOnCage?: boolean;
|
|
diagnostics?: Array<{ kind: 'INFO' | 'ERROR'; message: string }>;
|
|
bind?: { bound: boolean; enabled: boolean; reason: string };
|
|
duplicate?: { enabled: boolean; reason: string };
|
|
apply?: { enabled: boolean; reason: string; requiresSingleUser: boolean; supportsAllKeyframes?: boolean; supportsMergeCustomData?: boolean };
|
|
applyAsShapeKey?: { enabled: boolean; reason: string };
|
|
copyToSelected?: { enabled: boolean; reason: string; targets: string[] };
|
|
skinActions?: Array<{ id: 'CREATE_ARMATURE' | 'ADD_SKIN_DATA' | 'MARK_LOOSE' | 'CLEAR_LOOSE' | 'MARK_ROOT' | 'EQUALIZE_RADII'; label: string; enabled: boolean; reason: string }>;
|
|
hookActions?: Array<{ id: 'RESET' | 'RECENTER' | 'SELECT' | 'ASSIGN'; label: string; enabled: boolean; reason: string }>;
|
|
dataLayoutActions?: Array<{ id: 'GENERATE_DATA_LAYERS'; label: string; enabled: boolean; reason: string }>;
|
|
multiresActions?: Array<{ id: 'DELETE_HIGHER_LEVELS' | 'SUBDIVIDE' | 'RESHAPE' | 'BASE_APPLY' | 'UNSUBDIVIDE' | 'REBUILD_SUBDIV' | 'EXTERNAL_SAVE' | 'EXTERNAL_PACK'; label: string; enabled: boolean; reason: string }>;
|
|
parameters: Record<string, unknown>;
|
|
editableParameters?: Array<{ key: string; label?: string; description?: string; editable?: boolean; nullable?: boolean; visible?: boolean; enabled?: boolean; suggestionsOnly?: boolean; maxLength?: number; unit?: 'ANGLE'; kind: 'boolean' | 'number' | 'enum' | 'enum_set' | 'object' | 'collection' | 'texture' | 'cachefile' | 'curve_mapping' | 'string' | 'profile'; value: unknown; integer: boolean; length: number; minimum?: number; maximum?: number; items?: Array<{ id: string; label: string }> }>;
|
|
}>;
|
|
modifierTypes?: Array<{ id: string; label: string; category: string; enabled: boolean; reason: string }>;
|
|
activeModifierUuid?: string | null;
|
|
constraints?: Array<{ reorderable?: boolean; name: string; type: string; enabled: boolean; influence: number; targetObjectId?: string | null; targetBoneName?: string }>;
|
|
activeConstraintName?: string | null;
|
|
stackEditable?: boolean;
|
|
constraintTargets?: Array<{ id: string; name: string; kind: 'ARMATURE' | 'CURVE' | 'MESH' | 'LATTICE' | 'OTHER'; bones: string[]; vertexGroups?: string[] }>;
|
|
poseBones?: string[];
|
|
poseConstraints?: Array<{ reorderable?: boolean; targetBoneName?: string; boneName: string; name: string; type: string; enabled: boolean; influence: number; targetObjectId?: string | null }>;
|
|
activePoseConstraint?: { boneName: string; name: string } | null;
|
|
}
|
|
export type PropertiesDataValue = boolean | number | string | number[];
|
|
export interface NativeArmatureConstraintTarget {
|
|
objectId: string;
|
|
bone: string;
|
|
weight: number;
|
|
}
|
|
export interface NativePropertiesDataField {
|
|
id: string;
|
|
label: string;
|
|
description?: string;
|
|
editable: boolean;
|
|
value: PropertiesDataValue;
|
|
integer?: boolean;
|
|
arrayLayout?: 'COLOR' | 'VECTOR' | 'MATRIX' | 'SEQUENCE';
|
|
minimum?: number;
|
|
maximum?: number;
|
|
status?: string;
|
|
items: Array<{ id: string; label: string }>;
|
|
}
|
|
export interface NativePropertiesData {
|
|
lightgroups?: { sceneId: string; layerName: string; editable: boolean; activeIndex: number; rows: string[] };
|
|
aovs?: { sceneId: string; layerName: string; editable: boolean; activeIndex: number; rows: Array<{ name: string; type: 0 | 1; isValid: boolean }> };
|
|
id: string;
|
|
name: string;
|
|
fields: NativePropertiesDataField[];
|
|
shapeKeys?: {
|
|
objectId: string;
|
|
keyId: string;
|
|
activeUid: number;
|
|
editable: boolean;
|
|
rows: Array<{ uid: number; name: string; selected: boolean; muted: boolean; locked: boolean; fields?: NativePropertiesDataField[] }>;
|
|
operations: Array<{ id: string; label: string; enabled: boolean; reason: string; sources?: string[] }>;
|
|
};
|
|
shapeKeyMirror?: {
|
|
objectId: string; keyId: string; activeUid: number; name: string;
|
|
enabled: boolean; topologyEnabled: boolean; reason: string;
|
|
};
|
|
constraintOperations?: Array<{ id: string; label: string; description: string; enabled: boolean; reason: string; menu?: boolean;
|
|
parameters?: Array<{ id: string; label: string; description: string; defaultValue: number; minimum: number; maximum: number }> }>;
|
|
armatureTargets?: NativeArmatureConstraintTarget[];
|
|
targetsEditable?: boolean;
|
|
armatures?: Array<{ id: string; name: string; bones: string[] }>;
|
|
cacheLayers?: Array<{ filepath: string; hidden: boolean }>;
|
|
cacheActiveLayer?: number;
|
|
cacheLayersEditable?: boolean;
|
|
}
|
|
export interface NativePropertiesContext {
|
|
context: string | null;
|
|
contexts: Array<{ id: string; label: string }>;
|
|
viewLayers?: Array<{ name: string; active: boolean; editable: boolean }>;
|
|
pinned: boolean;
|
|
canPin: boolean;
|
|
pinId: string | null;
|
|
pinName: string | null;
|
|
outlinerSync?: { value: string | null; items: Array<{ id: string; label: string }>; editable: boolean };
|
|
object?: NativePropertiesObject | null;
|
|
data?: NativePropertiesData | null;
|
|
}
|
|
export interface NativeSpreadsheetRule {
|
|
enabled: boolean;
|
|
show_expanded: boolean;
|
|
column_name: string;
|
|
operation: 'EQUAL' | 'GREATER' | 'LESS';
|
|
value_float: number;
|
|
value_int: number;
|
|
value_float2: [number, number];
|
|
value_float3: [number, number, number];
|
|
value_float4: [number, number, number, number];
|
|
value_color: [number, number, number, number];
|
|
value_int2: [number, number];
|
|
value_int3: [number, number, number];
|
|
value_string: string;
|
|
value_boolean: boolean;
|
|
threshold: number;
|
|
}
|
|
export const SPREADSHEET_CONTEXT_PROPERTIES = ['object_eval_state', 'geometry_component_type', 'attribute_domain'] as const;
|
|
export type SpreadsheetContextProperty = typeof SPREADSHEET_CONTEXT_PROPERTIES[number];
|
|
export const SPREADSHEET_VALUE_PROPERTIES = ['value_float', 'value_int', 'value_boolean', 'value_string',
|
|
'value_float2', 'value_float3', 'value_float4', 'value_color', 'value_int2', 'value_int3'] as const;
|
|
export interface NativeSpreadsheetColumn {
|
|
name: string;
|
|
valueProperty: typeof SPREADSHEET_VALUE_PROPERTIES[number] | null;
|
|
comparison: boolean;
|
|
threshold: boolean;
|
|
}
|
|
export type SpreadsheetClosure = 'NONE' | 'INPUT' | 'OUTPUT';
|
|
export type SpreadsheetNavigationTarget = 'VIEWER_OUTPUTS' | 'VIEWER_BUNDLE_CHILDREN' | 'GEOMETRY_BUNDLE_CHILDREN' | 'INSTANCE_REFERENCES';
|
|
export interface NativeSpreadsheetBundleNavigation {
|
|
active: boolean;
|
|
available: boolean;
|
|
path: string[];
|
|
pathValid: boolean;
|
|
closure: SpreadsheetClosure;
|
|
hasInputs: boolean;
|
|
hasOutputs: boolean;
|
|
children: string[];
|
|
childrenTruncated: boolean;
|
|
childrenPage: number;
|
|
childrenPageCount: number;
|
|
}
|
|
export interface NativeSpreadsheetViewerNavigation {
|
|
available: boolean;
|
|
itemIdentifier: number;
|
|
items: Array<{ identifier: number; label: string }>;
|
|
itemsTruncated: boolean;
|
|
itemsPage: number;
|
|
itemsPageCount: number;
|
|
selection: NativeSpreadsheetBundleNavigation;
|
|
}
|
|
export interface NativeSpreadsheetContext {
|
|
bundle?: NativeSpreadsheetBundleNavigation;
|
|
viewer?: NativeSpreadsheetViewerNavigation;
|
|
useFilter: boolean;
|
|
rules: NativeSpreadsheetRule[];
|
|
instances?: {
|
|
path: number[];
|
|
breadcrumbs: string[];
|
|
geometryAvailable: boolean;
|
|
pathValid: boolean;
|
|
children: Array<{ referenceIndex: number; label: string; userCount: number }>;
|
|
childrenTruncated: boolean;
|
|
childrenPage: number;
|
|
childrenPageCount: number;
|
|
};
|
|
viewState?: {
|
|
pinned: boolean;
|
|
canPin: boolean;
|
|
showOnlySelected: boolean;
|
|
selectionFilterAvailable: boolean;
|
|
dataSourceAvailable: boolean;
|
|
};
|
|
context?: Record<SpreadsheetContextProperty, { value: string | null; choices: Array<{ id: string; label: string }> }>;
|
|
columns?: NativeSpreadsheetColumn[];
|
|
columnsTruncated?: boolean;
|
|
}
|
|
export type SpreadsheetRuleEdit = { [K in keyof NativeSpreadsheetRule]: {
|
|
operation: 'UPDATE_RULE'; index: number; property: K; value: NativeSpreadsheetRule[K];
|
|
} }[keyof NativeSpreadsheetRule];
|
|
export type NativeSpreadsheetEdit =
|
|
| { operation: 'ADD_RULE' }
|
|
| { operation: 'REMOVE_RULE'; index: number }
|
|
| { operation: 'SET_FILTER'; enabled: boolean }
|
|
| { operation: 'SET_PIN'; pinned: boolean }
|
|
| { operation: 'SET_SELECTED_ONLY'; enabled: boolean }
|
|
| { operation: 'SET_INSTANCE_PATH'; path: number[] }
|
|
| { operation: 'SET_BUNDLE_PATH'; path: string[]; closure: SpreadsheetClosure }
|
|
| { operation: 'SET_VIEWER_PATH'; itemIdentifier: number; path: string[]; closure: SpreadsheetClosure }
|
|
| { operation: 'SET_NAVIGATION_PAGE'; target: SpreadsheetNavigationTarget; page: number }
|
|
| { operation: 'SET_CONTEXT'; property: SpreadsheetContextProperty; value: string }
|
|
| SpreadsheetRuleEdit;
|
|
|
|
export function validSpreadsheetBundlePath(value: unknown): value is string[] {
|
|
return Array.isArray(value) && value.length <= 64 && value.every(key =>
|
|
typeof key === 'string' && key.length > 0 && !key.includes('\0') &&
|
|
new TextEncoder().encode(key).byteLength <= 4096);
|
|
}
|
|
|
|
export function validSpreadsheetBundleSelection(
|
|
bundle: NativeSpreadsheetBundleNavigation, path: unknown, closure: unknown,
|
|
): boolean {
|
|
if (!bundle.available || !validSpreadsheetBundlePath(path) ||
|
|
!['NONE', 'INPUT', 'OUTPUT'].includes(closure as string)) return false;
|
|
const ancestor = path.length <= bundle.path.length && path.every((key, depth) => key === bundle.path[depth]);
|
|
if (closure === 'NONE' && ancestor) return true;
|
|
if (!bundle.pathValid) return false;
|
|
const same = ancestor && path.length === bundle.path.length;
|
|
if (same && ((closure === 'INPUT' && bundle.hasInputs) || (closure === 'OUTPUT' && bundle.hasOutputs))) return true;
|
|
return closure === 'NONE' && path.length === bundle.path.length + 1 &&
|
|
bundle.path.every((key, depth) => key === path[depth]) && bundle.children.includes(path[path.length - 1]);
|
|
}
|
|
|
|
export function validSpreadsheetInstancePath(value: unknown): value is number[] {
|
|
return Array.isArray(value) && value.length <= 64 &&
|
|
value.every(index => Number.isInteger(index) && index >= 0 && index <= 2147483647);
|
|
}
|
|
|
|
export function validSpreadsheetViewerSelection(
|
|
viewer: NativeSpreadsheetViewerNavigation, itemIdentifier: unknown, path: unknown, closure: unknown,
|
|
): boolean {
|
|
if (!viewer.available || !viewer.selection.active || !Number.isInteger(itemIdentifier) ||
|
|
!viewer.items.some(item => item.identifier === itemIdentifier) ||
|
|
!validSpreadsheetBundlePath(path)) return false;
|
|
if (path.length === 0 && closure === 'NONE') return true;
|
|
return itemIdentifier === viewer.itemIdentifier &&
|
|
validSpreadsheetBundleSelection(viewer.selection, path, closure);
|
|
}
|
|
|
|
export function validSpreadsheetRuleValue(property: string, value: unknown): boolean {
|
|
const numeric = (item: unknown, integral = false) => typeof item === 'number' && Number.isFinite(item) &&
|
|
(integral ? Number.isInteger(item) && item >= -2147483648 && item <= 2147483647 : Math.abs(item) <= 3.4028234663852886e38);
|
|
if (['enabled', 'show_expanded', 'value_boolean'].includes(property)) return typeof value === 'boolean';
|
|
if (property === 'column_name' || property === 'value_string') return typeof value === 'string' && !value.includes('\0') &&
|
|
new TextEncoder().encode(value).byteLength <= (property === 'column_name' ? 63 : 4096);
|
|
if (property === 'operation') return typeof value === 'string' && ['EQUAL', 'GREATER', 'LESS'].includes(value);
|
|
if (property === 'value_int') return numeric(value, true);
|
|
if (property === 'value_float' || property === 'threshold') return numeric(value) && (property !== 'threshold' || (value as number) >= 0);
|
|
const sizes: Record<string, number> = { value_float2: 2, value_float3: 3, value_float4: 4, value_color: 4, value_int2: 2, value_int3: 3 };
|
|
const size = sizes[property];
|
|
return size !== undefined && Array.isArray(value) && value.length === size && value.every(item => numeric(item, property.startsWith('value_int')));
|
|
}
|
|
export type NativeImageViewEdit = { dataId: string; viewport: { width: number; height: number } } & (
|
|
| { operation: 'FRAME_ALL' | 'FIT' }
|
|
| { operation: 'ZOOM_RATIO'; ratio: number }
|
|
| { operation: 'PAN'; pixelDelta: [number, number] }
|
|
| { operation: 'ZOOM_IN' | 'ZOOM_OUT'; pixelPosition: [number, number] }
|
|
| { operation: 'ZOOM_BORDER'; pixelBounds: [number, number, number, number]; zoomOut: boolean }
|
|
);
|
|
export interface NativeAreaLayout {
|
|
editorType: string;
|
|
editorTypes: { id: string; label: string }[];
|
|
joinTargets: string[];
|
|
editable: boolean;
|
|
screenState: 'NORMAL' | 'MAXIMIZED' | 'FULLSCREEN';
|
|
headerMenusVisible?: boolean;
|
|
}
|
|
export interface NativeOutlinerRow { id: string; label: string; depth: number; selected: boolean; active: boolean; expanded: boolean; hasChildren: boolean; objectId: string | null; remapId?: string | null }
|
|
export interface NativeOutlinerRemapID { id: string; name: string; idType: number; library: string; editable: boolean }
|
|
export interface NativeOutlinerTree { rows: NativeOutlinerRow[]; truncated: boolean; syncSelection: boolean; remapIds?: NativeOutlinerRemapID[] }
|
|
export interface EditorAreaIR { nativeLayout?: NativeAreaLayout; id: string; editor: EditorTypeIR; regions: EditorRegionIR[]; rect: { x: number; y: number; width: number; height: number }; maximized: boolean; filterText?: string; space?: { outliner?: NativeOutlinerTree; kind: string; dataId?: string | null; view?: NativeViewportState; textSelection?: TextSelectionIR; imageView?: NativeImageView; uvPackTarget?: NativeUVPackTarget; properties?: NativePropertiesContext; spreadsheet?: NativeSpreadsheetContext } }
|
|
export interface EditorWorkspaceIR { id: string; name: string; screenId?: string; writable?: boolean; areas: EditorAreaIR[]; activeAreaId: string; revision: number }
|
|
// ACTION operator RNA identifiers; the native caller resolves them against the
|
|
// registered operator before changing Main.
|
|
export const TIMELINE_KEY_TYPES = {
|
|
SET_KEY_INTERPOLATION: ['CONSTANT', 'LINEAR', 'BEZIER', 'SINE', 'QUAD', 'CUBIC', 'QUART', 'QUINT', 'EXPO', 'CIRC', 'BACK', 'BOUNCE', 'ELASTIC'],
|
|
SET_KEY_EASING: ['AUTO', 'EASE_IN', 'EASE_OUT', 'EASE_IN_OUT'],
|
|
SET_KEY_HANDLE: ['FREE', 'ALIGNED', 'VECTOR', 'AUTO', 'AUTO_CLAMPED'],
|
|
SET_KEY_TYPE: ['KEYFRAME', 'BREAKDOWN', 'MOVING_HOLD', 'EXTREME', 'JITTER', 'GENERATED'],
|
|
SNAP_KEYS: ['CFRA', 'NEAREST_FRAME', 'NEAREST_SECOND', 'NEAREST_MARKER'],
|
|
MIRROR_KEYS: ['CFRA', 'MARKER', 'XAXIS'],
|
|
} as const;
|
|
export type NativeTimelineKeySetting = {
|
|
[K in keyof typeof TIMELINE_KEY_TYPES]: { operation: K; type: typeof TIMELINE_KEY_TYPES[K][number] }
|
|
}[keyof typeof TIMELINE_KEY_TYPES];
|
|
// Shared with ACTION_OT_paste's original keyframes_general.cc RNA enums.
|
|
export const TIMELINE_PASTE_OFFSETS = ['START', 'END', 'RELATIVE', 'NONE'] as const;
|
|
export const TIMELINE_PASTE_MERGES = ['MIX', 'OVER_ALL', 'OVER_RANGE', 'OVER_RANGE_ALL'] as const;
|
|
export const TIMELINE_KEY_COLUMN_MODES = ['KEYS', 'CFRA', 'MARKERS_COLUMN', 'MARKERS_BETWEEN'] as const;
|
|
export type NativeTimelineEdit =
|
|
| { operation: 'SELECT_FRAME_KEYS'; frame: number; extend: boolean; deselect: boolean }
|
|
| { operation: 'SELECT_KEY_COLUMNS'; mode: typeof TIMELINE_KEY_COLUMN_MODES[number] }
|
|
| { operation: 'SELECT_KEYS_SIDE'; side: 'LEFT' | 'RIGHT'; extend: boolean }
|
|
| NativeTimelineKeySetting
|
|
| { operation: 'COPY_KEYS' }
|
|
| { operation: 'DUPLICATE_MOVE_KEYS' | 'MOVE_KEYS'; delta: number }
|
|
| { operation: 'SCALE_KEYS'; factor: number }
|
|
| { operation: 'PASTE_KEYS'; offset: typeof TIMELINE_PASTE_OFFSETS[number];
|
|
merge: typeof TIMELINE_PASTE_MERGES[number]; flipped: boolean }
|
|
| { operation: 'DELETE_KEYS' | 'JUMP_SELECTED_KEYS' }
|
|
| { operation: 'FRAME_ALL_KEYS' | 'FRAME_SELECTED_KEYS' | 'CENTER_CURRENT_FRAME' |
|
|
'SELECT_ALL_KEYS' | 'DESELECT_ALL_KEYS' | 'INVERT_KEYS' |
|
|
'PREVIEW_SELECTED_KEYS' | 'CLEAR_PREVIEW_RANGE' }
|
|
| { operation: 'PLAY_FORWARD' | 'PLAY_REVERSE' | 'PAUSE_PLAYBACK' | 'CANCEL_PLAYBACK' }
|
|
| { operation: 'FRAME_OFFSET' | 'MOVE_MARKERS' | 'DUPLICATE_MARKERS'; delta: number }
|
|
| { operation: 'JUMP_START' | 'JUMP_END' | 'PREVIOUS_KEYFRAME' | 'NEXT_KEYFRAME' | 'PREVIOUS_MARKER' | 'NEXT_MARKER' |
|
|
'ADD_MARKER' | 'DELETE_MARKERS' | 'SELECT_ALL_MARKERS' | 'DESELECT_ALL_MARKERS' | 'INVERT_MARKERS' }
|
|
| { operation: 'RENAME_MARKER'; name: string };
|
|
// Playback needs the native WM timer/event pump; synchronous edits use registered storage.
|
|
export function isNativeTimelinePlayback(edit: NativeTimelineEdit): boolean {
|
|
return ['PLAY_FORWARD', 'PLAY_REVERSE', 'PAUSE_PLAYBACK', 'CANCEL_PLAYBACK'].includes(edit.operation);
|
|
}
|
|
export type NativeView3DNavigation =
|
|
| { operation: 'FRAME_ALL' | 'FRAME_SELECTED'; allRegions: boolean }
|
|
| { operation: 'VIEW_AXIS'; axis: 'FRONT' | 'BACK' | 'LEFT' | 'RIGHT' | 'TOP' | 'BOTTOM'; alignActive: boolean }
|
|
| { operation: 'PAN' | 'ORBIT'; direction: 'LEFT' | 'RIGHT' | 'UP' | 'DOWN' }
|
|
| { operation: 'ROLL'; direction: 'LEFT' | 'RIGHT' }
|
|
| { operation: 'ZOOM'; delta: -1 | 1 }
|
|
| { operation: 'ZOOM_BORDER' }
|
|
| { operation: 'TOGGLE_PROJECTION' | 'TOGGLE_CAMERA' | 'TOGGLE_LOCAL_VIEW' | 'REMOVE_FROM_LOCAL_VIEW' };
|
|
export type NativeView3DSelection =
|
|
| { operation: 'SELECT_ALL' | 'DESELECT_ALL' | 'INVERT_SELECTION' }
|
|
| { operation: 'GP_SELECT_MODE'; mode: 'POINT' | 'STROKE' | 'SEGMENT' }
|
|
| { operation: 'GP_SELECT_PICK'; x: number; y: number; coordinateSpace?: 'WINDOW' | 'REGION'; deselectAll?: boolean }
|
|
| { operation: 'GP_SELECT_LINKED'; deselect: boolean }
|
|
| { operation: 'GP_SELECT_ALTERNATE'; deselectEnds: boolean }
|
|
| { operation: 'GP_SELECT_ENDS'; amountStart: number; amountEnd: number }
|
|
| { operation: 'GP_SELECT_SIMILAR'; mode: 'LAYER' | 'MATERIAL' | 'VERTEX_COLOR' | 'RADIUS' | 'OPACITY'; threshold: number }
|
|
| { operation: 'GP_SELECT_RANDOM'; ratio: number; seed: number }
|
|
| { operation: 'GP_SELECT_FILL' }
|
|
| { operation: 'GP_SELECT_MATERIAL'; deselect: boolean }
|
|
| { operation: 'GP_SELECT_BY_STROKE_TYPE'; type: 'STROKE' | 'FILL'; deselect: boolean }
|
|
| { operation: 'TEXT_SELECT_ALL' | 'TEXT_DESELECT_ALL' | 'TEXT_SELECT_WORD' | 'TEXT_SELECT_POINTER' }
|
|
| { operation: 'TEXT_MOVE'; extend: boolean;
|
|
type: 'LINE_BEGIN' | 'LINE_END' | 'TEXT_BEGIN' | 'TEXT_END' |
|
|
'PREVIOUS_CHARACTER' | 'NEXT_CHARACTER' | 'PREVIOUS_WORD' | 'NEXT_WORD' |
|
|
'PREVIOUS_LINE' | 'NEXT_LINE' | 'PREVIOUS_PAGE' | 'NEXT_PAGE' }
|
|
| { operation: 'SET_PAINT_MASK'; domain: 'NONE' | 'FACE' | 'VERTEX' }
|
|
| { operation: 'PAINT_HIDE'; unselected: boolean }
|
|
| { operation: 'PAINT_REVEAL'; select: boolean }
|
|
| { operation: 'PAINT_SELECT_UNGROUPED'; extend: boolean }
|
|
// WINDOW uses top-left canvas backing pixels; omitted/REGION uses native mval.
|
|
| { operation: 'SELECT_LINKED_PICK'; select: boolean; x: number; y: number; coordinateSpace?: 'WINDOW' | 'REGION' }
|
|
| { operation: 'SELECT_NEXT_ACTIVE' | 'SELECT_PREVIOUS_ACTIVE' }
|
|
| { operation: 'SELECT_EDGE_LOOPS'; delimit?: ('SEAM' | 'SHARP' | 'NGONS' | 'INNER_CORNERS' | 'OUTER_CORNERS')[] }
|
|
| { operation: 'SELECT_EDGE_RINGS'; delimit?: ('SEAM' | 'SHARP' | 'MATERIAL' | 'NGONS')[] }
|
|
| { operation: 'SELECT_BOUNDARY_LOOPS'; extend: boolean;
|
|
delimit?: ('SEAM' | 'SHARP' | 'NGONS' | 'INNER_CORNERS' | 'OUTER_CORNERS')[] }
|
|
| { operation: 'LOOP_TO_REGION'; selectBigger: boolean }
|
|
| { operation: 'REGION_TO_LOOP' }
|
|
| { operation: 'SELECT_SHORTEST_PATH'; useFaceStep: boolean; useTopologyDistance: boolean; useFill: boolean;
|
|
edgeMode?: 'SELECT' | 'SEAM' | 'SHARP' | 'CREASE' | 'BEVEL' | 'FREESTYLE';
|
|
skip: number; nth: number; offset: number }
|
|
| { operation: 'SELECT_LINKED_FLAT_FACES'; sharpnessDegrees: number }
|
|
| { operation: 'SELECT_MORE' | 'SELECT_LESS'; useFaceStep: boolean }
|
|
| { operation: 'SELECT_HIERARCHY'; direction: 'PARENT' | 'CHILD'; extend: boolean }
|
|
| { operation: 'SELECT_LINKED'; objectType: 'OBDATA' | 'MATERIAL' | 'DUPGROUP' | 'PARTICLE' | 'LIBRARY' | 'LIBRARY_OBDATA';
|
|
extend: boolean; delimit?: ('NORMAL' | 'MATERIAL' | 'SEAM' | 'SHARP' | 'UV')[] }
|
|
| { operation: 'BOX' | 'CIRCLE' }
|
|
| { operation: 'LASSO'; mode: 'SET' | 'ADD' | 'SUB' | 'XOR' | 'AND' };
|
|
export type EditorContextEdit = { workspaceId: string; screenId: string } & (
|
|
| { action: "SWITCH_WORKSPACE" }
|
|
| { action: "SET_ACTIVE_AREA"; areaId: string }
|
|
| ({ action: 'TIMELINE_EDIT'; areaId: string } & NativeTimelineEdit)
|
|
| ({ action: 'VIEW3D_NAVIGATE'; areaId: string; regionId: string } & NativeView3DNavigation)
|
|
| ({ action: 'VIEW3D_SELECT'; areaId: string; regionId: string } & NativeView3DSelection)
|
|
| { action: 'OUTLINER_REFRESH'; areaId: string }
|
|
| { action: 'OUTLINER_TOGGLE_EXPAND'; areaId: string; rowId: string; toggleAll: boolean }
|
|
| { action: 'OUTLINER_TREE_SELECT'; areaId: string; rowId: string; extend: boolean; range: boolean; activateData?: boolean; activateProperties?: boolean; recursive?: boolean }
|
|
| { action: 'OUTLINER_REMAP'; areaId: string; rowId: string; oldId: string; newId: string }
|
|
| { action: 'OUTLINER_SELECT'; areaId: string; objectId: string; extend: boolean; range: boolean }
|
|
| { action: 'OUTLINER_SELECT_ALL'; areaId: string; operation: 'SELECT' | 'DESELECT' | 'INVERT' | 'TOGGLE' }
|
|
| { action: "SET_EDITOR_TYPE"; areaId: string; editorType: string }
|
|
| { action: "SPLIT_AREA"; areaId: string; direction: 'HORIZONTAL' | 'VERTICAL'; factor: number }
|
|
| { action: "JOIN_AREA"; areaId: string; targetAreaId: string }
|
|
| { action: "SWAP_AREAS"; areaId: string; targetAreaId: string }
|
|
| { action: "MOVE_AREA_EDGE"; areaId: string; targetAreaId: string; delta: number; snap: boolean }
|
|
| { action: "TOGGLE_MAXIMIZE_AREA"; areaId: string }
|
|
| { action: "TOGGLE_FULLSCREEN_AREA"; areaId: string }
|
|
| { action: "TOGGLE_QUAD_VIEW" | "SET_ACTIVE_REGION"; areaId: string; regionId: string }
|
|
| { action: "TOGGLE_HEADER_MENUS"; areaId: string }
|
|
| { action: "RESIZE_REGION"; areaId: string; regionId: string; size: number }
|
|
| { action: "SET_TEXT" | "SET_IMAGE"; areaId: string; dataId: string | null }
|
|
| ({ action: "TEXT_EDIT"; areaId: string } & NativeTextEdit)
|
|
| ({ action: "IMAGE_VIEW"; areaId: string } & NativeImageViewEdit)
|
|
| { action: "NLA_EDIT"; areaId: string; operation:
|
|
'SELECT_ALL' | 'DESELECT_ALL' | 'INVERT_SELECTION' | 'TOGGLE_MUTE' | 'TRANSITION_ADD' | 'META_ADD' | 'META_REMOVE'
|
|
| 'TIME_WARP_ENABLE' | 'TIME_WARP_DISABLE' | 'TIME_WARP_CYCLIC_ENABLE' | 'TIME_WARP_CYCLIC_DISABLE' | 'DELETE_STRIP_TIME_KEY'
|
|
| 'INFLUENCE_ENABLE' | 'INFLUENCE_DISABLE' | 'DELETE_INFLUENCE_KEY'
|
|
| 'TRACK_SELECT_ALL' | 'TRACK_DESELECT_ALL' | 'TRACK_INVERT_SELECTION' | 'TRACK_ADD' | 'TRACK_ADD_ABOVE' | 'TRACK_DELETE'
|
|
| 'TRACK_MOVE_TOP' | 'TRACK_MOVE_UP' | 'TRACK_MOVE_DOWN' | 'TRACK_MOVE_BOTTOM'
|
|
| 'DUPLICATE' | 'DUPLICATE_LINKED' | 'DELETE' | 'SPLIT' | 'SNAP_CURRENT_FRAME' | 'SYNC_ACTION_LENGTH' | 'SYNC_SELECTED_ACTION_LENGTHS' }
|
|
| { action: "NLA_EDIT"; areaId: string; operation: 'KEY_STRIP_TIME'; stripTime: number }
|
|
| { action: "NLA_EDIT"; areaId: string; operation: 'KEY_INFLUENCE'; influence: number }
|
|
| { action: "NLA_EDIT"; areaId: string; operation: 'TWEAK_ENTER'; isolateAction: boolean; useUpperStack: boolean }
|
|
| { action: "NLA_EDIT"; areaId: string; operation: 'TWEAK_EXIT'; clearSolo: boolean }
|
|
| ({ action: "UV_EDIT"; areaId: string } & NativeUVEdit)
|
|
| { action: "SEQUENCER_EDIT"; areaId: string; operation: 'SELECT_ALL' | 'DESELECT_ALL' | 'INVERT_SELECTION' | 'MUTE' | 'UNMUTE' }
|
|
| { action: "NODE_EDIT"; areaId: string; operation: 'SELECT_ALL' | 'DESELECT_ALL' | 'INVERT_SELECTION' | 'TOGGLE_MUTE' | 'DELETE' }
|
|
| { action: "GRAPH_EDIT"; areaId: string; operation: 'SELECT_ALL' | 'DESELECT_ALL' | 'INVERT_SELECTION' | 'DELETE' }
|
|
| { action: "GRAPH_EDIT"; areaId: string; operation: 'SET_INTERPOLATION'; interpolation: GraphInterpolation }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_CONTEXT'; context: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'VIEW_LAYER_OPERATION'; method: 'SELECT' | 'ADD' | 'REMOVE'; target?: string; expectedLayers: string[]; expectedActive: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_PIN'; pinned: boolean; expectedPinId?: string | null }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_OUTLINER_SYNC'; value: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_FRAME_RATE'; context: 'OUTPUT' | 'RENDER'; dataId: string; fps: number; base: number; expectedFps: number; expectedBase: number }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_TIME_REMAP'; context: 'OUTPUT'; dataId: string; old: number; new: number; expectedOld: number; expectedNew: number }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'LIGHTGROUP_SYNC'; context: 'VIEW_LAYER'; dataId: string; layerName: string; method: 'ADD_USED' | 'REMOVE_UNUSED'; expectedGroups: string[] }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'LIGHTGROUP_RENAME'; context: 'VIEW_LAYER'; dataId: string; layerName: string; expectedGroups: string[]; renames: Array<{ from: string; to: string }> }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'RENDER_VIEW_OPERATION'; context: 'OUTPUT'; dataId: string; method: 'ADD' | 'REMOVE'; expectedViews: string[]; expectedActiveIndex: number }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_CONTEXT_PROPERTY'; context: string; dataId: string; property: string; value: PropertiesDataValue; expectedValue?: PropertiesDataValue; expectedCacheFileId?: string; expectedShapeObjectId?: string; expectedKeyId?: string; expectedActiveUid?: number; shapeRowUid?: number }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'CAMERA_PRESET'; context: 'DATA'; dataId: string; method: 'ADD'; name: string; useFocalLength: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'CAMERA_PRESET'; context: 'DATA'; dataId: string; method: 'REMOVE'; path: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'CAMERA_CUSTOM_UPDATE'; context: 'DATA'; dataId: string }
|
|
// SELECT_RANGE extends selection from expectedActiveUid without moving the anchor.
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SHAPE_KEY_OPERATION'; objectId: string; expectedKeyId: string; expectedActiveUid: number; method: string; uid?: number; expectedOrder?: number[]; expectedSelection?: number[]; dropLocation?: 'BEFORE' | 'AFTER'; expectedSources?: string[]; transferMode?: 'OFFSET' | 'RELATIVE_FACE' | 'RELATIVE_EDGE'; useClamp?: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'RELOAD_CACHE'; context: string; dataId: string; expectedCacheFileId: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'CACHE_OPEN'; dataId: string; expectedCacheFileId: string; path: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'CACHE_LAYER'; dataId: string; expectedCacheFileId: string;
|
|
expectedLayers: Array<{ filepath: string; hidden: boolean }>; expectedActiveLayer: number;
|
|
method: 'ADD' | 'SELECT' | 'REMOVE' | 'MOVE_UP' | 'MOVE_DOWN' | 'SET_PATH' | 'SET_HIDE'; index: number; value?: string | boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'CONSTRAINT_OPERATION'; context: string; dataId: string; operator: string; parameters?: Record<string, number> }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'EDIT_ARMATURE_TARGET'; dataId: string; method: 'ADD' | 'REMOVE' | 'CLEAR' | 'MOVE' | 'SET'; expectedTargets: NativeArmatureConstraintTarget[]; index?: number; step?: -1 | 1; target?: NativeArmatureConstraintTarget }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_ACTIVE_MODIFIER'; objectId: string; modifierUuid: string | null; expectedModifierUuid?: string | null }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'MODIFIER_BIND'; objectId: string; modifierUuid: string; expectedBound: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'DUPLICATE_MODIFIER'; objectId: string; modifierUuid: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'APPLY_MODIFIER'; objectId: string; modifierUuid: string; singleUser: boolean; mergeCustomData: boolean; allKeyframes?: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'APPLY_MODIFIER_AS_SHAPE_KEY'; objectId: string; modifierUuid: string; keepModifier: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SHAPE_KEY_MIRROR'; objectId: string; keyId: string; activeUid: number; useTopology: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'COPY_MODIFIER_TO_SELECTED'; objectId: string; modifierUuid: string; expectedTargets: string[] }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'HOOK_OPERATION'; objectId: string; modifierUuid: string; operator: 'RESET' | 'RECENTER' | 'SELECT' | 'ASSIGN' }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SKIN_OPERATION'; objectId: string; modifierUuid: string; operator: 'CREATE_ARMATURE' | 'ADD_SKIN_DATA' | 'MARK_LOOSE' | 'CLEAR_LOOSE' | 'MARK_ROOT' | 'EQUALIZE_RADII' }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'DATA_LAYOUT_OPERATION'; objectId: string; modifierUuid: string; operator: 'GENERATE_DATA_LAYERS' }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'MULTIRES_OPERATION'; objectId: string; modifierUuid: string; operator: 'DELETE_HIGHER_LEVELS' | 'SUBDIVIDE' | 'RESHAPE' | 'BASE_APPLY' | 'UNSUBDIVIDE' | 'REBUILD_SUBDIV' | 'EXTERNAL_SAVE' | 'EXTERNAL_PACK'; path?: string }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_ACTIVE_CONSTRAINT'; objectId: string; constraintName: string | null; expectedConstraintName?: string | null }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_ACTIVE_POSE_CONSTRAINT'; objectId: string; boneName: string; constraintName: string | null; expectedBoneName?: string | null; expectedConstraintName?: string | null }
|
|
| { action: 'PROPERTIES_EDIT'; areaId: string; operation: 'SET_OBJECT_PROPERTY'; objectId: string; property: PropertiesObjectField; value: boolean | string; expectedValue?: boolean | string; expectedParentId?: string | null }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_OBJECT_TRANSFORM'; objectId: string; property: PropertiesObjectTransform; index: number; value: number }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_OBJECT_LOCK'; objectId: string; property: PropertiesObjectLock; index: number; value: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_OBJECT_PARENT'; objectId: string; expectedParentId: string | null; parentId: string; keepTransform: boolean }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'CLEAR_OBJECT_PARENT'; objectId: string; expectedParentId: string; mode: 'CLEAR' | 'CLEAR_KEEP_TRANSFORM' | 'CLEAR_INVERSE' }
|
|
| { action: "PROPERTIES_EDIT"; areaId: string; operation: 'SET_OBJECT_PARENT_TYPE' | 'SET_OBJECT_PARENT_BONE'; objectId: string; expectedParentId: string; expectedParentType: string | null; expectedParentBone: string; value: string }
|
|
| { action: 'PROPERTIES_EDIT'; areaId: string; operation: 'SET_OBJECT_PARENT_SETTING'; objectId: string; expectedParentId: string; expectedParentType: string | null; expectedParentBone: string; property: PropertiesParentSetting; index: number; expectedValue: number | boolean; value: number | boolean }
|
|
| ({ action: 'SPREADSHEET_EDIT'; areaId: string } & NativeSpreadsheetEdit)
|
|
| { action: "SET_VIEW"; areaId: string; view: NativeViewportState }
|
|
| { action: "TOGGLE_REGION"; areaId: string; regionId: string; visible: boolean }
|
|
| { action: "FLIP_REGION"; areaId: string; regionId: string }
|
|
);
|
|
export interface EditorContextIR { workspaceId: string; activeAreaId: string; activeEditor: EditorTypeIR; mode: EditorMode; activeObjectId: string | null; selection: string[]; viewLayer: string; pinnedData: string | null; revision: number }
|
|
export interface KeymapBindingIR {
|
|
id: string;
|
|
key: string;
|
|
modifiers: string[];
|
|
command: string;
|
|
enabled: boolean;
|
|
workspaceIds?: string[];
|
|
editors?: EditorTypeIR[];
|
|
modes?: EditorMode[];
|
|
}
|
|
// Native directed UV edge: start/end coordinates, start selection, edge selection, start pin.
|
|
export type NativeUVEdge = [number, number, number, number, boolean, boolean, boolean];
|
|
export interface NativeUVSelection { objects: Array<{ objectId: string; uvMap: string; edges: NativeUVEdge[] }>; syncSelection: boolean; truncated: boolean; selectionMode?: typeof UV_SELECTION_MODES[number]; meshSelectMode?: number; islandSelection?: boolean; stickyMode?: typeof UV_STICKY_MODES[number]; customRegion?: NativeUVCustomRegion }
|
|
export interface EditorWorkflowIR { schemaVersion: typeof EDITOR_WORKFLOW_SCHEMA; workspaces: EditorWorkspaceIR[]; context: EditorContextIR; keymaps: KeymapBindingIR[]; uvSelection?: NativeUVSelection }
|
|
export interface KeyChordIR { key: string; modifiers: Array<"ALT" | "CTRL" | "META" | "SHIFT"> }
|
|
export type EditorWorkflowEditIR =
|
|
| { type: "SWITCH_WORKSPACE"; revision: number; workspaceId: string }
|
|
| { type: "SET_ACTIVE_AREA"; revision: number; areaId: string }
|
|
| { type: "SET_SELECTION"; revision: number; selectedIds: string[]; activeObjectId: string | null }
|
|
| { type: "TOGGLE_REGION"; revision: number; areaId: string; regionId: string; visible: boolean };
|
|
|
|
export class EditorWorkflowValidationError extends Error {
|
|
readonly code: ErrorCode;
|
|
constructor(code: ErrorCode, message: string) { super(`${code}: ${message}`); this.name = "EditorWorkflowValidationError"; this.code = code; }
|
|
}
|
|
|
|
const EDITOR_REGION_KINDS = new Set<EditorRegionKind>(["HEADER", "MAIN", "TOOLBAR", "SIDEBAR", "FOOTER", "OTHER"]);
|
|
function record(value: unknown): value is Record<string, unknown> { return typeof value === "object" && value !== null && !Array.isArray(value); }
|
|
function text(value: unknown, name: string, maximum = 256): string { if (typeof value !== "string" || value.length === 0 || value.length > maximum) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name} is invalid`); return value; }
|
|
function finite(value: unknown, name: string, minimum: number, maximum: number): number { if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name} is outside the bounded range`); return value; }
|
|
function integer(value: unknown, name: string, minimum: number, maximum: number): number { if (typeof value !== "number" || !Number.isSafeInteger(value) || value < minimum || value > maximum) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name} is outside the bounded range`); return value; }
|
|
|
|
function parseSpreadsheetBundleNavigation(bundle: unknown): NativeSpreadsheetBundleNavigation {
|
|
if (!record(bundle) || !validSpreadsheetBundlePath(bundle.path) ||
|
|
typeof bundle.active !== 'boolean' || typeof bundle.available !== 'boolean' ||
|
|
typeof bundle.pathValid !== 'boolean' || typeof bundle.hasInputs !== 'boolean' ||
|
|
typeof bundle.hasOutputs !== 'boolean' || typeof bundle.childrenTruncated !== 'boolean' ||
|
|
typeof bundle.childrenPage !== 'number' || typeof bundle.childrenPageCount !== 'number' ||
|
|
!Number.isSafeInteger(bundle.childrenPage) || !Number.isSafeInteger(bundle.childrenPageCount) ||
|
|
bundle.childrenPage < 0 || bundle.childrenPageCount < 0 || bundle.childrenPage > 4095 ||
|
|
bundle.childrenPageCount > 4096 ||
|
|
!['NONE', 'INPUT', 'OUTPUT'].includes(bundle.closure as string) ||
|
|
!Array.isArray(bundle.children) || bundle.children.length > 256 ||
|
|
bundle.children.some(key => !validSpreadsheetBundlePath([key])) ||
|
|
new Set(bundle.children).size !== bundle.children.length ||
|
|
(bundle.pathValid && !bundle.available) ||
|
|
(!bundle.available && (bundle.path.length > 0 || bundle.children.length > 0)) ||
|
|
(bundle.childrenPageCount === 0 && bundle.childrenPage !== 0) ||
|
|
(bundle.childrenPageCount > 0 && bundle.childrenPage >= bundle.childrenPageCount) ||
|
|
(bundle.pathValid && bundle.closure === 'INPUT' && !bundle.hasInputs) ||
|
|
(bundle.pathValid && bundle.closure === 'OUTPUT' && !bundle.hasOutputs)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet bundle navigation');
|
|
}
|
|
return {
|
|
active: bundle.active, available: bundle.available, path: [...bundle.path],
|
|
pathValid: bundle.pathValid, closure: bundle.closure as SpreadsheetClosure,
|
|
hasInputs: bundle.hasInputs, hasOutputs: bundle.hasOutputs,
|
|
children: [...bundle.children] as string[], childrenTruncated: bundle.childrenTruncated,
|
|
childrenPage: bundle.childrenPage, childrenPageCount: bundle.childrenPageCount,
|
|
};
|
|
}
|
|
|
|
function rect(value: unknown, name: string): EditorAreaIR["rect"] {
|
|
if (!record(value)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name} is invalid`);
|
|
const next = { x: finite(value.x, `${name}.x`, 0, 1), y: finite(value.y, `${name}.y`, 0, 1), width: finite(value.width, `${name}.width`, 0.0001, 1), height: finite(value.height, `${name}.height`, 0.0001, 1) };
|
|
if (next.x + next.width > 1 || next.y + next.height > 1) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name} exceeds workspace bounds`);
|
|
return next;
|
|
}
|
|
function overlap(a: EditorAreaIR["rect"], b: EditorAreaIR["rect"]): boolean { return a.x < b.x + b.width && a.x + a.width > b.x && a.y < b.y + b.height && a.y + a.height > b.y; }
|
|
function scopeOverlaps<T>(left: readonly T[] | undefined, right: readonly T[] | undefined): boolean { return !left?.length || !right?.length || left.some((value) => right.includes(value)); }
|
|
function keymapScopesOverlap(left: KeymapBindingIR, right: KeymapBindingIR): boolean { return scopeOverlaps(left.workspaceIds, right.workspaceIds) && scopeOverlaps(left.editors, right.editors) && scopeOverlaps(left.modes, right.modes); }
|
|
|
|
export function parseNativeUVTransform(value: unknown): NativeUVTransform {
|
|
if (!record(value) || !['TRANSLATE','ROTATE','SCALE'].includes(value.mode as string)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'UV transform mode is invalid');
|
|
const number = (item: unknown) => typeof item === 'number' && Number.isFinite(item) && Number.isFinite(Math.fround(item));
|
|
const vector = (item: unknown) => Array.isArray(item) && item.length === 2 && item.every(number);
|
|
const allowed = value.mode === 'ROTATE' ? ['mode','angle','center'] : value.mode === 'SCALE' ? ['mode','value','center'] : ['mode','value'];
|
|
if (Object.keys(value).some(key => !allowed.includes(key)) || (value.mode === 'ROTATE' ? !number(value.angle) : !vector(value.value)) || (value.center !== undefined && !vector(value.center))) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'UV transform requires finite native values and a valid center');
|
|
return value as unknown as NativeUVTransform;
|
|
}
|
|
|
|
export function parseNativeUVStitchOptions(value: unknown): NativeUVStitchOptions {
|
|
if (!record(value) || Object.keys(value).length > 8) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'UV Stitch options must be a bounded object');
|
|
for (const [key,option] of Object.entries(value)) {
|
|
const valid = (UV_STITCH_BOOLEANS as readonly string[]).includes(key) ? typeof option === 'boolean'
|
|
: key === 'mode' ? option === 'VERTEX' || option === 'EDGE'
|
|
: key === 'limit' ? typeof option === 'number' && Number.isFinite(option) && Number.isFinite(Math.fround(option)) && option >= 0
|
|
: key === 'static_island' || key === 'active_object_index' ? typeof option === 'number' && Number.isSafeInteger(option) && option >= 0 && option <= 0x7fffffff : false;
|
|
if (!valid) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `Invalid UV Stitch option: ${key}`);
|
|
}
|
|
return {...value} as NativeUVStitchOptions;
|
|
}
|
|
|
|
export function parseNativeUVUnwrapOptions(value: unknown): NativeUVUnwrapOptions {
|
|
if (!record(value) || Object.keys(value).length > 12) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'UV Unwrap options must be a bounded object');
|
|
for (const [key, option] of Object.entries(value)) {
|
|
let valid = false;
|
|
if ((UV_UNWRAP_BOOLEANS as readonly string[]).includes(key)) valid = typeof option === 'boolean';
|
|
else if (key === 'method') valid = typeof option === 'string' && (UV_UNWRAP_METHODS as readonly string[]).includes(option);
|
|
else if (key === 'margin_method') valid = typeof option === 'string' && (UV_UNWRAP_MARGIN_METHODS as readonly string[]).includes(option);
|
|
else if (key === 'margin') valid = typeof option === 'number' && Number.isFinite(option) && option >= 0 && option <= 1;
|
|
else if (key === 'iterations') valid = typeof option === 'number' && Number.isSafeInteger(option) && option >= 0 && option <= 10000;
|
|
else if (key === 'weight_factor') valid = typeof option === 'number' && Number.isFinite(option) && Math.abs(option) <= 10000;
|
|
else if (key === 'weight_group') valid = typeof option === 'string' && !option.includes('\0') && new TextEncoder().encode(option).byteLength < 64;
|
|
if (!valid) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `Invalid UV Unwrap option: ${key}`);
|
|
}
|
|
return { ...value } as NativeUVUnwrapOptions;
|
|
}
|
|
|
|
function parseUVSelection(value: unknown): NativeUVSelection | undefined {
|
|
if (value === undefined) return undefined;
|
|
if (!record(value) || !Array.isArray(value.objects) || value.objects.length > 128 || typeof value.syncSelection !== 'boolean' || typeof value.truncated !== 'boolean') throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Native UV selection metadata is invalid');
|
|
if ((value.selectionMode !== undefined && !UV_SELECTION_MODES.includes(value.selectionMode as typeof UV_SELECTION_MODES[number])) ||
|
|
(value.meshSelectMode !== undefined && (typeof value.meshSelectMode !== 'number' || !Number.isInteger(value.meshSelectMode) || value.meshSelectMode < 1 || value.meshSelectMode > 7)) ||
|
|
(value.islandSelection !== undefined && typeof value.islandSelection !== 'boolean')) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Native UV selection settings are invalid');
|
|
let edgeCount = 0;
|
|
let customRegion: NativeUVCustomRegion | undefined;
|
|
if (value.customRegion !== undefined) {
|
|
if (!record(value.customRegion) || typeof value.customRegion.enabled !== 'boolean') throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Native UV custom region is invalid');
|
|
customRegion = {enabled:value.customRegion.enabled,bounds:parseNativeUVBounds(value.customRegion.bounds,false)};
|
|
}
|
|
if (value.stickyMode !== undefined && !UV_STICKY_MODES.includes(value.stickyMode as typeof UV_STICKY_MODES[number])) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Native UV sticky selection mode is invalid');
|
|
const ids = new Set<string>(), objects: NativeUVSelection['objects'] = [];
|
|
for (const item of value.objects) {
|
|
if (!record(item) || !Array.isArray(item.edges) || (edgeCount += item.edges.length) > 16384) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_BUDGET_EXCEEDED', 'Native UV edges exceed the budget or have invalid rows');
|
|
const objectId = text(item.objectId, 'uvSelection.objectId'), uvMap = text(item.uvMap, 'uvSelection.uvMap');
|
|
if (ids.has(objectId)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate native UV object');
|
|
ids.add(objectId);
|
|
const edges: NativeUVEdge[] = [];
|
|
for (const edge of item.edges) {
|
|
if (!Array.isArray(edge) || edge.length !== 7 || edge.slice(0,4).some(n => typeof n !== 'number' || !Number.isFinite(n)) || edge.slice(4).some(flag => typeof flag !== 'boolean')) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Native UV edge tuple is invalid');
|
|
edges.push([...edge] as NativeUVEdge);
|
|
}
|
|
objects.push({ objectId, uvMap, edges });
|
|
}
|
|
return { objects, syncSelection: value.syncSelection, truncated: value.truncated,
|
|
selectionMode: value.selectionMode as NativeUVSelection['selectionMode'], meshSelectMode: value.meshSelectMode as number | undefined,
|
|
islandSelection: value.islandSelection as boolean | undefined, stickyMode: value.stickyMode as NativeUVSelection['stickyMode'], customRegion };
|
|
}
|
|
|
|
export function parseEditorWorkflow(value: unknown): EditorWorkflowIR {
|
|
if (!record(value) || value.schemaVersion !== EDITOR_WORKFLOW_SCHEMA || !Array.isArray(value.workspaces) || !record(value.context) || !Array.isArray(value.keymaps)) throw new EditorWorkflowValidationError("PROTOCOL_MISMATCH", "Unsupported editor workflow schema");
|
|
if (value.workspaces.length > EDITOR_WORKFLOW_BUDGET.maxWorkspaces || value.keymaps.length > EDITOR_WORKFLOW_BUDGET.maxKeymaps) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_BUDGET_EXCEEDED", "Editor workflow exceeds the budget");
|
|
let areaCount = 0; let regionCount = 0; const workspaceIds = new Set<string>();
|
|
const workspaces = value.workspaces.map((workspaceValue, workspaceIndex): EditorWorkspaceIR => {
|
|
const name = `workspaces[${workspaceIndex}]`; if (!record(workspaceValue) || !Array.isArray(workspaceValue.areas)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name} is invalid`);
|
|
const id = text(workspaceValue.id, `${name}.id`); if (workspaceIds.has(id)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `Duplicate workspace ${id}`); workspaceIds.add(id);
|
|
areaCount += workspaceValue.areas.length; if (areaCount > EDITOR_WORKFLOW_BUDGET.maxAreas) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_BUDGET_EXCEEDED", "Area count exceeds the budget");
|
|
const areaIds = new Set<string>();
|
|
const areas = workspaceValue.areas.map((areaValue, areaIndex): EditorAreaIR => {
|
|
const areaName = `${name}.areas[${areaIndex}]`; if (!record(areaValue) || !EDITOR_TYPES.includes(areaValue.editor as EditorTypeIR) || !Array.isArray(areaValue.regions)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${areaName} is invalid`);
|
|
const areaId = text(areaValue.id, `${areaName}.id`); if (areaIds.has(areaId)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `Duplicate area ${areaId}`); areaIds.add(areaId);
|
|
regionCount += areaValue.regions.length; if (regionCount > EDITOR_WORKFLOW_BUDGET.maxRegions) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_BUDGET_EXCEEDED", "Region count exceeds the budget");
|
|
const regionIds = new Set<string>();
|
|
const regions = areaValue.regions.map((regionValue, regionIndex): EditorRegionIR => {
|
|
const regionName = `${areaName}.regions[${regionIndex}]`;
|
|
if (!record(regionValue) || !EDITOR_REGION_KINDS.has(regionValue.kind as EditorRegionKind)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${regionName} is invalid`);
|
|
const regionId = text(regionValue.id, `${regionName}.id`);
|
|
if (regionIds.has(regionId)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `Duplicate region ${regionId}`);
|
|
regionIds.add(regionId);
|
|
const alignment = regionValue.alignment;
|
|
if (alignment !== undefined && !['TOP', 'BOTTOM', 'LEFT', 'RIGHT', 'OTHER'].includes(alignment as string)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${regionName}.alignment is invalid`);
|
|
return {
|
|
id: regionId, kind: regionValue.kind as EditorRegionKind, visible: regionValue.visible !== false,
|
|
active: regionValue.active === true, quadView: regionValue.quadView === true,
|
|
toggleable: regionValue.toggleable === true, flippable: regionValue.flippable === true,
|
|
alignment: alignment as EditorRegionIR['alignment'],
|
|
};
|
|
});
|
|
let nativeLayout: NativeAreaLayout | undefined;
|
|
if (areaValue.nativeLayout !== undefined) {
|
|
const layout = areaValue.nativeLayout;
|
|
if (!record(layout) || typeof layout.editorType !== 'string' || layout.editorType.length > 128 ||
|
|
!Array.isArray(layout.editorTypes) || layout.editorTypes.length > 128 ||
|
|
!Array.isArray(layout.joinTargets) || layout.joinTargets.length > EDITOR_WORKFLOW_BUDGET.maxAreas ||
|
|
typeof layout.editable !== 'boolean' ||
|
|
(layout.screenState !== undefined && !['NORMAL', 'MAXIMIZED', 'FULLSCREEN'].includes(layout.screenState as string)) ||
|
|
(layout.headerMenusVisible !== undefined && typeof layout.headerMenusVisible !== 'boolean')) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.nativeLayout is invalid`);
|
|
}
|
|
nativeLayout = {
|
|
editorType: layout.editorType,
|
|
editorTypes: layout.editorTypes.map((item, index) => {
|
|
if (!record(item)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native editor choice');
|
|
return { id: text(item.id, `${areaName}.editorTypes[${index}].id`, 128),
|
|
label: text(item.label, `${areaName}.editorTypes[${index}].label`, 256) };
|
|
}),
|
|
joinTargets: layout.joinTargets.map(item => text(item, `${areaName}.joinTarget`)),
|
|
editable: layout.editable,
|
|
screenState: layout.screenState as NativeAreaLayout['screenState'] ?? 'NORMAL',
|
|
headerMenusVisible: layout.headerMenusVisible as boolean | undefined,
|
|
};
|
|
}
|
|
const filterText = areaValue.filterText;
|
|
if (filterText !== undefined && (typeof filterText !== "string" || filterText.length > 64)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${areaName}.filterText is invalid`);
|
|
let space: EditorAreaIR['space'];
|
|
if (areaValue.space !== undefined) {
|
|
if (!record(areaValue.space)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.space is invalid`);
|
|
space = { kind: text(areaValue.space.kind, `${areaName}.space.kind`, 64) };
|
|
if (areaValue.space.dataId !== undefined) space.dataId = areaValue.space.dataId === null ? null : text(areaValue.space.dataId, `${areaName}.space.dataId`);
|
|
if (areaValue.space.outliner !== undefined) {
|
|
const tree = areaValue.space.outliner;
|
|
if (areaValue.editor !== 'OUTLINER' || space.kind !== 'OUTLINER' || !record(tree) ||
|
|
!Array.isArray(tree.rows) || tree.rows.length > 65536 ||
|
|
typeof tree.truncated !== 'boolean' || typeof tree.syncSelection !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native Outliner tree');
|
|
}
|
|
const rowIds = new Set<string>();
|
|
const rows = tree.rows.map((row): NativeOutlinerRow => {
|
|
if (!record(row) || !Number.isInteger(row.depth) || Number(row.depth) < 0 || Number(row.depth) > 64 ||
|
|
typeof row.label !== 'string' || row.label.length > 65536 ||
|
|
['selected', 'active', 'expanded', 'hasChildren'].some(key => typeof row[key] !== 'boolean')) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native Outliner row');
|
|
}
|
|
const id = text(row.id, 'outliner.row.id', 65536);
|
|
if (rowIds.has(id)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate native Outliner row');
|
|
rowIds.add(id);
|
|
return { id, label: row.label, depth: Number(row.depth), selected: row.selected as boolean,
|
|
active: row.active as boolean, expanded: row.expanded as boolean, hasChildren: row.hasChildren as boolean,
|
|
objectId: row.objectId === null ? null : text(row.objectId, 'outliner.row.objectId'),
|
|
remapId: row.remapId == null ? null : text(row.remapId, 'outliner.row.remapId', 65536) };
|
|
});
|
|
let remapIds: NativeOutlinerRemapID[] | undefined;
|
|
if (tree.remapIds !== undefined) {
|
|
if (!Array.isArray(tree.remapIds)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Remap IDs');
|
|
remapIds = tree.remapIds.map(value => {
|
|
if (!record(value) || !Number.isInteger(value.idType) || typeof value.editable !== 'boolean' ||
|
|
typeof value.library !== 'string' || value.library.length > 65536) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Remap ID');
|
|
}
|
|
return { id: text(value.id, 'outliner.remap.id', 65536), name: text(value.name, 'outliner.remap.name', 65536),
|
|
idType: Number(value.idType), library: value.library, editable: value.editable };
|
|
});
|
|
}
|
|
space.outliner = { rows, truncated: tree.truncated, syncSelection: tree.syncSelection, remapIds };
|
|
}
|
|
if (areaValue.space.spreadsheet !== undefined) {
|
|
const spreadsheet = areaValue.space.spreadsheet;
|
|
if (areaValue.editor !== 'SPREADSHEET' || space.kind !== 'SPREADSHEET' || !record(spreadsheet) ||
|
|
typeof spreadsheet.useFilter !== 'boolean' || !Array.isArray(spreadsheet.rules)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.spreadsheet is invalid`);
|
|
}
|
|
const fields = ['enabled', 'show_expanded', 'column_name', 'operation', 'value_float', 'value_int',
|
|
'value_float2', 'value_float3', 'value_float4', 'value_color', 'value_int2', 'value_int3',
|
|
'value_string', 'value_boolean', 'threshold'] as const;
|
|
const rules = spreadsheet.rules.map((rule, index) => {
|
|
if (!record(rule) || fields.some(field => !validSpreadsheetRuleValue(field, rule[field]))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.rules[${index}] is invalid`);
|
|
}
|
|
return Object.fromEntries(fields.map(field => [field, Array.isArray(rule[field]) ? [...(rule[field] as number[])] : rule[field]])) as unknown as NativeSpreadsheetRule;
|
|
});
|
|
space.spreadsheet = { useFilter: spreadsheet.useFilter, rules };
|
|
if (spreadsheet.instances !== undefined) {
|
|
const instances = spreadsheet.instances;
|
|
if (!record(instances) || !validSpreadsheetInstancePath(instances.path) ||
|
|
!Array.isArray(instances.breadcrumbs) || instances.breadcrumbs.length !== instances.path.length + 1 ||
|
|
typeof instances.geometryAvailable !== 'boolean' || typeof instances.pathValid !== 'boolean' ||
|
|
typeof instances.childrenTruncated !== 'boolean' ||
|
|
typeof instances.childrenPage !== 'number' || typeof instances.childrenPageCount !== 'number' ||
|
|
!Number.isSafeInteger(instances.childrenPage) ||
|
|
!Number.isSafeInteger(instances.childrenPageCount) || instances.childrenPage < 0 ||
|
|
instances.childrenPageCount < 0 || instances.childrenPage > 4095 ||
|
|
instances.childrenPageCount > 4096 ||
|
|
!Array.isArray(instances.children) || instances.children.length > 256 ||
|
|
(instances.pathValid && !instances.geometryAvailable) ||
|
|
(!instances.geometryAvailable && instances.path.length !== 0) ||
|
|
(!instances.pathValid && (instances.children.length !== 0 || instances.childrenTruncated ||
|
|
instances.childrenPage !== 0 || instances.childrenPageCount !== 0)) ||
|
|
(instances.childrenPageCount === 0 && instances.childrenPage !== 0) ||
|
|
(instances.childrenPageCount > 0 && instances.childrenPage >= instances.childrenPageCount) ||
|
|
instances.childrenTruncated !== (instances.childrenPageCount > 1)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet instance navigation');
|
|
}
|
|
const children = instances.children.map(child => {
|
|
if (!record(child) || !validSpreadsheetInstancePath([child.referenceIndex]) ||
|
|
typeof child.userCount !== 'number' || !Number.isInteger(child.userCount) ||
|
|
child.userCount < 0 || child.userCount > 2147483647) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet instance reference');
|
|
}
|
|
return { referenceIndex: child.referenceIndex as number,
|
|
label: text(child.label, 'Spreadsheet instance name', 4096), userCount: child.userCount };
|
|
});
|
|
if (new Set(children.map(child => child.referenceIndex)).size !== children.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate Spreadsheet instance reference');
|
|
}
|
|
space.spreadsheet.instances = {
|
|
path: [...instances.path],
|
|
breadcrumbs: instances.breadcrumbs.map(name => text(name, 'Spreadsheet instance name', 4096)),
|
|
geometryAvailable: instances.geometryAvailable, pathValid: instances.pathValid,
|
|
children, childrenTruncated: instances.childrenTruncated,
|
|
childrenPage: instances.childrenPage, childrenPageCount: instances.childrenPageCount,
|
|
};
|
|
}
|
|
if (spreadsheet.bundle !== undefined) {
|
|
space.spreadsheet.bundle = parseSpreadsheetBundleNavigation(spreadsheet.bundle);
|
|
}
|
|
if (spreadsheet.viewer !== undefined) {
|
|
const viewer = spreadsheet.viewer;
|
|
if (!record(viewer) || typeof viewer.available !== 'boolean' ||
|
|
typeof viewer.itemsPage !== 'number' || typeof viewer.itemsPageCount !== 'number' ||
|
|
typeof viewer.itemsTruncated !== 'boolean' || !Array.isArray(viewer.items) ||
|
|
viewer.items.length > 256 || !Number.isSafeInteger(viewer.itemsPage) ||
|
|
!Number.isSafeInteger(viewer.itemsPageCount) || viewer.itemsPage < 0 ||
|
|
viewer.itemsPageCount < 0 || viewer.itemsPage > 4095 || viewer.itemsPageCount > 4096 ||
|
|
(viewer.itemsPageCount === 0 && viewer.itemsPage !== 0) ||
|
|
(viewer.itemsPageCount > 0 && viewer.itemsPage >= viewer.itemsPageCount) ||
|
|
(!viewer.available && (viewer.items.length > 0 || viewer.itemsTruncated || viewer.itemsPageCount !== 0))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet Viewer outputs');
|
|
}
|
|
const itemIdentifier = integer(viewer.itemIdentifier, 'Viewer output identifier', -2147483648, 2147483647);
|
|
const items = viewer.items.map(item => {
|
|
if (!record(item) || typeof item.label !== 'string' || item.label.length > 4096 || item.label.includes('\0')) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet Viewer output');
|
|
}
|
|
return { identifier: integer(item.identifier, 'Viewer output identifier', -2147483648, 2147483647), label: item.label };
|
|
});
|
|
const selection = parseSpreadsheetBundleNavigation(viewer.selection);
|
|
if (new Set(items.map(item => item.identifier)).size !== items.length ||
|
|
(viewer.available && !selection.active) ||
|
|
(selection.available && !viewer.available)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet Viewer selection');
|
|
}
|
|
space.spreadsheet.viewer = {
|
|
available: viewer.available, itemIdentifier, items,
|
|
itemsTruncated: viewer.itemsTruncated, itemsPage: viewer.itemsPage,
|
|
itemsPageCount: viewer.itemsPageCount, selection,
|
|
};
|
|
}
|
|
if (spreadsheet.viewState !== undefined) {
|
|
const view = spreadsheet.viewState;
|
|
if (!record(view) || typeof view.pinned !== 'boolean' || typeof view.canPin !== 'boolean' ||
|
|
typeof view.showOnlySelected !== 'boolean' || typeof view.selectionFilterAvailable !== 'boolean' ||
|
|
typeof view.dataSourceAvailable !== 'boolean' ||
|
|
(view.selectionFilterAvailable && !view.dataSourceAvailable)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet view state');
|
|
}
|
|
space.spreadsheet.viewState = {
|
|
pinned: view.pinned, canPin: view.canPin, showOnlySelected: view.showOnlySelected,
|
|
selectionFilterAvailable: view.selectionFilterAvailable, dataSourceAvailable: view.dataSourceAvailable,
|
|
};
|
|
}
|
|
if (spreadsheet.context !== undefined) {
|
|
const settings = spreadsheet.context;
|
|
if (!record(settings)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.spreadsheet.context is invalid`);
|
|
const parsed = {} as NonNullable<NativeSpreadsheetContext['context']>;
|
|
for (const property of SPREADSHEET_CONTEXT_PROPERTIES) {
|
|
const setting = settings[property];
|
|
if (!record(setting) || !Array.isArray(setting.choices) || setting.choices.length > 64) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.spreadsheet.${property} is invalid`);
|
|
}
|
|
const choices = setting.choices.map(item => {
|
|
if (!record(item)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet context choice');
|
|
return { id: text(item.id, 'Spreadsheet choice id', 64), label: text(item.label, 'Spreadsheet choice label', 256) };
|
|
});
|
|
const value = setting.value === null ? null : text(setting.value, 'Spreadsheet context value', 64);
|
|
if (new Set(choices.map(item => item.id)).size !== choices.length ||
|
|
(value !== null && !choices.some(item => item.id === value))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet context selection');
|
|
}
|
|
parsed[property] = { value, choices };
|
|
}
|
|
space.spreadsheet.context = parsed;
|
|
}
|
|
if (spreadsheet.columns !== undefined) {
|
|
if (!Array.isArray(spreadsheet.columns) || spreadsheet.columns.length > 512 ||
|
|
typeof spreadsheet.columnsTruncated !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet columns');
|
|
}
|
|
space.spreadsheet.columns = spreadsheet.columns.map(column => {
|
|
if (!record(column) || typeof column.comparison !== 'boolean' || typeof column.threshold !== 'boolean' ||
|
|
(column.valueProperty !== null && !(SPREADSHEET_VALUE_PROPERTIES as readonly unknown[]).includes(column.valueProperty))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Spreadsheet column type');
|
|
}
|
|
return { name: text(column.name, 'Spreadsheet column name', 4096),
|
|
valueProperty: column.valueProperty as NativeSpreadsheetColumn['valueProperty'],
|
|
comparison: column.comparison, threshold: column.threshold };
|
|
});
|
|
space.spreadsheet.columnsTruncated = spreadsheet.columnsTruncated;
|
|
}
|
|
}
|
|
if (areaValue.space.properties !== undefined) {
|
|
const properties = areaValue.space.properties;
|
|
if (areaValue.editor !== 'PROPERTIES' || space.kind !== 'PROPERTIES' || !record(properties) ||
|
|
!Array.isArray(properties.contexts) || properties.contexts.length > 64 ||
|
|
typeof properties.pinned !== 'boolean' || typeof properties.canPin !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.properties is invalid`);
|
|
}
|
|
const contexts = properties.contexts.map((item, index) => {
|
|
if (!record(item)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.contexts[${index}] is invalid`);
|
|
return { id: text(item.id, `${areaName}.context.id`, 64), label: text(item.label, `${areaName}.context.label`) };
|
|
});
|
|
const context = properties.context === null ? null : text(properties.context, `${areaName}.context`, 64);
|
|
const pinId = properties.pinId === null ? null : text(properties.pinId, `${areaName}.pinId`);
|
|
const pinName = properties.pinName === null ? null : text(properties.pinName, `${areaName}.pinName`);
|
|
if (new Set(contexts.map(item => item.id)).size !== contexts.length ||
|
|
(context !== null && !contexts.some(item => item.id === context)) ||
|
|
properties.pinned !== (pinId !== null) || properties.pinned !== (pinName !== null)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.properties context or pin is inconsistent`);
|
|
}
|
|
space.properties = { context, contexts, pinned: properties.pinned, canPin: properties.canPin, pinId, pinName };
|
|
if (properties.viewLayers !== undefined) {
|
|
if (!Array.isArray(properties.viewLayers) || properties.viewLayers.length > 64)
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties view layers');
|
|
space.properties.viewLayers = properties.viewLayers.map(item => {
|
|
if (!record(item) || typeof item.active !== 'boolean' || typeof item.editable !== 'boolean')
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties view layer entry');
|
|
return { name: text(item.name, `${areaName}.viewLayer.name`, 63), active: item.active, editable: item.editable };
|
|
});
|
|
}
|
|
if (properties.outlinerSync !== undefined) {
|
|
const sync = properties.outlinerSync;
|
|
if (!record(sync) || typeof sync.editable !== 'boolean' || !Array.isArray(sync.items) || sync.items.length > 64) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties Outliner sync');
|
|
}
|
|
const items = sync.items.map(item => {
|
|
if (!record(item)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties sync item');
|
|
return { id: text(item.id, `${areaName}.sync.id`, 64), label: text(item.label, `${areaName}.sync.label`) };
|
|
});
|
|
const value = sync.value === null ? null : text(sync.value, `${areaName}.sync.value`, 64);
|
|
if (new Set(items.map(item => item.id)).size !== items.length ||
|
|
(value !== null && !items.some(item => item.id === value))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Inconsistent Properties sync value');
|
|
}
|
|
space.properties.outlinerSync = { value, items, editable: sync.editable };
|
|
}
|
|
if (properties.object !== undefined && properties.object !== null) {
|
|
const object = properties.object;
|
|
if (context === null || !['OBJECT', 'MODIFIER', 'CONSTRAINT', 'BONE', 'BONE_CONSTRAINT'].includes(context) || !record(object) || !Array.isArray(object.fields) ||
|
|
object.fields.length > PROPERTIES_OBJECT_BOOLEAN_FIELDS.length + PROPERTIES_OBJECT_ENUM_FIELDS.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties object');
|
|
}
|
|
const fields = object.fields.map((field): NativePropertiesObject['fields'][number] => {
|
|
if (!record(field) || typeof field.editable !== 'boolean' || !Array.isArray(field.items) || field.items.length > 32) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties object field');
|
|
}
|
|
const id = text(field.id, 'Properties object field', 64) as PropertiesObjectField;
|
|
const items = field.items.map(item => {
|
|
if (!record(item)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties field option');
|
|
return { id: text(item.id, 'Properties field option', 64), label: text(item.label, 'Properties field label') };
|
|
});
|
|
const booleanField = (PROPERTIES_OBJECT_BOOLEAN_FIELDS as readonly string[]).includes(id);
|
|
const enumField = (PROPERTIES_OBJECT_ENUM_FIELDS as readonly string[]).includes(id);
|
|
if (new Set(items.map(item => item.id)).size !== items.length ||
|
|
(!booleanField && !enumField) ||
|
|
(booleanField && (typeof field.value !== 'boolean' || items.length !== 0)) ||
|
|
(enumField && (typeof field.value !== 'string' || !items.some(item => item.id === field.value)))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties object value');
|
|
}
|
|
return { id, label: text(field.label, 'Properties field label'), editable: field.editable,
|
|
value: field.value as boolean | string, items };
|
|
});
|
|
if (new Set(fields.map(field => field.id)).size !== fields.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate Properties object field');
|
|
}
|
|
const meshId = object.meshId === undefined || object.meshId === null ? null : text(object.meshId, 'Properties mesh ID');
|
|
const parseStack = (value: unknown, label: string) => {
|
|
if (value === undefined) return undefined;
|
|
if (!Array.isArray(value) || value.length > 256) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `Invalid ${label}`);
|
|
return value.map((entry, index) => {
|
|
if (!record(entry)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `Invalid ${label}[${index}]`);
|
|
if (label === 'Properties modifiers') text(entry.uuid, `${label}.uuid`, 256);
|
|
const name = text(entry.name, `${label}.name`, 256);
|
|
const type = text(entry.type, `${label}.type`, 128);
|
|
if (typeof entry.enabled !== 'boolean' ||
|
|
(label === 'Properties modifiers' && (typeof entry.showViewport !== 'boolean' || typeof entry.showRender !== 'boolean' || !record(entry.parameters))) ||
|
|
(label !== 'Properties modifiers' && (typeof entry.influence !== 'number' || !Number.isFinite(entry.influence)))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `Invalid ${label} entry`);
|
|
}
|
|
if (label === 'Properties modifiers' && entry.editableParameters !== undefined) {
|
|
if (!Array.isArray(entry.editableParameters) || entry.editableParameters.length > 64) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier editable parameters');
|
|
}
|
|
for (const parameter of entry.editableParameters) {
|
|
if (!record(parameter) || typeof parameter.key !== 'string' || parameter.key.length === 0 ||
|
|
typeof parameter.kind !== 'string' || typeof parameter.length !== 'number' ||
|
|
!['boolean', 'number', 'enum', 'enum_set', 'object', 'collection', 'texture', 'cachefile', 'curve_mapping', 'string', 'profile'].includes(parameter.kind) ||
|
|
!Number.isSafeInteger(parameter.length) || parameter.length < 0 || parameter.length > 4) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier parameter metadata');
|
|
}
|
|
if ((parameter.label !== undefined && typeof parameter.label !== 'string') ||
|
|
(parameter.description !== undefined && typeof parameter.description !== 'string') ||
|
|
(parameter.visible !== undefined && typeof parameter.visible !== 'boolean') ||
|
|
(parameter.enabled !== undefined && typeof parameter.enabled !== 'boolean') ||
|
|
(parameter.editable !== undefined && typeof parameter.editable !== 'boolean') ||
|
|
(parameter.nullable !== undefined && typeof parameter.nullable !== 'boolean') ||
|
|
(parameter.display !== undefined && typeof parameter.display !== 'string') ||
|
|
(parameter.unit !== undefined && parameter.unit !== 'ANGLE')) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier parameter access metadata');
|
|
}
|
|
if (parameter.kind === 'string' && (typeof parameter.value !== 'string' ||
|
|
typeof parameter.maxLength !== 'number' ||
|
|
typeof parameter.suggestionsOnly !== 'boolean' || !Number.isSafeInteger(parameter.maxLength) ||
|
|
parameter.maxLength < 0 || parameter.maxLength > 65535 || parameter.length !== 0)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier string resource metadata');
|
|
}
|
|
if (parameter.kind === 'profile' && (parameter.key !== 'custom_profile' || parameter.length !== 0 || !isModifierCurveProfile(parameter.value))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier custom profile metadata');
|
|
}
|
|
if (parameter.kind === 'curve_mapping' && (!['map_curve', 'falloff_curve'].includes(parameter.key) || parameter.length !== 0 ||
|
|
!record(parameter.value) || !Array.isArray(parameter.value.clip) || parameter.value.clip.length !== 4 ||
|
|
!parameter.value.clip.every(value => typeof value === 'number' && Number.isFinite(value)) ||
|
|
!Array.isArray(parameter.value.points) || parameter.value.points.length < 2 || parameter.value.points.length > 256 ||
|
|
!parameter.value.points.every(point => Array.isArray(point) && point.length === 2 && point.every(value => typeof value === 'number' && Number.isFinite(value))))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier CurveMapping metadata');
|
|
}
|
|
if (parameter.kind === 'curve_mapping' && record(parameter.value) &&
|
|
['useClip', 'extend', 'handles', 'wrapping'].some(key => Object.prototype.hasOwnProperty.call(parameter.value, key))) {
|
|
const curve = parameter.value;
|
|
if (typeof curve.useClip !== 'boolean' || typeof curve.wrapping !== 'boolean' ||
|
|
typeof curve.extend !== 'string' || !['HORIZONTAL', 'EXTRAPOLATED'].includes(curve.extend) ||
|
|
!Array.isArray(curve.points) || !Array.isArray(curve.handles) || curve.handles.length !== curve.points.length ||
|
|
!curve.handles.every(handle => typeof handle === 'string' && ['AUTO', 'VECTOR', 'AUTO_CLAMPED'].includes(handle))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier CurveMapping tools metadata');
|
|
}
|
|
}
|
|
if (parameter.kind === 'curve_mapping' && record(parameter.value) &&
|
|
['view', 'selected', 'samples'].some(key => Object.prototype.hasOwnProperty.call(parameter.value, key))) {
|
|
const curve = parameter.value;
|
|
if (!Array.isArray(curve.view) || curve.view.length !== 4 ||
|
|
!curve.view.every(value => typeof value === 'number' && Number.isFinite(value)) ||
|
|
curve.view[0] >= curve.view[2] || curve.view[1] >= curve.view[3] ||
|
|
!Array.isArray(curve.points) || !Array.isArray(curve.selected) ||
|
|
curve.selected.length !== curve.points.length || !curve.selected.every(value => typeof value === 'boolean') ||
|
|
!Array.isArray(curve.samples) || curve.samples.length !== 257 ||
|
|
!curve.samples.every(point => Array.isArray(point) && point.length === 2 &&
|
|
point.every(value => typeof value === 'number' && Number.isFinite(value)))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native CurveMapping graph metadata');
|
|
}
|
|
}
|
|
if (parameter.kind === 'curve_mapping' && record(parameter.value) &&
|
|
['canZoomIn', 'canZoomOut', 'active'].some(key => Object.prototype.hasOwnProperty.call(parameter.value, key))) {
|
|
const curve = parameter.value;
|
|
if (typeof curve.canZoomIn !== 'boolean' || typeof curve.canZoomOut !== 'boolean' ||
|
|
!Number.isInteger(curve.active) || Number(curve.active) < -1 ||
|
|
!Array.isArray(curve.points) || Number(curve.active) >= curve.points.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native CurveMapping view controls');
|
|
}
|
|
}
|
|
if (parameter.kind === 'enum' || parameter.kind === 'enum_set' || parameter.kind === 'object' || parameter.kind === 'collection' || parameter.kind === 'texture' || parameter.kind === 'cachefile' || parameter.kind === 'string') {
|
|
if (!Array.isArray(parameter.items) || (parameter.kind === 'enum' && parameter.items.length === 0) ||
|
|
!parameter.items.every(item => record(item) && typeof item.id === 'string' && typeof item.label === 'string')) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier enum metadata');
|
|
}
|
|
}
|
|
const enumItems = parameter.items;
|
|
if (parameter.kind === 'enum_set' && (parameter.length !== 0 ||
|
|
!Array.isArray(parameter.value) || !Array.isArray(enumItems) ||
|
|
enumItems.length > 64 || new Set(enumItems.map(item => item.id)).size !== enumItems.length ||
|
|
parameter.value.length > enumItems.length ||
|
|
!parameter.value.every(value => typeof value === 'string' && enumItems.some(item => item.id === value)) ||
|
|
new Set(parameter.value).size !== parameter.value.length)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier enum flag selection');
|
|
}
|
|
if (parameter.kind === 'object' && parameter.value !== null &&
|
|
(typeof parameter.value !== 'string' || !parameter.value.startsWith('object:'))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier object resource value');
|
|
}
|
|
if (parameter.kind === 'collection' && parameter.value !== null &&
|
|
(typeof parameter.value !== 'string' || !parameter.value.startsWith('collection:'))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier Collection resource value');
|
|
}
|
|
if (parameter.kind === 'texture' && parameter.value !== null &&
|
|
(typeof parameter.value !== 'string' || !parameter.value.startsWith('texture:'))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier Texture resource value');
|
|
}
|
|
if (parameter.kind === 'cachefile' && parameter.value !== null &&
|
|
(typeof parameter.value !== 'string' || !parameter.value.startsWith('cachefile:'))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier CacheFile resource value');
|
|
}
|
|
}
|
|
}
|
|
if (label === 'Properties modifiers' && entry.diagnostics !== undefined) {
|
|
if (!Array.isArray(entry.diagnostics) || entry.diagnostics.length > 8) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier diagnostics');
|
|
}
|
|
for (const diagnostic of entry.diagnostics) {
|
|
if (!record(diagnostic) || !['INFO', 'ERROR'].includes(String(diagnostic.kind))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier diagnostic');
|
|
}
|
|
text(diagnostic.message, 'Modifier diagnostic message', 4096);
|
|
}
|
|
}
|
|
if (label === 'Properties modifiers' && entry.bind !== undefined &&
|
|
(!record(entry.bind) || !['LaplacianDeform', 'CorrectiveSmooth', 'MeshDeform', 'SurfaceDeform'].includes(type) ||
|
|
typeof entry.bind.bound !== 'boolean' || typeof entry.bind.enabled !== 'boolean' ||
|
|
typeof entry.bind.reason !== 'string' || entry.bind.reason.length > 512)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier bind action');
|
|
}
|
|
if (label === 'Properties modifiers' && entry.duplicate !== undefined &&
|
|
(!record(entry.duplicate) || typeof entry.duplicate.enabled !== 'boolean' ||
|
|
typeof entry.duplicate.reason !== 'string' || entry.duplicate.reason.length > 512)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier duplicate action');
|
|
}
|
|
if (label === 'Properties modifiers' && entry.apply !== undefined &&
|
|
(!record(entry.apply) || typeof entry.apply.enabled !== 'boolean' ||
|
|
typeof entry.apply.reason !== 'string' || entry.apply.reason.length > 512 ||
|
|
typeof entry.apply.requiresSingleUser !== 'boolean' ||
|
|
(entry.apply.supportsAllKeyframes !== undefined && typeof entry.apply.supportsAllKeyframes !== 'boolean') ||
|
|
(entry.apply.supportsMergeCustomData !== undefined && typeof entry.apply.supportsMergeCustomData !== 'boolean'))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier apply action');
|
|
}
|
|
if (label === 'Properties modifiers' && entry.applyAsShapeKey !== undefined &&
|
|
(!record(entry.applyAsShapeKey) || typeof entry.applyAsShapeKey.enabled !== 'boolean' ||
|
|
typeof entry.applyAsShapeKey.reason !== 'string' || entry.applyAsShapeKey.reason.length > 512)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier shape key action');
|
|
}
|
|
if (label === 'Properties modifiers' && entry.copyToSelected !== undefined) {
|
|
const copy = entry.copyToSelected;
|
|
if (!record(copy) || typeof copy.enabled !== 'boolean' ||
|
|
typeof copy.reason !== 'string' || copy.reason.length > 512 ||
|
|
!Array.isArray(copy.targets) || copy.targets.length > 1024 ||
|
|
copy.targets.some((id: unknown) => typeof id !== 'string' || !id.startsWith('id:OB') || id.length > 256)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier copy destinations');
|
|
}
|
|
}
|
|
if (label === 'Properties modifiers' && entry.hookActions !== undefined) {
|
|
const ids = ['RESET', 'RECENTER', 'SELECT', 'ASSIGN'];
|
|
if (type !== 'Hook' || !Array.isArray(entry.hookActions) || entry.hookActions.length !== ids.length ||
|
|
entry.hookActions.some((action: unknown, actionIndex: number) => !record(action) || action.id !== ids[actionIndex] ||
|
|
typeof action.enabled !== 'boolean' || typeof action.reason !== 'string' || action.reason.length > 512 ||
|
|
typeof action.label !== 'string' || action.label.length > 128)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native Hook actions');
|
|
}
|
|
}
|
|
if (label === 'Properties modifiers' && entry.skinActions !== undefined) {
|
|
const ids = ['CREATE_ARMATURE', 'ADD_SKIN_DATA', 'MARK_LOOSE', 'CLEAR_LOOSE', 'MARK_ROOT', 'EQUALIZE_RADII'];
|
|
if (type !== 'Skin' || !Array.isArray(entry.skinActions) || entry.skinActions.length !== ids.length ||
|
|
entry.skinActions.some((action: unknown, actionIndex: number) => !record(action) || action.id !== ids[actionIndex] ||
|
|
typeof action.enabled !== 'boolean' || typeof action.reason !== 'string' || action.reason.length > 512 ||
|
|
typeof action.label !== 'string' || action.label.length > 128)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native Skin actions');
|
|
}
|
|
}
|
|
if (label === 'Properties modifiers' && entry.dataLayoutActions !== undefined) {
|
|
if (type !== 'Data Transfer' || !Array.isArray(entry.dataLayoutActions) || entry.dataLayoutActions.length !== 1 ||
|
|
!record(entry.dataLayoutActions[0]) || entry.dataLayoutActions[0].id !== 'GENERATE_DATA_LAYERS' ||
|
|
typeof entry.dataLayoutActions[0].enabled !== 'boolean' ||
|
|
typeof entry.dataLayoutActions[0].reason !== 'string' || entry.dataLayoutActions[0].reason.length > 512 ||
|
|
typeof entry.dataLayoutActions[0].label !== 'string' || entry.dataLayoutActions[0].label.length > 128) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native Data Transfer actions');
|
|
}
|
|
}
|
|
if (label === 'Properties modifiers' && entry.multiresActions !== undefined) {
|
|
const ids = ['DELETE_HIGHER_LEVELS', 'SUBDIVIDE', 'RESHAPE', 'BASE_APPLY', 'UNSUBDIVIDE', 'REBUILD_SUBDIV', 'EXTERNAL_SAVE', 'EXTERNAL_PACK'];
|
|
if (type !== 'Multires' || !Array.isArray(entry.multiresActions) || entry.multiresActions.length !== ids.length ||
|
|
entry.multiresActions.some((action: unknown, actionIndex: number) => !record(action) || action.id !== ids[actionIndex] ||
|
|
typeof action.enabled !== 'boolean' || typeof action.reason !== 'string' || action.reason.length > 512 ||
|
|
typeof action.label !== 'string' || action.label.length > 128)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native Multires actions');
|
|
}
|
|
}
|
|
if ((label === 'Properties constraints' || label === 'Properties pose constraints') &&
|
|
entry.reorderable !== undefined && typeof entry.reorderable !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint reorder availability');
|
|
}
|
|
if (label === 'Properties pose constraints') {
|
|
text(entry.boneName, `${label}.boneName`, 63);
|
|
if (entry.targetBoneName !== undefined && (typeof entry.targetBoneName !== 'string' || entry.targetBoneName.length >= 64)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint target bone');
|
|
}
|
|
}
|
|
if (label === 'Properties constraints' && entry.targetBoneName !== undefined &&
|
|
(typeof entry.targetBoneName !== 'string' || entry.targetBoneName.length >= 64)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid object constraint target bone');
|
|
}
|
|
return entry as any;
|
|
});
|
|
};
|
|
const modifiers = parseStack(object.modifiers, 'Properties modifiers') as NativePropertiesObject['modifiers'];
|
|
let modifierTypes: NativePropertiesObject['modifierTypes'];
|
|
if (object.modifierTypes !== undefined) {
|
|
if (!Array.isArray(object.modifierTypes) || object.modifierTypes.length > 256) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier choices');
|
|
}
|
|
const ids = new Set<string>();
|
|
modifierTypes = object.modifierTypes.map(item => {
|
|
if (!record(item) || typeof item.enabled !== 'boolean' ||
|
|
typeof item.category !== 'string' || item.category.length > 256 ||
|
|
typeof item.reason !== 'string' || item.reason.length > 1024) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid modifier choice');
|
|
}
|
|
const id = text(item.id, 'Modifier choice ID', 256);
|
|
if (ids.has(id)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate modifier choice');
|
|
ids.add(id);
|
|
return { id, label: text(item.label, 'Modifier choice label', 256),
|
|
category: item.category, enabled: item.enabled, reason: item.reason };
|
|
});
|
|
}
|
|
const constraints = parseStack(object.constraints, 'Properties constraints') as NativePropertiesObject['constraints'];
|
|
const poseConstraints = parseStack(object.poseConstraints, 'Properties pose constraints') as NativePropertiesObject['poseConstraints'];
|
|
const activeModifierUuid = object.activeModifierUuid === undefined || object.activeModifierUuid === null ? null : text(object.activeModifierUuid, 'Properties active modifier UUID', 256);
|
|
const activeConstraintName = object.activeConstraintName === undefined || object.activeConstraintName === null ? null : text(object.activeConstraintName, 'Properties active constraint name', 63);
|
|
let activePoseConstraint: NativePropertiesObject['activePoseConstraint'] = null;
|
|
if (object.activePoseConstraint !== undefined && object.activePoseConstraint !== null) {
|
|
if (!record(object.activePoseConstraint)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid active pose constraint');
|
|
activePoseConstraint = { boneName: text(object.activePoseConstraint.boneName, 'Properties active pose bone', 63), name: text(object.activePoseConstraint.name, 'Properties active pose constraint', 63) };
|
|
}
|
|
space.properties.object = { id: text(object.id, 'Properties object ID'), name: text(object.name, 'Properties object name'), fields, meshId, modifiers, modifierTypes, activeModifierUuid, constraints, activeConstraintName, poseConstraints, activePoseConstraint };
|
|
if (object.stackEditable !== undefined) {
|
|
if (typeof object.stackEditable !== 'boolean') throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid stack editability');
|
|
space.properties.object.stackEditable = object.stackEditable;
|
|
}
|
|
if (object.poseBones !== undefined) {
|
|
if (!Array.isArray(object.poseBones) || object.poseBones.length > 65536) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid pose bones');
|
|
space.properties.object.poseBones = object.poseBones.map(bone => text(bone, 'Properties pose bone', 63));
|
|
}
|
|
if (object.constraintTargets !== undefined) {
|
|
if (!Array.isArray(object.constraintTargets)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint target choices');
|
|
}
|
|
space.properties.object.constraintTargets = object.constraintTargets.map(item => {
|
|
if (!record(item) || !['ARMATURE', 'CURVE', 'MESH', 'LATTICE', 'OTHER'].includes(item.kind as string) ||
|
|
!Array.isArray(item.bones) || item.bones.length > 65536) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint target choice');
|
|
}
|
|
const id = text(item.id, 'Constraint target ID');
|
|
if (!id.startsWith('object:')) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint target identity');
|
|
if (item.vertexGroups !== undefined && (!Array.isArray(item.vertexGroups) || item.vertexGroups.length > 65536)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint target vertex groups');
|
|
}
|
|
return { id, name: text(item.name, 'Constraint target name'),
|
|
kind: item.kind as 'ARMATURE' | 'CURVE' | 'MESH' | 'LATTICE' | 'OTHER',
|
|
bones: item.bones.map(bone => text(bone, 'Constraint target bone', 63)),
|
|
...(Array.isArray(item.vertexGroups) ? {
|
|
vertexGroups: item.vertexGroups.map(group => text(group, 'Constraint target vertex group', 63)),
|
|
} : {}) };
|
|
});
|
|
}
|
|
if (object.relations !== undefined) {
|
|
const relations = object.relations;
|
|
if (!record(relations) || typeof relations.editable !== 'boolean' ||
|
|
typeof relations.truncated !== 'boolean' || !Array.isArray(relations.candidates) ||
|
|
relations.candidates.length > 4096) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties relations');
|
|
}
|
|
const parentId = relations.parentId === null ? null : text(relations.parentId, 'Properties parent ID');
|
|
const parentName = relations.parentName === null ? null : text(relations.parentName, 'Properties parent name');
|
|
const candidates = relations.candidates.map(item => {
|
|
if (!record(item)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties parent candidate');
|
|
return { id: text(item.id, 'Properties parent candidate ID'), name: text(item.name, 'Properties parent candidate name') };
|
|
});
|
|
if ((parentId === null) !== (parentName === null) || parentId === object.id ||
|
|
candidates.some(item => item.id === object.id) ||
|
|
new Set(candidates.map(item => item.id)).size !== candidates.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Inconsistent Properties relations');
|
|
}
|
|
space.properties.object.relations = { parentId, parentName, editable: relations.editable,
|
|
candidates, truncated: relations.truncated };
|
|
if (relations.parenting !== undefined) {
|
|
const parenting = relations.parenting;
|
|
const validBone = (value: unknown): value is string => typeof value === 'string' &&
|
|
!value.includes('\0') && new TextEncoder().encode(value).length < 64;
|
|
if (!record(parenting) || !Array.isArray(parenting.types) || parenting.types.length > 6 ||
|
|
typeof parenting.typeEditable !== 'boolean' || typeof parenting.boneEditable !== 'boolean' ||
|
|
!validBone(parenting.bone) || !Array.isArray(parenting.bones) || parenting.bones.length > 4096 ||
|
|
!parenting.bones.every(value => validBone(value) && value.length > 0) ||
|
|
typeof parenting.bonesTruncated !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties parenting settings');
|
|
}
|
|
const types = parenting.types.map(item => {
|
|
if (!record(item) || !['OBJECT', 'ARMATURE', 'LATTICE', 'VERTEX', 'VERTEX_3', 'BONE'].includes(String(item.id))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties parent type');
|
|
}
|
|
return { id: text(item.id, 'Parent type ID'), label: text(item.label, 'Parent type label') };
|
|
});
|
|
const type = parenting.type === null ? null : text(parenting.type, 'Parent type');
|
|
if ((type !== null && !types.some(item => item.id === type)) ||
|
|
new Set(types.map(item => item.id)).size !== types.length ||
|
|
new Set(parenting.bones).size !== parenting.bones.length ||
|
|
(parenting.typeEditable && (!relations.editable || !parentId)) ||
|
|
(parenting.boneEditable && (!relations.editable || !parentId || type !== 'BONE'))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Inconsistent Properties parenting settings');
|
|
}
|
|
space.properties.object.relations.parenting = { type, types,
|
|
typeEditable: parenting.typeEditable, bone: parenting.bone, boneEditable: parenting.boneEditable,
|
|
bones: parenting.bones as string[], bonesTruncated: parenting.bonesTruncated };
|
|
if (parenting.settings !== undefined) {
|
|
if (!Array.isArray(parenting.settings) || parenting.settings.length > 4) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid parent detail settings');
|
|
}
|
|
const keys = new Set<string>();
|
|
space.properties.object.relations.parenting.settings = parenting.settings.map(item => {
|
|
if (!record(item) || !['parent_vertices', 'use_parent_final_indices', 'parent_bone_head_tail_factor'].includes(String(item.id)) ||
|
|
!Number.isSafeInteger(item.index) || typeof item.index !== 'number' ||
|
|
typeof item.editable !== 'boolean' || typeof item.minimum !== 'number' ||
|
|
typeof item.maximum !== 'number' || !Number.isFinite(item.minimum) ||
|
|
!Number.isFinite(item.maximum) || item.minimum > item.maximum) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid parent detail field');
|
|
}
|
|
const vertices = item.id === 'parent_vertices';
|
|
const finalIndices = item.id === 'use_parent_final_indices';
|
|
const vertexMode = type === 'VERTEX' || type === 'VERTEX_3';
|
|
const key = `${item.id}:${item.index}`;
|
|
if (!parentId || keys.has(key) ||
|
|
((vertices || finalIndices) ? !vertexMode : type !== 'BONE') ||
|
|
item.index < 0 || item.index >= (vertices && type === 'VERTEX_3' ? 3 : 1) ||
|
|
(item.editable && !relations.editable) ||
|
|
(vertices ? !Number.isSafeInteger(item.minimum) || !Number.isSafeInteger(item.maximum) ||
|
|
item.minimum < 0 || item.maximum > 2147483647 : item.minimum !== 0 || item.maximum !== 1) ||
|
|
(finalIndices ? typeof item.value !== 'boolean' : typeof item.value !== 'number' ||
|
|
!Number.isFinite(item.value) || item.value < item.minimum || item.value > item.maximum ||
|
|
(vertices && !Number.isSafeInteger(item.value)))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Inconsistent parent detail field');
|
|
}
|
|
keys.add(key);
|
|
return { id: item.id as PropertiesParentSetting, index: item.index,
|
|
label: text(item.label, 'Parent setting label'), value: item.value as number | boolean,
|
|
minimum: item.minimum, maximum: item.maximum, editable: item.editable };
|
|
});
|
|
}
|
|
}
|
|
}
|
|
for (const group of ['transforms', 'deltaTransforms', 'dimensions'] as const) {
|
|
if (object[group] === undefined) continue;
|
|
const mode = fields.find(field => field.id === 'rotation_mode')?.value;
|
|
const rotation = mode === 'QUATERNION' ? 'rotation_quaternion' : mode === 'AXIS_ANGLE' ? 'rotation_axis_angle' : 'rotation_euler';
|
|
const expected = group === 'dimensions' ? ['dimensions'] : group === 'transforms' ? ['location', rotation, 'scale'] :
|
|
['delta_location', ...(mode === 'AXIS_ANGLE' ? [] : [`delta_${rotation}`]), 'delta_scale'];
|
|
const nativeTransforms = object[group];
|
|
if (!Array.isArray(nativeTransforms) || nativeTransforms.length !== expected.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties transforms');
|
|
}
|
|
const transforms = nativeTransforms.map((field): NativePropertiesTransform => {
|
|
if (!record(field)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties transform');
|
|
const id = text(field.id, 'Properties transform field', 64) as PropertiesObjectTransform;
|
|
const length = Object.prototype.hasOwnProperty.call(PROPERTIES_OBJECT_TRANSFORM_LENGTHS, id) ? PROPERTIES_OBJECT_TRANSFORM_LENGTHS[id] : 0;
|
|
if (!length || !Array.isArray(field.values) || field.values.length !== length ||
|
|
!Array.isArray(field.editable) || field.editable.length !== length ||
|
|
!field.editable.every(value => typeof value === 'boolean')) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties transform components');
|
|
}
|
|
const minimum = finite(field.minimum, 'Properties transform minimum', -3.4028234663852886e38, 3.4028234663852886e38);
|
|
const maximum = finite(field.maximum, 'Properties transform maximum', minimum, 3.4028234663852886e38);
|
|
if (id === 'dimensions' && minimum < 0) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties dimensions range');
|
|
}
|
|
return { id, label: text(field.label, 'Properties transform label'), minimum, maximum,
|
|
values: field.values.map(value => finite(value, 'Properties transform value', -3.4028234663852886e38, 3.4028234663852886e38)),
|
|
editable: field.editable as boolean[] };
|
|
});
|
|
if ((group !== 'dimensions' && typeof mode !== 'string') || new Set(transforms.map(field => field.id)).size !== expected.length ||
|
|
!expected.every(id => transforms.some(field => field.id === id))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Properties transform mode is inconsistent');
|
|
}
|
|
space.properties.object[group] = transforms;
|
|
}
|
|
if (object.locks !== undefined) {
|
|
if (!Array.isArray(object.locks) || object.locks.length !== 5) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties transform locks');
|
|
}
|
|
const locks = object.locks.map((field): NativePropertiesLock => {
|
|
if (!record(field)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties transform lock');
|
|
const id = text(field.id, 'Properties transform lock', 64) as PropertiesObjectLock;
|
|
const length = Object.prototype.hasOwnProperty.call(PROPERTIES_OBJECT_LOCK_LENGTHS, id) ? PROPERTIES_OBJECT_LOCK_LENGTHS[id] : 0;
|
|
if (!length || !Array.isArray(field.values) || field.values.length !== length ||
|
|
!field.values.every(value => typeof value === 'boolean') ||
|
|
!Array.isArray(field.editable) || field.editable.length !== length ||
|
|
!field.editable.every(value => typeof value === 'boolean')) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties transform lock components');
|
|
}
|
|
return { id, label: text(field.label, 'Properties transform lock label'),
|
|
values: field.values as boolean[], editable: field.editable as boolean[] };
|
|
});
|
|
if (new Set(locks.map(field => field.id)).size !== 5) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate Properties transform lock');
|
|
}
|
|
space.properties.object.locks = locks;
|
|
}
|
|
}
|
|
else if (properties.object === null) space.properties.object = null;
|
|
if (properties.data !== undefined && properties.data !== null) {
|
|
const data = properties.data;
|
|
if (!record(data) || !Array.isArray(data.fields) || data.fields.length > EDITOR_WORKFLOW_BUDGET.maxPropertiesDataFields) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties data context');
|
|
}
|
|
const fields = data.fields.map((field): NativePropertiesDataField => {
|
|
if (!record(field)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties data field');
|
|
const arrayLayout = field.arrayLayout;
|
|
const array = Array.isArray(field.value) ? field.value : null;
|
|
const arrayShapeValid = array !== null && (
|
|
arrayLayout === 'MATRIX' ? array.length === 16 :
|
|
arrayLayout === 'SEQUENCE' ? field.id === 'joint_bindings' && array.length <= 256 &&
|
|
(array.length > 0 || field.editable === false) :
|
|
array.length >= 2 && array.length <= 4);
|
|
if (arrayLayout !== undefined &&
|
|
(!['COLOR', 'VECTOR', 'MATRIX', 'SEQUENCE'].includes(arrayLayout as string) || !arrayShapeValid)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties array layout');
|
|
}
|
|
if (!record(field) || typeof field.editable !== 'boolean' || !Array.isArray(field.items) ||
|
|
(typeof field.value !== 'boolean' && typeof field.value !== 'number' && typeof field.value !== 'string' &&
|
|
!(Array.isArray(field.value) && arrayShapeValid &&
|
|
field.value.every(component => typeof component === 'number' && Number.isFinite(component)))) ||
|
|
(typeof field.value === 'number' && !Number.isFinite(field.value))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties data field');
|
|
}
|
|
const items = field.items.map(item => {
|
|
if (!record(item)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties data option');
|
|
return { id: item.id === '' ? '' : text(item.id, 'Properties data option'), label: text(item.label, 'Properties data option label') };
|
|
});
|
|
if (new Set(items.map(item => item.id)).size !== items.length ||
|
|
(items.length > 0 && (typeof field.value !== 'string' || !items.some(item => item.id === field.value)))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Inconsistent Properties data field');
|
|
}
|
|
const minimum = field.minimum;
|
|
const maximum = field.maximum;
|
|
if (field.integer !== undefined && (typeof field.integer !== 'boolean' ||
|
|
(field.integer && !Number.isSafeInteger(field.value)))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties integer field');
|
|
}
|
|
if ((minimum !== undefined && (typeof minimum !== 'number' || !Number.isFinite(minimum))) ||
|
|
(maximum !== undefined && (typeof maximum !== 'number' || !Number.isFinite(maximum))) ||
|
|
(minimum !== undefined && maximum !== undefined && minimum > maximum)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties data field range');
|
|
}
|
|
if (field.status !== undefined && (typeof field.status !== 'string' || field.status.length > 4096)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties data field status');
|
|
}
|
|
if (field.description !== undefined && (typeof field.description !== 'string' || field.description.length > 4096)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Properties data field description');
|
|
}
|
|
return { id: text(field.id, 'Properties data field', 64), label: text(field.label, 'Properties data field label'),
|
|
editable: field.editable, value: field.value, items,
|
|
...(field.description !== undefined ? { description: field.description } : {}),
|
|
...(field.integer !== undefined ? { integer: field.integer as boolean } : {}),
|
|
...(arrayLayout !== undefined ? { arrayLayout: arrayLayout as NativePropertiesDataField['arrayLayout'] } : {}),
|
|
...(minimum !== undefined ? { minimum } : {}), ...(maximum !== undefined ? { maximum } : {}),
|
|
...(field.status !== undefined ? { status: field.status } : {}) };
|
|
});
|
|
if (new Set(fields.map(field => field.id)).size !== fields.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate Properties data field');
|
|
}
|
|
if (context === null || !['TOOL', 'SCENE', 'RENDER', 'OUTPUT', 'VIEW_LAYER', 'WORLD', 'COLLECTION', 'OBJECT', 'CONSTRAINT', 'MODIFIER', 'DATA', 'BONE', 'BONE_CONSTRAINT', 'MATERIAL', 'TEXTURE', 'PARTICLES', 'PHYSICS', 'SHADERFX', 'STRIP', 'STRIP_MODIFIER'].includes(context)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `Unsupported Properties data context: ${String(context)} at ${areaName}`);
|
|
space.properties.data = { id: text(data.id, 'Properties data ID'), name: text(data.name, 'Properties data name'), fields };
|
|
if (data.aovs !== undefined) {
|
|
const aovs = data.aovs;
|
|
if (context !== 'VIEW_LAYER' || !record(aovs) || typeof aovs.editable !== 'boolean' || !Array.isArray(aovs.rows)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid View Layer AOV context');
|
|
const rows = aovs.rows.map(row => {
|
|
if (!record(row) || typeof row.isValid !== 'boolean') throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid View Layer AOV row');
|
|
return { name: text(row.name, 'AOV name'), type: integer(row.type, 'AOV type', 0, 1) as 0 | 1, isValid: row.isValid }; });
|
|
space.properties.data.aovs = { sceneId: text(aovs.sceneId, 'AOV Scene'), layerName: text(aovs.layerName, 'AOV View Layer'), editable: aovs.editable, activeIndex: integer(aovs.activeIndex, 'AOV active index', -1, Math.max(-1, rows.length - 1)), rows };
|
|
}
|
|
if (data.lightgroups !== undefined) { const groups = data.lightgroups; if (context !== 'VIEW_LAYER' || !record(groups) || typeof groups.editable !== 'boolean' || !Array.isArray(groups.rows)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid View Layer Light Groups context'); const rows = groups.rows.map(name => text(name, 'Light Group name')); space.properties.data.lightgroups = { sceneId: text(groups.sceneId, 'Light Group Scene'), layerName: text(groups.layerName, 'Light Group View Layer'), editable: groups.editable, activeIndex: integer(groups.activeIndex, 'Light Group active index', -1, Math.max(-1, rows.length - 1)), rows }; }
|
|
if (data.shapeKeys !== undefined) {
|
|
const shapes = data.shapeKeys;
|
|
if (context !== 'DATA' || !record(shapes) || typeof shapes.editable !== 'boolean' ||
|
|
typeof shapes.activeUid !== 'number' || !Number.isSafeInteger(shapes.activeUid) ||
|
|
!Array.isArray(shapes.rows) || !Array.isArray(shapes.operations)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Shape Key context');
|
|
}
|
|
const rows = shapes.rows.map(row => {
|
|
if (!record(row) || typeof row.uid !== 'number' || !Number.isSafeInteger(row.uid) ||
|
|
typeof row.selected !== 'boolean' || typeof row.muted !== 'boolean' || typeof row.locked !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Shape Key row');
|
|
}
|
|
return { uid: row.uid, name: text(row.name, 'Shape Key name'),
|
|
selected: row.selected, muted: row.muted, locked: row.locked };
|
|
});
|
|
const operations = shapes.operations.map(operation => {
|
|
if (!record(operation) || typeof operation.enabled !== 'boolean' ||
|
|
typeof operation.reason !== 'string' || operation.reason.length > 4096 ||
|
|
(operation.sources !== undefined && (!Array.isArray(operation.sources) || operation.sources.length > 1024))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Shape Key operation');
|
|
}
|
|
return { id: text(operation.id, 'Shape Key operation'), label: text(operation.label, 'Shape Key label'),
|
|
enabled: operation.enabled, reason: operation.reason,
|
|
...(Array.isArray(operation.sources) ? { sources: operation.sources.map(source => text(source, 'Shape Key source', 2048)) } : {}) };
|
|
});
|
|
if (new Set(rows.map(row => row.uid)).size !== rows.length ||
|
|
new Set(operations.map(operation => operation.id)).size !== operations.length ||
|
|
(shapes.activeUid !== 0 && !rows.some(row => row.uid === shapes.activeUid))) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Inconsistent Shape Key context');
|
|
}
|
|
space.properties.data.shapeKeys = {
|
|
objectId: text(shapes.objectId, 'Shape Key object ID'),
|
|
keyId: shapes.keyId === '' ? '' : text(shapes.keyId, 'Shape Key data ID'),
|
|
activeUid: shapes.activeUid, editable: shapes.editable, rows, operations,
|
|
};
|
|
}
|
|
if (data.shapeKeyMirror !== undefined) {
|
|
const mirror = data.shapeKeyMirror;
|
|
if (context !== 'DATA' || !record(mirror) ||
|
|
typeof mirror.activeUid !== 'number' || !Number.isSafeInteger(mirror.activeUid) ||
|
|
typeof mirror.enabled !== 'boolean' || typeof mirror.topologyEnabled !== 'boolean' ||
|
|
typeof mirror.reason !== 'string' || mirror.reason.length > 4096 ||
|
|
(mirror.topologyEnabled && !mirror.enabled)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Shape Key mirror context');
|
|
}
|
|
space.properties.data.shapeKeyMirror = {
|
|
objectId: text(mirror.objectId, 'Shape Key object ID'),
|
|
keyId: mirror.keyId === '' ? '' : text(mirror.keyId, 'Shape Key data ID'),
|
|
activeUid: mirror.activeUid,
|
|
name: mirror.name === '' ? '' : text(mirror.name, 'Shape Key name'),
|
|
enabled: mirror.enabled, topologyEnabled: mirror.topologyEnabled, reason: mirror.reason,
|
|
};
|
|
}
|
|
if (data.cacheLayers !== undefined) {
|
|
if (!['MODIFIER', 'CONSTRAINT', 'BONE_CONSTRAINT'].includes(context) ||
|
|
!Array.isArray(data.cacheLayers) || data.cacheLayers.length > 128 ||
|
|
typeof data.cacheActiveLayer !== 'number' || !Number.isInteger(data.cacheActiveLayer) ||
|
|
data.cacheActiveLayer < -1 || data.cacheActiveLayer >= data.cacheLayers.length ||
|
|
typeof data.cacheLayersEditable !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid CacheFile layers');
|
|
}
|
|
space.properties.data.cacheLayers = data.cacheLayers.map(layer => {
|
|
if (!record(layer) || typeof layer.hidden !== 'boolean') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid CacheFile layer');
|
|
}
|
|
return { filepath: text(layer.filepath, 'CacheFile layer path', 4096), hidden: layer.hidden };
|
|
});
|
|
space.properties.data.cacheActiveLayer = data.cacheActiveLayer;
|
|
space.properties.data.cacheLayersEditable = data.cacheLayersEditable;
|
|
}
|
|
if (data.constraintOperations !== undefined) {
|
|
if (!['CONSTRAINT', 'BONE_CONSTRAINT'].includes(context) || !Array.isArray(data.constraintOperations)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint operations');
|
|
}
|
|
space.properties.data.constraintOperations = data.constraintOperations.map(operation => {
|
|
if (!record(operation) || typeof operation.enabled !== 'boolean' || typeof operation.reason !== 'string' ||
|
|
(operation.menu !== undefined && typeof operation.menu !== 'boolean') ||
|
|
operation.reason.length > 4096 || typeof operation.description !== 'string') {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native constraint operation');
|
|
}
|
|
if (operation.parameters !== undefined && !Array.isArray(operation.parameters)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid constraint operation parameters');
|
|
}
|
|
const parameters = (operation.parameters ?? []).map(parameter => {
|
|
if (!record(parameter) || typeof parameter.description !== 'string' ||
|
|
!Number.isSafeInteger(parameter.minimum) || !Number.isSafeInteger(parameter.maximum) ||
|
|
!Number.isSafeInteger(parameter.defaultValue) || Number(parameter.minimum) > Number(parameter.maximum)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid native constraint integer parameter');
|
|
}
|
|
return { id: text(parameter.id, 'Constraint parameter', 64), label: text(parameter.label, 'Constraint parameter label'),
|
|
description: parameter.description, minimum: Number(parameter.minimum), maximum: Number(parameter.maximum),
|
|
defaultValue: finite(parameter.defaultValue, 'Constraint parameter default', Number(parameter.minimum), Number(parameter.maximum)) };
|
|
});
|
|
if (new Set(parameters.map(parameter => parameter.id)).size !== parameters.length) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Duplicate constraint operation parameter');
|
|
}
|
|
return { id: text(operation.id, 'Constraint operator', 128), label: text(operation.label, 'Constraint operation label'),
|
|
description: operation.description, enabled: operation.enabled, reason: operation.reason,
|
|
menu: operation.menu === true, parameters };
|
|
});
|
|
}
|
|
if (data.armatureTargets !== undefined) {
|
|
if (!['CONSTRAINT', 'BONE_CONSTRAINT'].includes(context) || !Array.isArray(data.armatureTargets) ||
|
|
typeof data.targetsEditable !== 'boolean' || !Array.isArray(data.armatures)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Armature target collection');
|
|
}
|
|
space.properties.data.armatureTargets = data.armatureTargets.map(target => {
|
|
if (!record(target)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Armature target');
|
|
return { objectId: target.objectId === '' ? '' : text(target.objectId, 'Armature target object'),
|
|
bone: target.bone === '' ? '' : text(target.bone, 'Armature target bone', 63),
|
|
weight: finite(target.weight, 'Armature target weight', 0, 1) };
|
|
});
|
|
space.properties.data.targetsEditable = data.targetsEditable;
|
|
space.properties.data.armatures = data.armatures.map(armature => {
|
|
if (!record(armature) || !Array.isArray(armature.bones)) {
|
|
throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', 'Invalid Armature target candidates');
|
|
}
|
|
return { id: text(armature.id, 'Armature candidate'), name: text(armature.name, 'Armature name'),
|
|
bones: armature.bones.map(bone => text(bone, 'Armature bone', 63)) };
|
|
});
|
|
}
|
|
}
|
|
else if (properties.data === null) space.properties.data = null;
|
|
}
|
|
if (areaValue.space.imageView !== undefined) {
|
|
const view = areaValue.space.imageView;
|
|
if (!record(view)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.imageView is invalid`);
|
|
space.imageView = {
|
|
zoom: finite(view.zoom, `${areaName}.zoom`, Number.MIN_VALUE, Number.MAX_VALUE),
|
|
offsetX: finite(view.offsetX, `${areaName}.offsetX`, -Number.MAX_VALUE, Number.MAX_VALUE),
|
|
offsetY: finite(view.offsetY, `${areaName}.offsetY`, -Number.MAX_VALUE, Number.MAX_VALUE),
|
|
width: integer(view.width, `${areaName}.imageWidth`, 1, 2147483647),
|
|
height: integer(view.height, `${areaName}.imageHeight`, 1, 2147483647),
|
|
aspectX: finite(view.aspectX, `${areaName}.aspectX`, Number.MIN_VALUE, Number.MAX_VALUE),
|
|
aspectY: finite(view.aspectY, `${areaName}.aspectY`, Number.MIN_VALUE, Number.MAX_VALUE),
|
|
};
|
|
}
|
|
if (areaValue.space.uvPackTarget !== undefined) space.uvPackTarget = parseNativeUVPackTarget(areaValue.space.uvPackTarget);
|
|
if (areaValue.space.textSelection !== undefined) {
|
|
const selection = areaValue.space.textSelection;
|
|
if (!record(selection)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.textSelection is invalid`);
|
|
const position = (key: 'anchor' | 'focus'): TextCursorIR => {
|
|
const cursor = selection[key];
|
|
if (!record(cursor)) throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID', `${areaName}.${key} is invalid`);
|
|
return {line: integer(cursor.line, `${areaName}.${key}.line`, 0, 65535), column: integer(cursor.column, `${areaName}.${key}.column`, 0, 1048576)};
|
|
};
|
|
space.textSelection = {anchor: position('anchor'), focus: position('focus')};
|
|
}
|
|
if (areaValue.space.view !== undefined) {
|
|
const source=areaValue.space.view;
|
|
if(!record(source)||!Array.isArray(source.offset)||source.offset.length!==3||!Array.isArray(source.rotation)||source.rotation.length!==4||![...source.offset,...source.rotation,source.distance,source.lens,source.near,source.far].every(item=>typeof item==='number'&&Number.isFinite(item))||!['PERSPECTIVE','ORTHOGRAPHIC','CAMERA'].includes(source.projection as string))throw new EditorWorkflowValidationError('EDITOR_LAYOUT_INVALID',`${areaName}.view is invalid`);
|
|
space.view={offset:[...source.offset] as NativeViewportState['offset'],rotation:[...source.rotation] as NativeViewportState['rotation'],distance:source.distance as number,lens:source.lens as number,near:source.near as number,far:source.far as number,projection:source.projection as NativeViewportState['projection'],locked:source.locked===true};
|
|
}
|
|
}
|
|
return { id: areaId, editor: areaValue.editor as EditorTypeIR, regions, rect: rect(areaValue.rect, `${areaName}.rect`), maximized: areaValue.maximized === true, nativeLayout, filterText: filterText as string | undefined, space };
|
|
});
|
|
const activeAreaId = text(workspaceValue.activeAreaId, `${name}.activeAreaId`); if (!areaIds.has(activeAreaId)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name}.activeAreaId is missing`);
|
|
for (let index = 0; index < areas.length; index++) for (let other = index + 1; other < areas.length; other++) if (!areas[index].maximized && !areas[other].maximized && overlap(areas[index].rect, areas[other].rect)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `${name} has overlapping areas`);
|
|
areas.forEach((area, areaIndex) => area.regions.forEach((region, regionIndex) => {
|
|
const source = (workspaceValue.areas as Array<{ regions: Array<Record<string, unknown>> }>)[areaIndex].regions[regionIndex];
|
|
region.toggleable = source.toggleable === true;
|
|
}));
|
|
return { id, name: text(workspaceValue.name, `${name}.name`), screenId: workspaceValue.screenId === undefined ? undefined : text(workspaceValue.screenId, `${name}.screenId`), writable: workspaceValue.writable === true, areas, activeAreaId, revision: integer(workspaceValue.revision, `${name}.revision`, 0, Number.MAX_SAFE_INTEGER) };
|
|
});
|
|
const contextValue = value.context; const workspaceId = text(contextValue.workspaceId, "context.workspaceId"); const workspace = workspaces.find((item) => item.id === workspaceId); if (!workspace) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", "Context workspace is missing");
|
|
const activeAreaId = text(contextValue.activeAreaId, "context.activeAreaId"); const activeArea = workspace.areas.find((item) => item.id === activeAreaId); if (!activeArea || activeArea.editor !== contextValue.activeEditor) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", "Context active area/editor is inconsistent");
|
|
if (!EDITOR_TYPES.includes(contextValue.activeEditor as EditorTypeIR) || !EDITOR_MODES.includes(contextValue.mode as EditorMode) || !Array.isArray(contextValue.selection)) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", "Context is invalid");
|
|
if (contextValue.selection.length > EDITOR_WORKFLOW_BUDGET.maxSelection || contextValue.selection.some((item) => typeof item !== "string" || item.length === 0)) throw new EditorWorkflowValidationError("EDITOR_SELECTION_INVALID", "Selection exceeds the budget");
|
|
if (contextValue.activeObjectId !== null && typeof contextValue.activeObjectId !== "string") throw new EditorWorkflowValidationError("EDITOR_SELECTION_INVALID", "Active object is invalid");
|
|
const keymapIds = new Set<string>(); const keymaps: KeymapBindingIR[] = [];
|
|
value.keymaps.forEach((bindingValue, index) => {
|
|
const name = `keymaps[${index}]`; if (!record(bindingValue) || !Array.isArray(bindingValue.modifiers)) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", `${name} is invalid`);
|
|
const id = text(bindingValue.id, `${name}.id`); if (keymapIds.has(id)) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", `Duplicate keymap ${id}`); keymapIds.add(id);
|
|
const modifiers = bindingValue.modifiers.map((modifier, modifierIndex) => text(modifier, `${name}.modifiers[${modifierIndex}]`, 16).toUpperCase()); if (new Set(modifiers).size !== modifiers.length || modifiers.some((modifier) => !["ALT", "CTRL", "META", "SHIFT"].includes(modifier))) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", `${name} modifiers are invalid or duplicate`); modifiers.sort();
|
|
const parseScope = <T extends string>(field: "workspaceIds" | "editors" | "modes", allowed?: readonly T[]): T[] | undefined => {
|
|
const source = bindingValue[field]; if (source === undefined) return undefined;
|
|
if (!Array.isArray(source) || source.length === 0 || source.length > 64) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", `${name}.${field} is invalid`);
|
|
const parsed = source.map((item, scopeIndex) => text(item, `${name}.${field}[${scopeIndex}]`, 256) as T);
|
|
if (new Set(parsed).size !== parsed.length || (allowed && parsed.some((item) => !allowed.includes(item)))) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", `${name}.${field} is invalid or duplicated`);
|
|
return parsed;
|
|
};
|
|
const binding: KeymapBindingIR = { id, key: text(bindingValue.key, `${name}.key`, 32).toUpperCase(), modifiers, command: text(bindingValue.command, `${name}.command`, 128), enabled: bindingValue.enabled !== false, workspaceIds: parseScope("workspaceIds"), editors: parseScope("editors", EDITOR_TYPES), modes: parseScope("modes", EDITOR_MODES) };
|
|
if (binding.workspaceIds?.some((workspace) => !workspaceIds.has(workspace))) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", `${name}.workspaceIds references a missing workspace`);
|
|
if (binding.enabled && keymaps.some((candidate) => candidate.enabled && candidate.key === binding.key && candidate.modifiers.join("+") === binding.modifiers.join("+") && keymapScopesOverlap(candidate, binding))) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", `${name} conflicts with another enabled keymap in the same context`);
|
|
keymaps.push(binding);
|
|
});
|
|
return { schemaVersion: EDITOR_WORKFLOW_SCHEMA, workspaces, uvSelection: parseUVSelection(value.uvSelection), context: { workspaceId, activeAreaId, activeEditor: contextValue.activeEditor as EditorTypeIR, mode: contextValue.mode as EditorMode, activeObjectId: contextValue.activeObjectId as string | null, selection: [...contextValue.selection] as string[], viewLayer: text(contextValue.viewLayer, "context.viewLayer"), pinnedData: contextValue.pinnedData === null ? null : text(contextValue.pinnedData, "context.pinnedData"), revision: integer(contextValue.revision, "context.revision", 0, Number.MAX_SAFE_INTEGER) }, keymaps };
|
|
}
|
|
|
|
export function keyChordFromKeyboardEvent(event: Pick<KeyboardEvent, "key" | "altKey" | "ctrlKey" | "metaKey" | "shiftKey">): KeyChordIR {
|
|
const key = text(event.key, "event.key", 32).toUpperCase();
|
|
const modifiers: KeyChordIR["modifiers"] = [];
|
|
if (event.altKey) modifiers.push("ALT");
|
|
if (event.ctrlKey) modifiers.push("CTRL");
|
|
if (event.metaKey) modifiers.push("META");
|
|
if (event.shiftKey) modifiers.push("SHIFT");
|
|
return { key, modifiers };
|
|
}
|
|
|
|
export function resolveKeymapCommand(value: unknown, chordValue: unknown): string | null {
|
|
const workflow = parseEditorWorkflow(value);
|
|
if (!record(chordValue) || !Array.isArray(chordValue.modifiers)) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", "Key chord is invalid");
|
|
const chord = { key: text(chordValue.key, "keyChord.key", 32).toUpperCase(), modifiers: chordValue.modifiers.map((modifier, index) => text(modifier, `keyChord.modifiers[${index}]`, 16).toUpperCase()).sort() };
|
|
if (new Set(chord.modifiers).size !== chord.modifiers.length || chord.modifiers.some((modifier) => !["ALT", "CTRL", "META", "SHIFT"].includes(modifier))) throw new EditorWorkflowValidationError("EDITOR_KEYMAP_INVALID", "Key chord modifiers are invalid");
|
|
return workflow.keymaps.find((binding) => binding.enabled && binding.key === chord.key && binding.modifiers.join("+") === chord.modifiers.join("+") &&
|
|
(!binding.workspaceIds || binding.workspaceIds.includes(workflow.context.workspaceId)) &&
|
|
(!binding.editors || binding.editors.includes(workflow.context.activeEditor)) &&
|
|
(!binding.modes || binding.modes.includes(workflow.context.mode)))?.command ?? null;
|
|
}
|
|
|
|
export function applyEditorWorkflowEdit(value: unknown, edit: EditorWorkflowEditIR): EditorWorkflowIR {
|
|
const workflow = parseEditorWorkflow(value); if (edit.revision !== workflow.context.revision) throw new EditorWorkflowValidationError("REVISION_CONFLICT", "Editor context revision is stale"); const clone = structuredClone(workflow);
|
|
if (edit.type === "SWITCH_WORKSPACE") { const workspace = clone.workspaces.find((item) => item.id === edit.workspaceId); if (!workspace) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `Unknown workspace ${edit.workspaceId}`); clone.context.workspaceId = workspace.id; clone.context.activeAreaId = workspace.activeAreaId; clone.context.activeEditor = workspace.areas.find((item) => item.id === workspace.activeAreaId)?.editor ?? "VIEW_3D"; }
|
|
else if (edit.type === "SET_ACTIVE_AREA") { const workspace = clone.workspaces.find((item) => item.id === clone.context.workspaceId); const area = workspace?.areas.find((item) => item.id === edit.areaId); if (!area) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `Unknown area ${edit.areaId}`); clone.context.activeAreaId = area.id; clone.context.activeEditor = area.editor; }
|
|
else if (edit.type === "SET_SELECTION") { if (new Set(edit.selectedIds).size !== edit.selectedIds.length || edit.selectedIds.length > EDITOR_WORKFLOW_BUDGET.maxSelection || edit.selectedIds.some((id) => typeof id !== "string" || !id)) throw new EditorWorkflowValidationError("EDITOR_SELECTION_INVALID", "Selection is invalid"); if (edit.activeObjectId !== null && !edit.selectedIds.includes(edit.activeObjectId)) throw new EditorWorkflowValidationError("EDITOR_SELECTION_INVALID", "Active object must be selected"); clone.context.selection = [...edit.selectedIds]; clone.context.activeObjectId = edit.activeObjectId; }
|
|
else { const area = clone.workspaces.find((item) => item.id === clone.context.workspaceId)?.areas.find((item) => item.id === edit.areaId); const region = area?.regions.find((item) => item.id === edit.regionId); if (!region) throw new EditorWorkflowValidationError("EDITOR_LAYOUT_INVALID", `Unknown region ${edit.regionId}`); region.visible = edit.visible; }
|
|
clone.context.revision += 1; return parseEditorWorkflow(clone);
|
|
}
|
|
|
|
export function gateEditorOperation(operation: "READ_ONLY_VIEW" | "SELECTION_SYNC" | "KEYMAP" | "WRITER" | "GIZMO" | "TOUCH_DRAG"): CapabilityGateResult {
|
|
if (["READ_ONLY_VIEW", "SELECTION_SYNC", "KEYMAP"].includes(operation)) return readyGate("N-024", operation);
|
|
return blockedGate("N-024", operation, [capabilityIssue(operation === "GIZMO" || operation === "TOUCH_DRAG" ? "EDITOR_GIZMO_UNAVAILABLE" : "EDITOR_WRITER_UNAVAILABLE", `${operation} requires editor-specific Main transaction and interaction verification`)]);
|
|
}
|