@plaudit/gutenberg-api-extensions 2.95.0 → 2.96.0

package/src/blocks/conditions.ts

@@ -1,261 +0,0 @@
-import {store as blocksStore, type BlockInstance} from "@wordpress/blocks";
-import {store as blockEditorStore} from "@wordpress/block-editor";
-import {select} from "@wordpress/data";
-
-import type {DataStore, NodePath, RawPath} from "./simple-native-property-api";
-
-export type CombinerOp = "and"|"or"|"not"|"nand"|"nor";
-export type CombinerConditionTest = {op: CombinerOp, conditions: ConditionStruct};
-export type PropertyConditionTest = {op: "=="|"!="|">"|"<"|">="|"<="|"in"|"!in"|"contains"|"!contains", property: string, value: any}|{op: "empty"|"!empty", property: string};
-export type ConditionTest = PropertyConditionTest|CombinerConditionTest;
-export type ConditionStruct = Array<ConditionTest|ConditionStruct>;
-export type ConditionFunction = (propertyValueResolver: (propertyPath: RawPath) => any) => boolean;
-export type Condition = ConditionFunction|ConditionStruct|undefined;
-
-export function isCombinerCondition(condition: ConditionTest): condition is CombinerConditionTest {
-	return condition.op === "and" || condition.op === "or" || condition.op === "not" || condition.op === "nand" || condition.op === "nor";
-}
-
-export function testCondition(condition: Condition, propertyValueResolver: (propertyPath: RawPath) => any) {
-	if (condition === undefined) {
-		return true;
-	}
-	if (Array.isArray(condition)) {
-		return condition.length === 0 || testConditionStruct(condition, propertyValueResolver, "or");
-	}
-	return condition(propertyValueResolver);
-}
-function performConditionTest(condition: ConditionTest, propertyValueResolver: (propertyPath: RawPath) => any): boolean {
-	if (isCombinerCondition(condition)) {
-		return testConditionStruct(condition.conditions, propertyValueResolver, condition.op);
-	}
-	const attrValue = propertyValueResolver(condition.property.split("."));
-	if (!('value' in condition)) { // We negate this in order to ensure that unchecked values in the switch will throw a compile-time error
-		return condition.op === "empty" ? !attrValue : !!attrValue;
-	}
-	switch (condition.op) {
-		case "contains":
-			return attrContains(condition.value, attrValue);
-		case "!contains":
-			return !attrContains(condition.value, attrValue);
-		case "in":
-			return isIn(condition.value, attrValue);
-		case "!in":
-			return !isIn(condition.value, attrValue);
-		case "==":
-			return attrValue == condition.value;
-		case "!=":
-			return attrValue != condition.value;
-		case ">":
-			return attrValue > condition.value;
-		case "<":
-			return attrValue < condition.value;
-		case ">=":
-			return attrValue >= condition.value;
-		case "<=":
-			return attrValue <= condition.value;
-	}
-}
-function isIn(conditionValue: any, attrValue: any): boolean {
-	if (typeof conditionValue === 'string') {
-		return conditionValue.includes(attrValue?.toString());
-	} else if (Array.isArray(conditionValue)) {
-		return conditionValue.some(condVal => condVal == attrValue); // This is a "coercive" version of includes
-	} else {
-		if (conditionValue !== undefined) {
-			console.error(`The in operators only support arrays and strings as their value. Received ${conditionValue} instead`);
-		}
-		return false;
-	}
-}
-function attrContains(conditionValue: any, attrValue: any): boolean {
-	if (typeof attrValue === 'string') {
-		return attrValue.includes(conditionValue?.toString());
-	} else if (Array.isArray(attrValue)) {
-		return attrValue.some(attVal => attVal == conditionValue); // This is a "coercive" version of includes
-	} else {
-		if (attrValue !== undefined) {
-			console.error(`The contains operators only support arrays and strings as their value. Received ${attrValue} instead`);
-		}
-		return false;
-	}
-}
-function testConditionStruct(conditions: ConditionStruct, propertyValueResolver: (propertyPath: RawPath) => any, combiner: CombinerOp = "and"): boolean {
-	switch (combiner) {
-		case "and":
-			for (const condition of conditions) {
-				if (!(Array.isArray(condition) ? testConditionStruct(conditions, propertyValueResolver, "and") : performConditionTest(condition, propertyValueResolver))) {
-					return false;
-				}
-			}
-			return true;
-		case "or":
-			for (const condition of conditions) {
-				if ((Array.isArray(condition) ? testConditionStruct(conditions, propertyValueResolver, "and") : performConditionTest(condition, propertyValueResolver))) {
-					return true;
-				}
-			}
-			return false;
-		case "not":
-		case "nand":
-			for (const condition of conditions) {
-				if (!(Array.isArray(condition) ? testConditionStruct(conditions, propertyValueResolver, "and") : performConditionTest(condition, propertyValueResolver))) {
-					return true;
-				}
-			}
-			return false;
-		case "nor":
-			for (const condition of conditions) {
-				if ((Array.isArray(condition) ? testConditionStruct(conditions, propertyValueResolver, "and") : performConditionTest(condition, propertyValueResolver))) {
-					return false;
-				}
-			}
-			return true;
-	}
-}
-
-export function resolveValueForCondition(propertyPath: RawPath, contextPath: RawPath, blockClientId: string, getDataStore: (property: string) => DataStore|undefined) {
-	if (propertyPath[0] === "@block") {
-		if (propertyPath.length >= 2) {
-			const blockEditorSelect = select(blockEditorStore);
-			if (typeof propertyPath[1] === 'string') {
-				if (propertyPath[1] === 'parentClientId') {
-					console.warn("Using parentClientId is deprecated. Please use clientId(1) instead.");
-					return blockEditorSelect.getBlockParents(blockClientId, true)[0];
-				}
-				const potentialProperty = /^(anchor|attributes|className|clientId|name|variation)(?:\((\d+)\))?$/.exec(propertyPath[1]);
-				if (potentialProperty !== null) {
-					// This type is just the first group of the pattern's possible values
-					const matchedProperty = potentialProperty[1] as ('anchor'|'attributes'|'className'|'clientId'|'name'|'variation');
-					const index = potentialProperty[2] ? parseInt(potentialProperty[2]) : 0;
-					const targetClientId = index ? blockEditorSelect.getBlockParents(blockClientId, true)[index - 1] : blockClientId;
-					if (targetClientId === undefined || matchedProperty === "clientId") {
-						// We handle the clientId property separately to avoid an unnecessary state lookup
-						return targetClientId;
-					}
-
-					let targetBlockInstance: BlockInstance|null;
-					if (index) {
-						const targetBlockClientId = blockEditorSelect.getBlockParents(blockClientId, true)[index - 1];
-						targetBlockInstance = targetBlockClientId ? blockEditorSelect.getBlock(targetBlockClientId) : null;
-					} else {
-						targetBlockInstance = blockEditorSelect.getBlock(blockClientId);
-					}
-					if (!targetBlockInstance) {
-						return undefined;
-					}
-					if (matchedProperty === "attributes") {
-						return walkToNodeWithLogging(targetBlockInstance.attributes, propertyPath.slice(2));
-					}
-
-					if (propertyPath.length > 2) {
-						console.error(`@block.${matchedProperty} cannot have any additional terms in the path. They will be ignored.`);
-					}
-					switch (matchedProperty) {
-						case "anchor":
-							return targetBlockInstance.attributes["anchor"] ?? "";
-						case "className":
-							return targetBlockInstance.attributes["className"] ?? "";
-						case "name":
-							return targetBlockInstance.name;
-						case "variation":
-							return (select(blocksStore) as any).getActiveBlockVariation(targetBlockInstance.name, targetBlockInstance.attributes)?.name;
-					}
-				}
-			}
-			console.error(`Cannot resolve "${propertyPath[1]}" as a Block property.`);
-			return undefined;
-		}
-	}
-	const actualPath = resolveActualPathToValueForCondition(propertyPath, contextPath);
-	if (actualPath === undefined) {
-		return undefined;
-	}
-	const dataStore = getDataStore(actualPath[0]);
-	return walkToNodeWithLogging(dataStore ? dataStore.getValue(actualPath[0]) : select(blockEditorStore).getBlockAttributes(blockClientId)?.[actualPath[0]], actualPath);
-}
-
-function resolveActualPathToValueForCondition(propertyPath: RawPath, contextPath: RawPath): NodePath|undefined {
-	if (propertyPath.length === 0) {
-		return undefined; //TODO: Log an error
-	}
-	let actualPath = [...contextPath];
-
-	let sawRoot = false;
-	let encounteredParents = 0;
-	let relativePath: RawPath = [];
-	for (let i = 0, nodeName: (typeof propertyPath[number])|undefined; i < propertyPath.length; i++) {
-		nodeName = propertyPath[i];
-		if (nodeName === '@root') {
-			if (i > 0) {
-				console.error("Encountered an improperly-placed '@root' name. '@root' must the first name in the path.", "It will be skipped.", `Preceding Part: ${relativePath.join(".")}`);
-			}
-			sawRoot = true;
-			actualPath = [];
-		} else if (nodeName === '@parent') {
-			if (sawRoot) {
-				console.error("Encountered a '@parent' name after encountering a '@root' name.", "It will be skipped.", `Preceding Part: ${relativePath.join(".")}`);
-			} else if (relativePath.length > 0) {
-				console.error("Encountered a '@parent' name after the first non-special name.", "It will be skipped.", `Preceding Part: ${relativePath.join(".")}`);
-			} else {
-				if (encounteredParents === actualPath.length - 1) { // The -1 is because we already remove the last node
-					console.error("Encountered a '@parent' name that would attempt to resolve the parent of the root.", "It will be skipped.", `Preceding Part: ${relativePath.join(".")}`);
-				}
-				encounteredParents++;
-			}
-		} else if (nodeName !== undefined) {
-			relativePath.push(nodeName);
-		}
-	}
-	if (encounteredParents >= actualPath.length - 1) {
-		actualPath = [];
-	} else {
-		actualPath = actualPath.slice(0, actualPath.length - encounteredParents - 1);
-	}
-
-	actualPath.push(...relativePath);
-	if (actualPath.length === 0 || typeof actualPath[0] !== 'string') {
-		console.error("Encountered an invalid path-resolution pair (context:", contextPath.join("."), ", property: ", propertyPath.join("."), ")");
-		return undefined;
-	}
-	return actualPath as NodePath;
-}
-
-function walkToNodeWithLogging(value: any, propertyPath: RawPath) {
-	for (let i = 1; i < propertyPath.length; i++) {
-		if (value === null || value === undefined) {
-			console.warn(
-				`Encountered a ${value === null ? 'null' : 'undefined'} value while attempting to resolve a child value.`,
-				`The property value will be treated as ${value === null ? 'null' : 'undefined'}`, `Property: ${propertyPath.join(".")}`, `Remainder: ${propertyPath.slice(i).join(".")}`
-			);
-			return value;
-		} else if (typeof value !== 'object') {
-			console.error(
-				"Encountered a scalar value while attempting to resolve a child value.",
-				"The scalar value will be used as the property value", `Property: ${propertyPath.join(".")}`, `Remainder: ${propertyPath.slice(i).join(".")}`
-			);
-			return value;
-		} else {
-			const name = propertyPath[i];
-			if (Array.isArray(value)) {
-				if (typeof name !== 'number') {
-					console.error(
-						"Encountered an array while attempting to resolve a named value.",
-						"The array will be used as the property value", `Property: ${propertyPath.join(".")}`, `Remainder: ${propertyPath.slice(i).join(".")}`
-					);
-					return value;
-				}
-			} else {
-				if (typeof name !== 'string') {
-					console.error(
-						"Encountered an object while attempting to resolve an index value.",
-						"The object will be used as the property value", `Property: ${propertyPath.join(".")}`, `Remainder: ${propertyPath.slice(i).join(".")}`
-					);
-					return value;
-				}
-			}
-			value = value[name];
-		}
-	}
-	return value;
-}

package/src/blocks/csnp-api.ts

@@ -1,221 +0,0 @@
-import type {BaseEntityRecords} from "@wordpress/core-data";
-import type {
-	ColorPalette,
-	DatePicker,
-	DateTimePicker,
-	RadioControl,
-	RangeControl,
-	TextareaControl,
-	TextControl,
-	ToggleControl,
-	__experimentalToggleGroupControl as ToggleGroupControl,
-	__experimentalToolsPanel as ToolsPanel
-} from "@wordpress/components";
-
-import {
-	ExtendedPostPickerProps, ExtendedTaxonomyPickerProps, ExtendedTaxonomyPickerPropsMultiple, ExtendedTaxonomyPickerPropsSingle,
-	ExtendedTermPickerProps, ExtendedTermPickerPropsMultiple, ExtendedTermPickerPropsSingle, ExtendedUserPickerProps, FileControl, FileControlProps,
-	FlexibleItem, ImageControl, PickableOptions, ProperLinkControlProps, SortableItemsControlProps, TextareaControlPropsExtension
-} from "../controls";
-import type {IconName} from "./shared-exportable-types";
-import type {NormalSwitch, SmallSwitch} from "./shared-internal-types";
-import type {GenericSimpleNativeProperty, PDSimpleNativeProperty, SimpleNativeProperty, SimpleNativePropertyType} from "./simple-native-property-api";
-
-import type {ComponentPropsWithoutRef, CSSProperties, HTMLAttributes, ReactElement, ReactNode} from "react";
-
-export type CommonPropertyConfig<N extends typeof CSNPControlNames[number], T, C, V extends SimpleNativePropertyType> = Omit<GenericSimpleNativeProperty<T, V>, 'control'|'enum'|'type'|'label'>&{
-	control: N
-	label: string,
-	help?: ReactNode,
-	component?: Partial<C>,
-	styleProperty?: string
-}
-export type CommonPropertyConfigWithEnum<N extends typeof CSNPControlNames[number], T, C, V extends SimpleNativePropertyType> = CommonPropertyConfig<N, T, C, V>&{enum?: T[]};
-export type ShareableSNPElements<T extends SimpleNativeProperty['type']> = Pick<SimpleNativeProperty, 'name'|'condition'|'alwaysStore'|'label'|'required'>&{type: T};
-
-export type CommonSimpleNativeProperty<N extends typeof CSNPControlNames[number], T, C, V extends SimpleNativePropertyType, A = {}> = CommonPropertyConfig<N, T, C, V> & A;
-export type CommonSimpleNativePropertyWithEnum<N extends typeof CSNPControlNames[number], T, C, V extends SimpleNativePropertyType, A = {}> = CommonPropertyConfigWithEnum<N, T, C, V> & A;
-
-type UnsuspendablePromisablePickableOptions<V extends string|number, T extends object = {}> = PickableOptions<V, T>|Promise<PickableOptions<V, T>>;
-export type SuspendablePromisablePickableOptions = `${string}://${string}`|`select:${string}:${string}${`:${string}`|''}`|`setting:${string}${`:${string}`|''}`|URL;
-export type PromisablePickableOptions<V extends string|number, T extends object = {}> = SuspendablePromisablePickableOptions|UnsuspendablePromisablePickableOptions<V, T>;
-
-type BaseConstantPropertyCSNPConfig = Omit<CommonSimpleNativeProperty<'constant', string|number|boolean|any[]|Record<string|number, unknown>|undefined,
-	ComponentPropsWithoutRef<typeof TextControl>, SimpleNativePropertyType, { type: SimpleNativePropertyType }>, 'alwaysStore'>;
-
-export type ColorPaletteCSNPConfig = CommonSimpleNativePropertyWithEnum<'colorPalette', string, ComponentPropsWithoutRef<typeof ColorPalette>, 'string', {
-	allowCustom?: boolean|undefined,
-	clearable?: boolean|undefined,
-	options: PromisablePickableOptions<string, {color?: CSSProperties['color']}>
-}>;
-export type ConstantPropertyCSNPConfig = Omit<BaseConstantPropertyCSNPConfig, 'default'>&Required<Pick<BaseConstantPropertyCSNPConfig, 'default'>>;
-export type DatePropertyCSNPConfig = CommonSimpleNativePropertyWithEnum<'date', number, ComponentPropsWithoutRef<typeof DateTimePicker>, 'number', {time: true}>
-	|CommonSimpleNativePropertyWithEnum<'date', number, ComponentPropsWithoutRef<typeof DatePicker>, 'number', {time?: false|undefined}>;
-
-export type FilePropertyCSNPConfig = CommonSimpleNativeProperty<'file', number, Omit<ComponentPropsWithoutRef<typeof FileControl>, 'allowedTypes'>, 'number', Pick<FileControlProps, 'allowedTypes'>>;
-
-type NormalGroupPropertyCSNPConfig = CommonPropertyConfig<'group', Record<string, unknown>, HTMLAttributes<HTMLFieldSetElement>, 'object'>&{
-	fields?: PDSimpleNativeProperty[],
-	interface?: 'default'
-};
-type ToolsPanelPropertyCSNPConfig = CommonPropertyConfig<'group', Record<string, unknown>, ComponentPropsWithoutRef<typeof ToolsPanel>, 'object'>&{
-	fields?: PDSimpleNativeProperty[],
-	interface: 'toolsPanel'
-};
-export type GroupPropertyCSNPConfig = NormalGroupPropertyCSNPConfig|ToolsPanelPropertyCSNPConfig;
-
-export type ImagePropertyCSNPConfig = Omit<CommonPropertyConfig<'image', ImageData, {}, 'object'>, 'default'> & Partial<Pick<CommonPropertyConfig<'image', ImageData, {}, 'object'>, 'default'>> & {
-	includeFocalPointPicker?: boolean,
-	storage?: ComponentPropsWithoutRef<typeof ImageControl>['storage']
-};
-
-export type LinkPropertyCSNPConfig = CommonSimpleNativeProperty<'link', Record<string, unknown>, Omit<ProperLinkControlProps, 'settings'>, 'object',
-	{settings?: ProperLinkControlProps['settings']|boolean}>;
-
-type ListPropertyConfigBase<T extends string|number|object, V extends 'string'|'number'|'object'> = CommonPropertyConfig<'list', T[], SortableItemsControlProps<T>, V>&{
-	emptyValue?: T,
-	min?: number,
-	max?: number,
-	listComponent?: ComponentPropsWithoutRef<typeof TextControl>
-};
-export type NumberListPropertyConfig = (ListPropertyConfigBase<number, 'number'>&{itemType: 'integer'|'int'})|(ListPropertyConfigBase<number, 'number'>&{itemType: 'float'});
-export type StringListPropertyConfig = ListPropertyConfigBase<string, 'string'>&{itemType?: 'string'};
-export type ObjectListPropertyConfig = ListPropertyConfigBase<object, 'object'>&{itemType: PDSimpleNativeProperty[]};
-export interface FlexibleItemsListPropertyConfig<T extends string = string> extends Omit<ListPropertyConfigBase<FlexibleItem<T>, 'object'>, 'emptyValue'> {
-	sharedProperties?: PDSimpleNativeProperty[],
-	itemType: Exclude<{[key in T]: {label: string, emptyValue?: object, properties: PDSimpleNativeProperty[]}}, any[]>
-}
-export type ListPropertyCSNPConfig = StringListPropertyConfig|NumberListPropertyConfig|ObjectListPropertyConfig|FlexibleItemsListPropertyConfig;
-
-export type MessagePropertyCSNPConfig = CommonSimpleNativeProperty<'message', string, {}, 'string'>;
-
-export type NumberPropertyCSNPConfig = CommonSimpleNativeProperty<'number', number, Omit<ComponentPropsWithoutRef<typeof TextControl>, 'type'>, 'number', {
-	placeholder?: string|undefined, float?: boolean, min?: number, max?: number, step?: number|'any'
-}>;
-export type RadioPropertyCSNPConfig = CommonSimpleNativePropertyWithEnum<'radio', string, ComponentPropsWithoutRef<typeof RadioControl>, 'string', {
-	allowCustom?: boolean,
-	options: PromisablePickableOptions<string>
-}>;
-export type RangePropertyCSNPConfig = CommonSimpleNativePropertyWithEnum<'range', number, ComponentPropsWithoutRef<typeof RangeControl>, 'number', {
-	min: number,
-	max: number,
-	step?: number
-}>;
-type SelectPropertyCSNPConfigSingle = CommonSimpleNativePropertyWithEnum<'select', string, never, 'string', {
-	options: PromisablePickableOptions<string>,
-	multiple?: false|undefined,
-	clearable?: boolean|undefined
-}>;
-type SelectPropertyCSNPConfigMultiple = CommonSimpleNativeProperty<'select', string[], never, 'array', {
-	options: PromisablePickableOptions<string>,
-	multiple: true,
-	expandOnFocus?: boolean,
-	maxLength?: number
-}>;
-export type SelectPropertyCSNPConfig = SelectPropertyCSNPConfigSingle|SelectPropertyCSNPConfigMultiple;
-export type TextareaPropertyCSNPConfig = CommonSimpleNativeProperty<'textarea', string, ComponentPropsWithoutRef<typeof TextareaControl>, 'string', TextareaControlPropsExtension>;
-export type TextPropertyCSNPConfig = CommonSimpleNativeProperty<'text', string, ComponentPropsWithoutRef<typeof TextControl>, 'string', {placeholder?: string|undefined}>;
-
-type PostPropertyTypeSingle = CommonPropertyConfig<'post', number, ExtendedPostPickerProps, 'number'>&{postTypes?: string[], multiple?: false};
-type PostPropertyTypeMultiple = CommonPropertyConfig<'post', number[], ExtendedPostPickerProps, 'array'>&{postTypes?: string[], multiple: true};
-export type PostPropertyCSNPConfig = PostPropertyTypeSingle|PostPropertyTypeMultiple;
-
-type TaxonomyPropertyTypeSingle = CommonPropertyConfig<'taxonomy', string, ExtendedTaxonomyPickerProps, 'string'>&Omit<ExtendedTaxonomyPickerPropsSingle, 'onChange'>;
-type TaxonomyPropertyTypeMultiple = CommonPropertyConfig<'taxonomy', string[], ExtendedTaxonomyPickerProps, 'array'>&Omit<ExtendedTaxonomyPickerPropsMultiple, 'onChange'>;
-export type TaxonomyPropertyCSNPConfig = (TaxonomyPropertyTypeSingle|TaxonomyPropertyTypeMultiple)&{visibility?: Partial<BaseEntityRecords.TaxonomyVisibility>};
-
-type TermPropertyTypeSingle = CommonPropertyConfig<'term', string, ExtendedTermPickerProps, 'string'>&Omit<ExtendedTermPickerPropsSingle, 'onChange'>;
-type TermPropertyTypeMultiple = CommonPropertyConfig<'term', string[], ExtendedTermPickerProps, 'array'>&Omit<ExtendedTermPickerPropsMultiple, 'onChange'>;
-export type TermPropertyCSNPConfig = (TermPropertyTypeSingle|TermPropertyTypeMultiple);
-
-type ToggleGroupPropertyConfigBase<T extends string|number, V extends 'string'|'number'>
-	= CommonPropertyConfig<'toggleGroup', T, ComponentPropsWithoutRef<typeof ToggleGroupControl>, V>&{options: PromisablePickableOptions<T, {icon?: ReactElement|IconName}>, clearable?: boolean, type?: V};
-type StringValuedToggleGroupConfig = ToggleGroupPropertyConfigBase<string, 'string'>;
-type NumberValuedToggleGroupConfig = ToggleGroupPropertyConfigBase<number, 'number'>;
-export type ToggleGroupPropertyCSNPConfig = StringValuedToggleGroupConfig|NumberValuedToggleGroupConfig;
-
-export type TogglePropertyCSNPConfig = (CommonPropertyConfig<'toggle', boolean, ComponentPropsWithoutRef<typeof ToggleControl>, 'boolean'>&{switch: SmallSwitch})
-	|(CommonPropertyConfig<'toggle', boolean, ComponentPropsWithoutRef<typeof ToggleGroupControl>, 'boolean'>&{switch?: NormalSwitch});
-
-type UserPropertyTypeSingle = CommonPropertyConfig<'user', number, ExtendedUserPickerProps, 'number'>&{userRoles?: string[], multiple?: false};
-type UserPropertyTypeMultiple = CommonPropertyConfig<'user', number[], ExtendedUserPickerProps, 'array'>&{userRoles?: string[], multiple: true};
-export type UserPropertyCSNPConfig = UserPropertyTypeSingle|UserPropertyTypeMultiple;
-
-export type CSNPConfig = ColorPaletteCSNPConfig|ConstantPropertyCSNPConfig|DatePropertyCSNPConfig|FilePropertyCSNPConfig|GroupPropertyCSNPConfig
-	|ImagePropertyCSNPConfig|LinkPropertyCSNPConfig|ListPropertyCSNPConfig|MessagePropertyCSNPConfig|NumberPropertyCSNPConfig|PostPropertyCSNPConfig|RadioPropertyCSNPConfig
-	|RangePropertyCSNPConfig|SelectPropertyCSNPConfig|TaxonomyPropertyCSNPConfig|TermPropertyCSNPConfig|TextareaPropertyCSNPConfig|TextPropertyCSNPConfig
-	|ToggleGroupPropertyCSNPConfig|TogglePropertyCSNPConfig|UserPropertyCSNPConfig;
-
-export const CSNPControlNames = [
-	'colorPalette', 'constant', 'date', 'file', 'group', 'image', 'link', 'list', 'message', 'number', 'post', 'radio', 'range', 'select', 'taxonomy', 'term',
-	'text', 'textarea', 'toggle', 'toggleGroup', 'user'
-] as const;
-
-export function getPropType(config: PDSimpleNativeProperty): SimpleNativePropertyType {
-	if (isCSNPConfig(config)) {
-		switch (config.control) {
-			case "colorPalette":
-				return 'string';
-			case "constant":
-				return config.type;
-			case "date":
-			case "file":
-				return 'number';
-			case "group":
-			case "image":
-			case "link":
-				return 'object';
-			case "list":
-				return 'array';
-			case "message":
-				return 'string';
-			case "number":
-				return 'number';
-			case "post":
-				return config.multiple ? 'array' : 'number';
-			case "radio":
-				return 'string';
-			case "range":
-				return 'number';
-			case "select":
-			case "taxonomy":
-			case "term":
-				return config.multiple ? 'array' : 'string';
-			case "textarea":
-			case "text":
-				return 'string';
-			case "toggle":
-				return 'boolean';
-			case "toggleGroup":
-				return isStringValuedToggleGroupCSNPConfig(config) ? 'string' : 'number';
-			case "user":
-				return config.multiple ? 'array' : 'number';
-		}
-	} else {
-		return config.type;
-	}
-}
-
-export function isCSNPConfig(config: PDSimpleNativeProperty): config is CSNPConfig {
-	return isNamedCSNPControl(config.control);
-}
-
-export function isNamedCSNPControl(control: PDSimpleNativeProperty['control']): control is typeof CSNPControlNames[number] {
-	return typeof control === 'string' && CSNPControlNames.includes(control as any);
-}
-
-export function isStringValuedToggleGroupCSNPConfig(config: ToggleGroupPropertyCSNPConfig): config is StringValuedToggleGroupConfig {
-	if (config.type) {
-		return config.type === 'string';
-	}
-	if (config.default === undefined) {
-		console.warn(`Encountered a toggleGroup SNP named "${config.name}" without a declared type or default.`,
-			"It will be treated as if its values are strings.", config);
-		return true;
-	}
-	return typeof config.default !== 'number';
-}
-
-export function isObjectListPropertyConfig(config: ListPropertyCSNPConfig): config is ObjectListPropertyConfig {
-	return Array.isArray(config.itemType);
-}

package/src/blocks/data-controller/actions.ts

@@ -1,20 +0,0 @@
-import type {HydratedLaidOutProperties} from "../simple-native-property-internal-shared";
-import type {DataStore} from "../simple-native-property-api";
-import {createGlobalAction, createPathedAction} from "./trigger-handlers";
-
-export const actions = {
-	addProperties: createGlobalAction<{properties: HydratedLaidOutProperties, dataStore: DataStore}>('addProperties', {conditionChecks: true, changedByManagedControl: true}),
-	checkConditions: createGlobalAction('checkConditions', {conditionChecks: true}), // This action is handled implicitly
-	commitBatchAddedProperties: createGlobalAction('commitBatchAddedProperties'),
-	markManagedControlChangeHandled: createGlobalAction('markManagedControlChangeHandled'),
-	validateNodes: createGlobalAction('validateNodes'),
-	node: {
-		add: createPathedAction<{value?: any, subtype?: string}>('node/add', {conditionChecks: true, changedByManagedControl: true}),
-		remove: createPathedAction('node/remove', {conditionChecks: true, changedByManagedControl: true}),
-		move: createPathedAction<{from: number, to: number}|{from: string, to: string}>('node/move', {conditionChecks: true}),
-		validate: createPathedAction('node/validate', {validation: true}), // This action is handled implicitly
-		write: createPathedAction<{value?: any}>('node/write', {conditionChecks: true, validation: true, changedByManagedControl: true}),
-	}
-} as const;
-
-export type DataControllerActions = ReturnType<typeof actions[Exclude<keyof typeof actions, 'node'>]|typeof actions['node'][keyof typeof actions['node']]>;

package/src/blocks/data-controller/reducer.ts

@@ -1,146 +0,0 @@
-import {createReducer} from "@reduxjs/toolkit";
-import {produce} from "immer";
-
-import {actions} from "./actions";
-import {DCStoreState, walkToNodeInValue} from "../data-controller";
-import {PathError} from "../PathError";
-import type {HydratedSimpleNativeProperty} from "../simple-native-property-api";
-import {triggerHandlers, validateFoundNode} from "./trigger-handlers";
-import {
-	applyToTree, buildDefaultValueFromDefinition,
-	buildNodeFromDataAndDefinition, getDataStore,
-	moveNodeWithinParent,
-	populateValueBasedOnDefinition, recordCloneableDefaultValueForNode, removeBackupForNode,
-	removeFromParentNode, removeValueFromBackingDataStore,
-	resolveParentNodeDefinition, TreeMutatorResult,
-	walkToNode, writeValueToBackingDataStoreWithCorrections
-} from "./utils";
-
-export function buildReducer(blockClientId: string) {
-	const initialState: DCStoreState = {
-		treeRoot: {children: {}, rendered: true}, dataStores: {byProperty: {}, list: []}, blockClientId, changedByManagedControl: false, rerenderTrigger: 0,
-		batchAddedPropertiesThatNeedWriteThrough: []
-	};
-
-	return createReducer(initialState, builder => {
-		builder
-			.addCase(actions.addProperties, (state, {payload: {properties, dataStore}, meta}) => {
-				if (!state.dataStores.list.includes(dataStore)) {
-					state.dataStores.list.push(dataStore);
-				}
-				for (const property of properties) {
-					for (const prop of Array.isArray(property) ? property : [property]) {
-						dataStore.addProperty(prop);
-						state.dataStores.byProperty[prop.name] = dataStore;
-						state.treeRoot.children[prop.name] = buildNodeFromDataAndDefinition(dataStore.getValue(prop.name), prop);
-					}
-				}
-				return state;
-			})
-			.addCase(actions.validateNodes, state => {
-				let hasChanged = false;
-				applyToTree(state.treeRoot, (node, path) => {
-					if (!node.rendered) {
-						return TreeMutatorResult.SKIP_DESCENDANTS;
-					}
-
-					if (validateFoundNode(node, path, state)) {
-						hasChanged = true;
-					}
-					return TreeMutatorResult.CONTINUE;
-				});
-				if (hasChanged) {
-					state.rerenderTrigger++;
-				}
-			})
-			.addCase(actions.markManagedControlChangeHandled, state => {
-				state.changedByManagedControl = false;
-			})
-			.addCase(actions.commitBatchAddedProperties, state => {
-				const batch = [...state.batchAddedPropertiesThatNeedWriteThrough];
-				state.batchAddedPropertiesThatNeedWriteThrough = [];
-				for (const batchAddedProperty of batch) {
-					if (state.treeRoot.children[batchAddedProperty.name]?.rendered) {
-						writeValueToBackingDataStoreWithCorrections([batchAddedProperty.name], state, buildDefaultValueFromDefinition(batchAddedProperty));
-					}
-				}
-			})
-			.addCase(actions.node.add, (state, {payload: {path, value, subtype}}) => {
-				const parentDefinition = resolveParentNodeDefinition(state.treeRoot, path);
-				if (!parentDefinition) {
-					throw new Error("Cannot add children to a node without a definition");
-				}
-				const nodeNameOrIndex = path[path.length - 1];
-				let parentDefinitionChildren: HydratedSimpleNativeProperty[] | undefined;
-				if (Array.isArray(parentDefinition.children) || parentDefinition.children === undefined) {
-					parentDefinitionChildren = parentDefinition.children;
-				} else {
-					const actualSubtype = value?.type ?? subtype;
-					if (!actualSubtype || !parentDefinition.children[actualSubtype]) {
-						throw new PathError("Unable to locate the definition of the named node because its type could not be resolved.", path);
-					}
-					parentDefinitionChildren = parentDefinition.children[actualSubtype];
-				}
-
-				if (typeof nodeNameOrIndex === 'string') {
-					const definition = parentDefinitionChildren?.find(definition => definition.name === nodeNameOrIndex);
-					if (definition === undefined) {
-						throw new PathError("Unable to locate the definition of the named node.", path);
-					}
-					const data = populateValueBasedOnDefinition(value, parentDefinition);
-					const builtNode = buildNodeFromDataAndDefinition(data, definition);
-					const parentNode = walkToNode(state.treeRoot, path.slice(0, path.length - 1));
-					if (parentNode.children === undefined) {
-						parentNode.children = {[nodeNameOrIndex]: builtNode};
-					} else {
-						if (Array.isArray(parentNode.children)) {
-							throw new PathError("Encountered a node with indexed descendants while expecting one with string-keyed descendants.", path);
-						}
-						parentNode.children[nodeNameOrIndex] = builtNode;
-					}
-					writeValueToBackingDataStoreWithCorrections(path, state, data);
-				} else if (nodeNameOrIndex === undefined) {
-					throw new PathError("Encountered an undefined name in a path.", path);
-				} else {
-					const data = populateValueBasedOnDefinition(value, parentDefinition);
-					const builtNode = buildNodeFromDataAndDefinition(data, parentDefinition);
-					const parentNode = walkToNode(state.treeRoot, path.slice(0, path.length - 1));
-					if (parentNode.children === undefined) {
-						parentNode.children = [];
-						parentNode.children[nodeNameOrIndex] = builtNode;
-					} else {
-						if (!Array.isArray(parentNode.children)) {
-							throw new PathError("Encountered a node with string-keyed descendants while expecting one with indexed descendants.", path);
-						}
-						parentNode.children[nodeNameOrIndex] = builtNode;
-					}
-					writeValueToBackingDataStoreWithCorrections(path, state, data);
-				}
-			})
-			.addCase(actions.node.remove, (state, {payload: {path}}) => {
-				const parentNode = walkToNode(state.treeRoot, path.slice(0, path.length - 1));
-				removeFromParentNode(parentNode.children, path);
-				removeValueFromBackingDataStore(getDataStore(path[0], state, true), path);
-				removeBackupForNode(walkToNode(state.treeRoot, path));
-			})
-			.addCase(actions.node.move, (state, {payload: {path, ...action}}) => {
-				// If from and to are the same, then this is a no-op, so we can just skip it
-				if (action.from === action.to) {
-					return;
-				}
-				state.changedByManagedControl = true;
-				moveNodeWithinParent(walkToNode(state.treeRoot, path).children, path, action);
-				const dataStore = getDataStore(path[0], state, true);
-				dataStore.setValue(path[0], produce(dataStore.getValue(path[0]), (dsDraft: any) => {
-					moveNodeWithinParent(walkToNodeInValue(dsDraft, path), path, action);
-				}));
-			})
-			.addCase(actions.node.write, (state, {payload: {path, value}}) => {
-				writeValueToBackingDataStoreWithCorrections(path, state, value);
-			})
-		;
-		for (const {attachTo} of Object.values(triggerHandlers)) {
-			attachTo(builder);
-		}
-	});
-}