@workbench-kit/react 0.0.2-prototype.0.1.2 → 0.0.2-prototype.0.2.2

package/src/workbench/settings/structuredDataSchema.ts

@@ -1,15 +1,121 @@
-import type { ComponentPropsWithRef, FormEvent, ReactNode } from 'react';
 import {
   asWorkbenchStructuredDataRecord,
   getWorkbenchStructuredDataValue,
   isWorkbenchStructuredDataRecord,
   setWorkbenchStructuredDataPathOrRootValue,
   setWorkbenchStructuredDataValue,
-  type WorkbenchStructuredDataPath,
-  type WorkbenchStructuredDataRecord,
 } from '@workbench-kit/workspace';
+import type {
+  WorkbenchStructuredDataRecord,
+  WorkbenchStructuredDataSchemaDocument,
+  WorkbenchStructuredDataSchemaFieldDefinition,
+  WorkbenchStructuredDataSchemaSectionAliases,
+  WorkbenchStructuredDataSchemaSectionSummary,
+} from './structuredDataSchemaTypes';
+import {
+  formatWorkbenchStructuredDataSchemaLabel,
+  getWorkbenchStructuredDataSchemaFieldDefaultValue,
+} from './structuredDataSchemaField';
+import {
+  getWorkbenchStructuredDataSchemaFieldDataPath,
+  getWorkbenchStructuredDataSchemaFieldDefinition,
+  getWorkbenchStructuredDataSchemaSectionFieldLabel,
+  getWorkbenchStructuredDataSchemaSectionPath,
+} from './structuredDataSchemaSection';
+import {
+  createWorkbenchStructuredDataSchemaEmptyRow,
+  getWorkbenchStructuredDataSchemaTableColumns,
+} from './structuredDataSchemaTable';
+export {
+  coerceWorkbenchStructuredDataFormFieldValue,
+  getWorkbenchStructuredDataFormErrors,
+  getWorkbenchStructuredDataFormFieldDefaultValue,
+  getWorkbenchStructuredDataFormFieldError,
+  getWorkbenchStructuredDataFormFields,
+  isWorkbenchStructuredDataFormSubmittable,
+  normalizeWorkbenchStructuredDataFormData,
+} from './structuredDataFormModel';
 
-export type { WorkbenchStructuredDataPath, WorkbenchStructuredDataRecord };
+export {
+  booleanWorkbenchStructuredDataSchemaFieldValue,
+  coerceWorkbenchStructuredDataSchemaFieldValue,
+  formatWorkbenchStructuredDataSchemaLabel,
+  formatWorkbenchStructuredDataSchemaValue,
+  getWorkbenchStructuredDataSchemaFieldControl,
+  getWorkbenchStructuredDataSchemaFieldDefaultValue,
+  stringifyWorkbenchStructuredDataSchemaFieldValue,
+} from './structuredDataSchemaField';
+export {
+  coerceWorkbenchStructuredDataSchemaDateValue,
+  fromWorkbenchStructuredDataHtmlDateInputValue,
+  inferWorkbenchStructuredDataSchemaDateFormat,
+  isWorkbenchStructuredDataSchemaDateField,
+  normalizeWorkbenchStructuredDataSchemaDateFormat,
+  parseWorkbenchStructuredDataSchemaDateValue,
+  resolveWorkbenchStructuredDataSchemaDateFormat,
+  toWorkbenchStructuredDataHtmlDateInputValue,
+  WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT,
+} from './structuredDataSchemaDate';
+export {
+  buildWorkbenchStructuredDataSchemaSelectOptions,
+  hasWorkbenchStructuredDataSchemaSelectOptions,
+  isWorkbenchStructuredDataSchemaColorField,
+  shouldUseWorkbenchStructuredDataSchemaRadioControl,
+  validateWorkbenchStructuredDataSchemaFieldValue,
+} from './structuredDataSchemaValidation';
+export {
+  getWorkbenchStructuredDataSchemaFieldDataPath,
+  getWorkbenchStructuredDataSchemaFieldDefinition,
+  getWorkbenchStructuredDataSchemaSectionAnchorId,
+  getWorkbenchStructuredDataSchemaSectionId,
+  getWorkbenchStructuredDataSchemaSectionPath,
+  slugWorkbenchStructuredDataSchemaAnchor,
+} from './structuredDataSchemaSection';
+export {
+  appendWorkbenchStructuredDataSchemaTableRow,
+  createWorkbenchStructuredDataSchemaEmptyRow,
+  getWorkbenchStructuredDataSchemaTableCellPath,
+  getWorkbenchStructuredDataSchemaTableColumns,
+  getWorkbenchStructuredDataSchemaTablePath,
+  getWorkbenchStructuredDataSchemaTableRowKey,
+  getWorkbenchStructuredDataSchemaTableRows,
+  removeWorkbenchStructuredDataSchemaTableRow,
+} from './structuredDataSchemaTable';
+
+export type {
+  WorkbenchStructuredDataFieldType,
+  WorkbenchStructuredDataFieldValue,
+  WorkbenchStructuredDataFormCancelContext,
+  WorkbenchStructuredDataFormCheckboxField,
+  WorkbenchStructuredDataFormErrors,
+  WorkbenchStructuredDataFormField,
+  WorkbenchStructuredDataFormFieldBase,
+  WorkbenchStructuredDataFormFieldChangeContext,
+  WorkbenchStructuredDataFormNumberField,
+  WorkbenchStructuredDataFormOption,
+  WorkbenchStructuredDataFormProps,
+  WorkbenchStructuredDataFormSection,
+  WorkbenchStructuredDataFormSelectField,
+  WorkbenchStructuredDataFormSubmitContext,
+  WorkbenchStructuredDataFormTextArrayField,
+  WorkbenchStructuredDataFormTextField,
+  WorkbenchStructuredDataPath,
+  WorkbenchStructuredDataRecord,
+  WorkbenchStructuredDataSchemaDocument,
+  WorkbenchStructuredDataSchemaFieldControl,
+  WorkbenchStructuredDataSchemaFieldDefinition,
+  WorkbenchStructuredDataSchemaFieldInputProps,
+  WorkbenchStructuredDataSchemaSectionAliases,
+  WorkbenchStructuredDataSchemaSectionSummary,
+  WorkbenchStructuredDataSchemaTableColumnInput,
+  WorkbenchStructuredDataSchemaTableDefinition,
+  WorkbenchStructuredDataSchemaTableRowKeyInput,
+  WorkbenchStructuredDataTable,
+  WorkbenchStructuredDataTableCellContext,
+  WorkbenchStructuredDataTableColumn,
+  WorkbenchStructuredDataTableRow,
+  WorkbenchStructuredDataTextArrayInputProps,
+} from './structuredDataSchemaTypes';
 export {
   asWorkbenchStructuredDataRecord,
   getWorkbenchStructuredDataValue,
@@ -18,435 +124,6 @@ export {
   setWorkbenchStructuredDataValue,
 };
 
-export type WorkbenchStructuredDataFieldType =
-  | 'checkbox'
-  | 'number'
-  | 'select'
-  | 'text'
-  | 'text-array';
-
-export type WorkbenchStructuredDataFieldValue = boolean | number | string | readonly string[];
-
-export type WorkbenchStructuredDataFormErrors = Record<string, ReactNode>;
-
-export type WorkbenchStructuredDataSchemaFieldControl =
-  | 'checkbox'
-  | 'date'
-  | 'number'
-  | 'select'
-  | 'text'
-  | 'textarea';
-
-export interface WorkbenchStructuredDataSchemaFieldDefinition {
-  default?: unknown;
-  description?: string | undefined;
-  enum?: readonly (boolean | number | string)[] | undefined;
-  format?: string | undefined;
-  items?: {
-    type?: string | undefined;
-  };
-  markdownDescription?: string | undefined;
-  title?: string | undefined;
-  type?: string | undefined;
-  ui?: {
-    control?: WorkbenchStructuredDataSchemaFieldControl | string | undefined;
-    placeholder?: string | undefined;
-    rows?: number | undefined;
-  };
-}
-
-export interface WorkbenchStructuredDataSchemaSectionSummary {
-  columns?: readonly string[] | undefined;
-  dataPath?: string | undefined;
-  fieldCount?: number | undefined;
-  fields?: readonly string[] | undefined;
-  id?: string | undefined;
-  sectionKey?: string | undefined;
-  title?: string | undefined;
-  type?: string | undefined;
-}
-
-export interface WorkbenchStructuredDataSchemaTableDefinition {
-  items?: Record<string, WorkbenchStructuredDataSchemaFieldDefinition> | undefined;
-  title?: string | undefined;
-}
-
-export interface WorkbenchStructuredDataSchemaDocument {
-  activePattern?: string | undefined;
-  pattern?: string | undefined;
-  patterns?: readonly {
-    pattern: string;
-    sections?: readonly WorkbenchStructuredDataSchemaSectionSummary[] | undefined;
-  }[];
-  sampleDraft?: unknown;
-  sampleDrafts?: Record<string, unknown> | undefined;
-  schema?: {
-    properties?: Record<string, WorkbenchStructuredDataSchemaFieldDefinition> | undefined;
-    sections?: readonly WorkbenchStructuredDataSchemaSectionSummary[] | undefined;
-    tables?: Record<string, WorkbenchStructuredDataSchemaTableDefinition> | undefined;
-  };
-  ui?: {
-    patterns?: Record<
-      string,
-      {
-        label?: string | undefined;
-        sections?: readonly WorkbenchStructuredDataSchemaSectionSummary[] | undefined;
-      }
-    >;
-  };
-}
-
-export type WorkbenchStructuredDataSchemaSectionAliases = Record<
-  string,
-  readonly WorkbenchStructuredDataPath[]
->;
-
-export interface WorkbenchStructuredDataSchemaTableColumnInput {
-  maxColumns?: number | undefined;
-  preferredColumns?: readonly string[] | undefined;
-  rows: readonly WorkbenchStructuredDataRecord[];
-  schemaColumns?: readonly string[] | undefined;
-  sectionColumns?: readonly string[] | undefined;
-}
-
-export interface WorkbenchStructuredDataSchemaTableRowKeyInput {
-  row: WorkbenchStructuredDataRecord;
-  rowIndex: number;
-  value: unknown;
-}
-
-export interface WorkbenchStructuredDataFormOption {
-  disabled?: boolean;
-  label: ReactNode;
-  value: string;
-}
-
-export interface WorkbenchStructuredDataFormFieldBase {
-  defaultValue?: WorkbenchStructuredDataFieldValue;
-  description?: ReactNode;
-  disabled?: boolean;
-  id: string;
-  label: ReactNode;
-  metadata?: Record<string, unknown>;
-  path: WorkbenchStructuredDataPath;
-  readOnly?: boolean;
-  required?: boolean;
-  validationMessage?: ReactNode;
-  validate?: (
-    value: WorkbenchStructuredDataFieldValue,
-    data: WorkbenchStructuredDataRecord,
-    field: WorkbenchStructuredDataFormField,
-  ) => ReactNode | undefined;
-}
-
-export interface WorkbenchStructuredDataFormTextField extends WorkbenchStructuredDataFormFieldBase {
-  autocomplete?: string;
-  monospace?: boolean;
-  placeholder?: string;
-  type: 'text';
-}
-
-export interface WorkbenchStructuredDataFormNumberField extends WorkbenchStructuredDataFormFieldBase {
-  max?: number;
-  min?: number;
-  placeholder?: string;
-  step?: number;
-  type: 'number';
-}
-
-export interface WorkbenchStructuredDataFormSelectField extends WorkbenchStructuredDataFormFieldBase {
-  emptyOptionLabel?: ReactNode;
-  options: readonly WorkbenchStructuredDataFormOption[];
-  type: 'select';
-}
-
-export interface WorkbenchStructuredDataFormCheckboxField extends WorkbenchStructuredDataFormFieldBase {
-  type: 'checkbox';
-}
-
-export interface WorkbenchStructuredDataFormTextArrayField extends WorkbenchStructuredDataFormFieldBase {
-  addLabel?: ReactNode;
-  emptyLabel?: ReactNode;
-  itemLabel?: string;
-  itemPlaceholder?: string;
-  maxItems?: number;
-  minItems?: number;
-  removeLabel?: string;
-  type: 'text-array';
-}
-
-export interface WorkbenchStructuredDataTextArrayInputProps extends Omit<
-  ComponentPropsWithRef<'div'>,
-  'children' | 'onChange'
-> {
-  addLabel?: ReactNode | undefined;
-  ariaDescribedBy?: string | undefined;
-  ariaLabel: string;
-  disabled?: boolean | undefined;
-  emptyLabel?: ReactNode | undefined;
-  maxItems?: number | undefined;
-  minItems?: number | undefined;
-  placeholder?: string | undefined;
-  readOnly?: boolean | undefined;
-  removeLabel?: string | undefined;
-  value?: unknown;
-  onValueChange?: ((value: string[]) => void) | undefined;
-}
-
-export interface WorkbenchStructuredDataSchemaFieldInputProps {
-  addTextArrayLabel?: ReactNode | undefined;
-  checkboxClassName?: string | undefined;
-  className?: string | undefined;
-  definition?: WorkbenchStructuredDataSchemaFieldDefinition | undefined;
-  fieldPath: string;
-  readOnly?: boolean | undefined;
-  removeTextArrayLabel?: string | undefined;
-  textareaClassName?: string | undefined;
-  textArrayClassName?: string | undefined;
-  value: unknown;
-  onValueChange?: ((value: unknown) => void) | undefined;
-}
-
-export type WorkbenchStructuredDataFormField =
-  | WorkbenchStructuredDataFormCheckboxField
-  | WorkbenchStructuredDataFormNumberField
-  | WorkbenchStructuredDataFormSelectField
-  | WorkbenchStructuredDataFormTextArrayField
-  | WorkbenchStructuredDataFormTextField;
-
-export interface WorkbenchStructuredDataTableColumn {
-  align?: 'end' | 'start';
-  id: string;
-  label: ReactNode;
-  path?: WorkbenchStructuredDataPath;
-  render?: (context: WorkbenchStructuredDataTableCellContext) => ReactNode;
-}
-
-export interface WorkbenchStructuredDataTableRow {
-  data: WorkbenchStructuredDataRecord;
-  id: string;
-  label?: ReactNode;
-  metadata?: Record<string, unknown>;
-}
-
-export interface WorkbenchStructuredDataTableCellContext {
-  column: WorkbenchStructuredDataTableColumn;
-  row: WorkbenchStructuredDataTableRow;
-  value: unknown;
-}
-
-export interface WorkbenchStructuredDataTable {
-  columns: readonly WorkbenchStructuredDataTableColumn[];
-  description?: ReactNode;
-  emptyLabel?: ReactNode;
-  id: string;
-  label?: ReactNode;
-  rows: readonly WorkbenchStructuredDataTableRow[];
-}
-
-export interface WorkbenchStructuredDataFormSection {
-  count?: number;
-  description?: ReactNode;
-  fields?: readonly WorkbenchStructuredDataFormField[];
-  id: string;
-  tables?: readonly WorkbenchStructuredDataTable[];
-  title: ReactNode;
-}
-
-export interface WorkbenchStructuredDataFormFieldChangeContext {
-  data: WorkbenchStructuredDataRecord;
-  field: WorkbenchStructuredDataFormField;
-  fieldId: string;
-  path: WorkbenchStructuredDataPath;
-  value: WorkbenchStructuredDataFieldValue;
-}
-
-export interface WorkbenchStructuredDataFormSubmitContext {
-  data: WorkbenchStructuredDataRecord;
-  event: FormEvent<HTMLFormElement>;
-}
-
-export interface WorkbenchStructuredDataFormCancelContext {
-  data: WorkbenchStructuredDataRecord;
-}
-
-export interface WorkbenchStructuredDataFormProps extends Omit<
-  ComponentPropsWithRef<'form'>,
-  'children' | 'defaultValue' | 'onCancel' | 'onChange' | 'onSubmit'
-> {
-  ariaLabel: string;
-  cancelLabel?: ReactNode;
-  data?: WorkbenchStructuredDataRecord;
-  defaultData?: WorkbenchStructuredDataRecord;
-  disabled?: boolean;
-  emptyLabel?: ReactNode;
-  errors?: WorkbenchStructuredDataFormErrors;
-  onCancel?: (context: WorkbenchStructuredDataFormCancelContext) => void;
-  onDataChange?: (
-    data: WorkbenchStructuredDataRecord,
-    context: WorkbenchStructuredDataFormFieldChangeContext,
-  ) => void;
-  onFieldChange?: (context: WorkbenchStructuredDataFormFieldChangeContext) => void;
-  onSubmit?: (
-    data: WorkbenchStructuredDataRecord,
-    context: WorkbenchStructuredDataFormSubmitContext,
-  ) => void;
-  readOnly?: boolean;
-  sections: readonly WorkbenchStructuredDataFormSection[];
-  showActions?: boolean;
-  submitLabel?: ReactNode;
-}
-
-const EMPTY_RECORD: WorkbenchStructuredDataRecord = {};
-
-export function getWorkbenchStructuredDataFormFieldDefaultValue(
-  field: WorkbenchStructuredDataFormField,
-): WorkbenchStructuredDataFieldValue {
-  if (field.defaultValue !== undefined) {
-    return coerceWorkbenchStructuredDataFormFieldValue(field, field.defaultValue);
-  }
-
-  if (field.type === 'checkbox') return false;
-  if (field.type === 'text-array') return [];
-  return '';
-}
-
-export function coerceWorkbenchStructuredDataFormFieldValue(
-  field: WorkbenchStructuredDataFormField,
-  value: unknown,
-): WorkbenchStructuredDataFieldValue {
-  if (field.type === 'checkbox') return Boolean(value);
-  if (field.type === 'text-array') {
-    if (Array.isArray(value)) {
-      return value.map((item) => (item === null || item === undefined ? '' : String(item)));
-    }
-
-    if (value === '' || value === null || value === undefined) return [];
-    return [String(value)];
-  }
-
-  if (field.type === 'number') {
-    if (value === '' || value === null || value === undefined) return '';
-    const numericValue = Number(value);
-    return Number.isFinite(numericValue) ? numericValue : '';
-  }
-
-  return value === null || value === undefined ? '' : String(value);
-}
-
-export function getWorkbenchStructuredDataSchemaFieldControl(
-  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
-): WorkbenchStructuredDataSchemaFieldControl {
-  if (definition?.ui?.control) {
-    return definition.ui.control as WorkbenchStructuredDataSchemaFieldControl;
-  }
-  if (definition?.enum?.length) return 'select';
-  if (definition?.type === 'array') return 'textarea';
-  if (definition?.type === 'boolean') return 'checkbox';
-  if (definition?.type === 'number' || definition?.type === 'integer') return 'number';
-  if (definition?.format === 'date') return 'date';
-  return 'text';
-}
-
-export function getWorkbenchStructuredDataSchemaFieldDefaultValue(
-  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
-) {
-  if (definition?.default !== undefined) return definition.default;
-  if (definition?.type === 'array') return [];
-  if (definition?.type === 'boolean') return false;
-  if (definition?.type === 'number' || definition?.type === 'integer') return 0;
-  return '';
-}
-
-export function stringifyWorkbenchStructuredDataSchemaFieldValue(
-  value: unknown,
-  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
-) {
-  if (Array.isArray(value)) return value.join('\n');
-  if (value === null || value === undefined) return '';
-  if (definition?.type === 'object') return JSON.stringify(value, null, 2);
-  return String(value);
-}
-
-export function booleanWorkbenchStructuredDataSchemaFieldValue(value: unknown) {
-  return value === true || value === 'true' || value === 'Y';
-}
-
-export function coerceWorkbenchStructuredDataSchemaFieldValue(
-  rawValue: string,
-  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
-): unknown {
-  if (definition?.type === 'array') {
-    return rawValue.split('\n');
-  }
-
-  if (definition?.type === 'number' || definition?.type === 'integer') {
-    if (rawValue.trim() === '') return null;
-    const numericValue = Number(rawValue);
-    return Number.isFinite(numericValue) ? numericValue : rawValue;
-  }
-
-  if (definition?.enum?.length) {
-    return definition.enum.find((option) => String(option) === rawValue) ?? rawValue;
-  }
-
-  return rawValue;
-}
-
-export function formatWorkbenchStructuredDataSchemaValue(value: unknown) {
-  if (value === null || value === undefined || value === '') return '-';
-  if (Array.isArray(value)) return value.join('\n');
-  if (typeof value === 'boolean') return value ? 'Y' : 'N';
-  if (typeof value === 'object') return JSON.stringify(value, null, 2);
-  return String(value);
-}
-
-export function getWorkbenchStructuredDataSchemaSectionId(
-  section: WorkbenchStructuredDataSchemaSectionSummary,
-) {
-  return section.id ?? section.sectionKey;
-}
-
-export function getWorkbenchStructuredDataSchemaSectionPath(
-  section: WorkbenchStructuredDataSchemaSectionSummary,
-) {
-  const dataPath = section.dataPath;
-  if (dataPath !== undefined) {
-    return dataPath.trim();
-  }
-
-  return section.sectionKey || section.id || '';
-}
-
-export function formatWorkbenchStructuredDataSchemaLabel(value: string) {
-  return value.replace(/_/g, ' ');
-}
-
-export function getWorkbenchStructuredDataSchemaFieldDataPath(
-  section: WorkbenchStructuredDataSchemaSectionSummary,
-  fieldPath: string,
-) {
-  if (fieldPath.includes('.')) return fieldPath;
-  const sectionPath = getWorkbenchStructuredDataSchemaSectionPath(section);
-  return sectionPath ? `${sectionPath}.${fieldPath}` : fieldPath;
-}
-
-export function getWorkbenchStructuredDataSchemaFieldDefinition({
-  fieldPath,
-  properties,
-  section,
-}: {
-  fieldPath: string;
-  properties?: Record<string, WorkbenchStructuredDataSchemaFieldDefinition> | undefined;
-  section: WorkbenchStructuredDataSchemaSectionSummary;
-}) {
-  const sectionPath = getWorkbenchStructuredDataSchemaSectionPath(section);
-  return (
-    properties?.[fieldPath] ??
-    (sectionPath ? properties?.[`${sectionPath}.${fieldPath}`] : undefined)
-  );
-}
-
 export function getWorkbenchStructuredDataSchemaDocumentSections(
   schema: WorkbenchStructuredDataSchemaDocument | null | undefined,
   pattern: string,
@@ -493,7 +170,7 @@ export function getWorkbenchStructuredDataSchemaDocumentFieldLabel(
 ) {
   return (
     getWorkbenchStructuredDataSchemaDocumentFieldDefinition(schema, section, fieldPath)?.title ??
-    formatWorkbenchStructuredDataSchemaLabel(fieldPath.split('.').pop() ?? fieldPath)
+    getWorkbenchStructuredDataSchemaSectionFieldLabel(fieldPath)
   );
 }
 
@@ -545,103 +222,6 @@ export function getWorkbenchStructuredDataSchemaDocumentSectionValue({
   return null;
 }
 
-export function getWorkbenchStructuredDataSchemaTableRows(
-  value: unknown,
-): WorkbenchStructuredDataRecord[] {
-  if (Array.isArray(value)) {
-    return value.map((item) => asWorkbenchStructuredDataRecord(item) ?? { value: item });
-  }
-
-  const record = asWorkbenchStructuredDataRecord(value);
-  if (!record) return [];
-
-  const objectEntries = Object.entries(record).filter(([, entry]) =>
-    asWorkbenchStructuredDataRecord(entry),
-  );
-  if (!objectEntries.length) return [];
-
-  return objectEntries.map(([key, entry]) => ({
-    id: key,
-    ...(asWorkbenchStructuredDataRecord(entry) ?? {}),
-  }));
-}
-
-export function getWorkbenchStructuredDataSchemaTablePath(
-  section: WorkbenchStructuredDataSchemaSectionSummary,
-) {
-  const tablePath = getWorkbenchStructuredDataSchemaSectionPath(section);
-  return tablePath ? tablePath.split('.') : [];
-}
-
-export function getWorkbenchStructuredDataSchemaTableRowKey({
-  row,
-  rowIndex,
-  value,
-}: WorkbenchStructuredDataSchemaTableRowKeyInput) {
-  return Array.isArray(value) ? String(rowIndex) : String(row.id ?? rowIndex);
-}
-
-export function getWorkbenchStructuredDataSchemaTableCellPath({
-  column,
-  rowKey,
-  section,
-}: {
-  column: string;
-  rowKey: string;
-  section: WorkbenchStructuredDataSchemaSectionSummary;
-}) {
-  return [...getWorkbenchStructuredDataSchemaTablePath(section), rowKey, column];
-}
-
-export function removeWorkbenchStructuredDataSchemaTableRow({
-  rowIndex,
-  rowKey,
-  value,
-}: {
-  rowIndex: number;
-  rowKey: string;
-  value: unknown;
-}) {
-  if (Array.isArray(value)) return value.filter((_, index) => index !== rowIndex);
-
-  const nextRecord = { ...(asWorkbenchStructuredDataRecord(value) ?? {}) };
-  delete nextRecord[rowKey];
-  return nextRecord;
-}
-
-export function appendWorkbenchStructuredDataSchemaTableRow({
-  row,
-  rowKey,
-  value,
-}: {
-  row: WorkbenchStructuredDataRecord;
-  rowKey: string;
-  value: unknown;
-}) {
-  if (Array.isArray(value)) return [...value, row];
-
-  return {
-    ...(asWorkbenchStructuredDataRecord(value) ?? {}),
-    [rowKey]: { ...row, id: rowKey },
-  };
-}
-
-export function getWorkbenchStructuredDataSchemaTableColumns({
-  maxColumns = 6,
-  preferredColumns = [],
-  rows,
-  schemaColumns = [],
-  sectionColumns = [],
-}: WorkbenchStructuredDataSchemaTableColumnInput) {
-  if (sectionColumns.length) return [...sectionColumns];
-  if (schemaColumns.length) return [...schemaColumns];
-
-  const keys = Array.from(new Set(rows.flatMap((row) => Object.keys(row))));
-  const preferred = preferredColumns.filter((column) => keys.includes(column));
-  const remaining = keys.filter((column) => !preferred.includes(column));
-  return [...preferred, ...remaining].slice(0, maxColumns);
-}
-
 export function getWorkbenchStructuredDataSchemaDocumentTableColumns({
   maxColumns,
   preferredColumns,
@@ -668,19 +248,6 @@ export function getWorkbenchStructuredDataSchemaDocumentTableColumns({
   });
 }
 
-export function createWorkbenchStructuredDataSchemaEmptyRow({
-  columns,
-  getDefinition,
-}: {
-  columns: readonly string[];
-  getDefinition: (column: string) => WorkbenchStructuredDataSchemaFieldDefinition | undefined;
-}) {
-  return columns.reduce<WorkbenchStructuredDataRecord>((row, column) => {
-    row[column] = getWorkbenchStructuredDataSchemaFieldDefaultValue(getDefinition(column));
-    return row;
-  }, {});
-}
-
 export function createWorkbenchStructuredDataSchemaDocumentEmptyRow({
   columns,
   schema,
@@ -754,29 +321,6 @@ export function createWorkbenchStructuredDataSchemaFallbackSection({
   };
 }
 
-export function slugWorkbenchStructuredDataSchemaAnchor(value: string | undefined) {
-  return (
-    value
-      ?.toLowerCase()
-      .replace(/[^a-z0-9_-]+/g, '-')
-      .replace(/^-+|-+$/g, '') || 'section'
-  );
-}
-
-export function getWorkbenchStructuredDataSchemaSectionAnchorId({
-  index,
-  panelId,
-  section,
-}: {
-  index: number;
-  panelId: string;
-  section: WorkbenchStructuredDataSchemaSectionSummary;
-}) {
-  return `${panelId}-section-${index}-${slugWorkbenchStructuredDataSchemaAnchor(
-    getWorkbenchStructuredDataSchemaSectionId(section) ?? section.title,
-  )}`;
-}
-
 export function getWorkbenchStructuredDataSchemaDocumentPanelData({
   data,
   pattern,
@@ -793,94 +337,3 @@ export function getWorkbenchStructuredDataSchemaDocumentPanelData({
     createWorkbenchStructuredDataSchemaDocumentSampleData(schema, pattern)
   );
 }
-
-export function getWorkbenchStructuredDataFormFields(
-  sections: readonly WorkbenchStructuredDataFormSection[],
-) {
-  return sections.flatMap((section) => section.fields ?? []);
-}
-
-export function normalizeWorkbenchStructuredDataFormData(
-  sections: readonly WorkbenchStructuredDataFormSection[],
-  data: WorkbenchStructuredDataRecord = EMPTY_RECORD,
-): WorkbenchStructuredDataRecord {
-  return getWorkbenchStructuredDataFormFields(sections).reduce<WorkbenchStructuredDataRecord>(
-    (nextData, field) => {
-      const value = getWorkbenchStructuredDataValue(nextData, field.path);
-      return setWorkbenchStructuredDataValue(
-        nextData,
-        field.path,
-        value === undefined
-          ? getWorkbenchStructuredDataFormFieldDefaultValue(field)
-          : coerceWorkbenchStructuredDataFormFieldValue(field, value),
-      );
-    },
-    { ...data },
-  );
-}
-
-export function getWorkbenchStructuredDataFormFieldError({
-  data,
-  field,
-  value,
-}: {
-  data: WorkbenchStructuredDataRecord;
-  field: WorkbenchStructuredDataFormField;
-  value: WorkbenchStructuredDataFieldValue;
-}) {
-  if (field.validationMessage) return field.validationMessage;
-  if (field.required && isWorkbenchStructuredDataFormEmptyValue(value)) {
-    return 'This field is required.';
-  }
-
-  return field.validate?.(value, data, field);
-}
-
-export function getWorkbenchStructuredDataFormErrors(
-  sections: readonly WorkbenchStructuredDataFormSection[],
-  data: WorkbenchStructuredDataRecord = EMPTY_RECORD,
-): WorkbenchStructuredDataFormErrors {
-  const normalizedData = normalizeWorkbenchStructuredDataFormData(sections, data);
-
-  return getWorkbenchStructuredDataFormFields(sections).reduce<WorkbenchStructuredDataFormErrors>(
-    (errors, field) => {
-      const value = coerceWorkbenchStructuredDataFormFieldValue(
-        field,
-        getWorkbenchStructuredDataValue(normalizedData, field.path),
-      );
-      const error = getWorkbenchStructuredDataFormFieldError({
-        data: normalizedData,
-        field,
-        value,
-      });
-
-      if (isRenderableWorkbenchStructuredDataFormError(error)) {
-        errors[field.id] = error;
-      }
-
-      return errors;
-    },
-    {},
-  );
-}
-
-export function isWorkbenchStructuredDataFormSubmittable({
-  disabled = false,
-  errors = {},
-  readOnly = false,
-}: {
-  disabled?: boolean;
-  errors?: WorkbenchStructuredDataFormErrors;
-  readOnly?: boolean;
-}) {
-  return !disabled && !readOnly && Object.keys(errors).length === 0;
-}
-
-function isWorkbenchStructuredDataFormEmptyValue(value: WorkbenchStructuredDataFieldValue) {
-  if (Array.isArray(value)) return value.length === 0;
-  return value === '' || value === false;
-}
-
-function isRenderableWorkbenchStructuredDataFormError(error: ReactNode) {
-  return error !== undefined && error !== null && error !== false && error !== '';
-}