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

package/src/workbench/settings/structuredDataSchemaDate.ts

@@ -0,0 +1,197 @@
+import type { WorkbenchStructuredDataSchemaFieldDefinition } from './structuredDataSchemaTypes';
+
+export const WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT = 'yyyy-MM-dd';
+
+interface WorkbenchStructuredDataDateParts {
+  day: number;
+  month: number;
+  year: number;
+}
+
+const COMPACT_DATE_PATTERN = /^\d{8}$/;
+const HTML_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+export function normalizeWorkbenchStructuredDataSchemaDateFormat(format: string): string {
+  return format.trim().replace(/YYYY/g, 'yyyy').replace(/DD/g, 'dd');
+}
+
+export function inferWorkbenchStructuredDataSchemaDateFormat(
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): string | undefined {
+  const pattern = definition?.pattern?.trim();
+  if (!pattern) return undefined;
+
+  if (COMPACT_DATE_PATTERN.test('20260703') && /\\d\{8\}/.test(pattern)) {
+    return 'yyyyMMdd';
+  }
+
+  if (/\\d\{4\}-\\d\{2\}-\\d\{2\}/.test(pattern)) {
+    return WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT;
+  }
+
+  return undefined;
+}
+
+export function resolveWorkbenchStructuredDataSchemaDateFormat(
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): string {
+  const explicit = definition?.ui?.dateFormat?.trim();
+  if (explicit) {
+    return normalizeWorkbenchStructuredDataSchemaDateFormat(explicit);
+  }
+
+  return (
+    inferWorkbenchStructuredDataSchemaDateFormat(definition) ??
+    WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT
+  );
+}
+
+export function isWorkbenchStructuredDataSchemaDateField(
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): boolean {
+  if (!definition) return false;
+  if (definition.ui?.control === 'date') return true;
+  return definition.format === 'date';
+}
+
+function isValidDateParts(parts: WorkbenchStructuredDataDateParts): boolean {
+  const { day, month, year } = parts;
+  if (!Number.isInteger(year) || !Number.isInteger(month) || !Number.isInteger(day)) {
+    return false;
+  }
+  if (month < 1 || month > 12 || day < 1 || day > 31) return false;
+
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return (
+    date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day
+  );
+}
+
+function parseWorkbenchStructuredDataDateParts(
+  value: string,
+  format: string,
+): WorkbenchStructuredDataDateParts | null {
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+
+  if (format === 'yyyyMMdd' && COMPACT_DATE_PATTERN.test(trimmed)) {
+    const parts = {
+      year: Number(trimmed.slice(0, 4)),
+      month: Number(trimmed.slice(4, 6)),
+      day: Number(trimmed.slice(6, 8)),
+    };
+    return isValidDateParts(parts) ? parts : null;
+  }
+
+  if (format === WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT && HTML_DATE_PATTERN.test(trimmed)) {
+    const parts = {
+      year: Number(trimmed.slice(0, 4)),
+      month: Number(trimmed.slice(5, 7)),
+      day: Number(trimmed.slice(8, 10)),
+    };
+    return isValidDateParts(parts) ? parts : null;
+  }
+
+  const tokenPattern = format
+    .replace(/yyyy/g, '(?<year>\\d{4})')
+    .replace(/MM/g, '(?<month>\\d{2})')
+    .replace(/dd/g, '(?<day>\\d{2})');
+  const match = trimmed.match(new RegExp(`^${tokenPattern}$`));
+  if (!match?.groups) return null;
+
+  const parts = {
+    year: Number(match.groups.year),
+    month: Number(match.groups.month),
+    day: Number(match.groups.day),
+  };
+  return isValidDateParts(parts) ? parts : null;
+}
+
+export function formatWorkbenchStructuredDataSchemaDateValue(
+  parts: WorkbenchStructuredDataDateParts,
+  format: string,
+): string {
+  const normalizedFormat = normalizeWorkbenchStructuredDataSchemaDateFormat(format);
+  const year = String(parts.year).padStart(4, '0');
+  const month = String(parts.month).padStart(2, '0');
+  const day = String(parts.day).padStart(2, '0');
+
+  return normalizedFormat.replace(/yyyy/g, year).replace(/MM/g, month).replace(/dd/g, day);
+}
+
+export function parseWorkbenchStructuredDataSchemaDateValue(
+  value: unknown,
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): WorkbenchStructuredDataDateParts | null {
+  if (value === null || value === undefined || value === '') return null;
+  const stringValue = String(value).trim();
+  if (!stringValue) return null;
+
+  const primaryFormat = resolveWorkbenchStructuredDataSchemaDateFormat(definition);
+  const primary = parseWorkbenchStructuredDataDateParts(stringValue, primaryFormat);
+  if (primary) return primary;
+
+  if (HTML_DATE_PATTERN.test(stringValue)) {
+    return parseWorkbenchStructuredDataDateParts(
+      stringValue,
+      WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT,
+    );
+  }
+
+  if (COMPACT_DATE_PATTERN.test(stringValue)) {
+    return parseWorkbenchStructuredDataDateParts(stringValue, 'yyyyMMdd');
+  }
+
+  return null;
+}
+
+export function toWorkbenchStructuredDataHtmlDateInputValue(
+  value: unknown,
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): string {
+  const parts = parseWorkbenchStructuredDataSchemaDateValue(value, definition);
+  if (!parts) return '';
+  return formatWorkbenchStructuredDataSchemaDateValue(
+    parts,
+    WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT,
+  );
+}
+
+export function fromWorkbenchStructuredDataHtmlDateInputValue(
+  htmlValue: string,
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): string {
+  const trimmed = htmlValue.trim();
+  if (!trimmed) return '';
+
+  const parts = parseWorkbenchStructuredDataDateParts(
+    trimmed,
+    WORKBENCH_STRUCTURED_DATA_HTML_DATE_FORMAT,
+  );
+  if (!parts) return trimmed;
+
+  return formatWorkbenchStructuredDataSchemaDateValue(
+    parts,
+    resolveWorkbenchStructuredDataSchemaDateFormat(definition),
+  );
+}
+
+export function coerceWorkbenchStructuredDataSchemaDateValue(
+  rawValue: string,
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): string {
+  const trimmed = rawValue.trim();
+  if (!trimmed) return '';
+
+  if (HTML_DATE_PATTERN.test(trimmed)) {
+    return fromWorkbenchStructuredDataHtmlDateInputValue(trimmed, definition);
+  }
+
+  const parts = parseWorkbenchStructuredDataSchemaDateValue(trimmed, definition);
+  if (!parts) return trimmed;
+
+  return formatWorkbenchStructuredDataSchemaDateValue(
+    parts,
+    resolveWorkbenchStructuredDataSchemaDateFormat(definition),
+  );
+}

package/src/workbench/settings/structuredDataSchemaField.ts

@@ -0,0 +1,105 @@
+import type {
+  WorkbenchStructuredDataSchemaFieldControl,
+  WorkbenchStructuredDataSchemaFieldDefinition,
+} from './structuredDataSchemaTypes';
+import {
+  coerceWorkbenchStructuredDataSchemaDateValue,
+  isWorkbenchStructuredDataSchemaDateField,
+  toWorkbenchStructuredDataHtmlDateInputValue,
+} from './structuredDataSchemaDate';
+import {
+  hasWorkbenchStructuredDataSchemaSelectOptions,
+  isWorkbenchStructuredDataSchemaColorField,
+  shouldUseWorkbenchStructuredDataSchemaRadioControl,
+} from './structuredDataSchemaValidation';
+
+export function getWorkbenchStructuredDataSchemaFieldControl(
+  definition: WorkbenchStructuredDataSchemaFieldDefinition | undefined,
+): WorkbenchStructuredDataSchemaFieldControl {
+  if (definition?.ui?.control) {
+    return definition.ui.control as WorkbenchStructuredDataSchemaFieldControl;
+  }
+  if (isWorkbenchStructuredDataSchemaColorField(definition)) return 'color';
+  if (hasWorkbenchStructuredDataSchemaSelectOptions(definition)) {
+    return shouldUseWorkbenchStructuredDataSchemaRadioControl(definition) ? 'radio' : '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 (isWorkbenchStructuredDataSchemaDateField(definition)) {
+    return toWorkbenchStructuredDataHtmlDateInputValue(value, definition);
+  }
+  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;
+  }
+
+  if (definition?.oneOf?.length) {
+    const match = definition.oneOf.find((option) => String(option.const) === rawValue);
+    return match?.const ?? rawValue;
+  }
+
+  if (definition?.ui?.options?.length) {
+    const match = definition.ui.options.find((option) => String(option.value) === rawValue);
+    return match?.value ?? rawValue;
+  }
+
+  if (isWorkbenchStructuredDataSchemaDateField(definition)) {
+    return coerceWorkbenchStructuredDataSchemaDateValue(rawValue, definition);
+  }
+
+  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 formatWorkbenchStructuredDataSchemaLabel(value: string) {
+  return value.replace(/_/g, ' ');
+}

package/src/workbench/settings/structuredDataSchemaSection.ts

@@ -0,0 +1,74 @@
+import type {
+  WorkbenchStructuredDataSchemaFieldDefinition,
+  WorkbenchStructuredDataSchemaSectionSummary,
+} from './structuredDataSchemaTypes';
+import { formatWorkbenchStructuredDataSchemaLabel } from './structuredDataSchemaField';
+
+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 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 getWorkbenchStructuredDataSchemaSectionFieldLabel(fieldPath: string) {
+  return formatWorkbenchStructuredDataSchemaLabel(fieldPath.split('.').pop() ?? fieldPath);
+}
+
+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,
+  )}`;
+}

package/src/workbench/settings/structuredDataSchemaTable.ts

@@ -0,0 +1,120 @@
+import { asWorkbenchStructuredDataRecord } from '@workbench-kit/workspace';
+import type {
+  WorkbenchStructuredDataRecord,
+  WorkbenchStructuredDataSchemaFieldDefinition,
+  WorkbenchStructuredDataSchemaSectionSummary,
+  WorkbenchStructuredDataSchemaTableColumnInput,
+  WorkbenchStructuredDataSchemaTableRowKeyInput,
+} from './structuredDataSchemaTypes';
+import { getWorkbenchStructuredDataSchemaFieldDefaultValue } from './structuredDataSchemaField';
+import { getWorkbenchStructuredDataSchemaSectionPath } from './structuredDataSchemaSection';
+
+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 createWorkbenchStructuredDataSchemaEmptyRow({
+  columns,
+  getDefinition,
+}: {
+  columns: readonly string[];
+  getDefinition: (column: string) => WorkbenchStructuredDataSchemaFieldDefinition | undefined;
+}) {
+  return columns.reduce<WorkbenchStructuredDataRecord>((row, column) => {
+    row[column] = getWorkbenchStructuredDataSchemaFieldDefaultValue(getDefinition(column));
+    return row;
+  }, {});
+}