@uides/stepwise 2.2.1 → 2.2.3

package/src/schemas/field/afm/index.ts

@@ -1,19 +1,21 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const AfmDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('afm'),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const AfmSchema = v.strictObject({
-  'user-input-mode': v.picklist(['noinput', 'optional', 'required', 'display']),
-  attribute: v.nullish(v.string()),
-  datatype: v.nullish(v.literal('afm')),
+const AfmSchema = createFieldSchema({
+  'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
   display: AfmDisplaySchema,
   'default-value': v.nullish(v.string()),
-  sources: v.nullish(v.string()),
 });
 export type AfmType = v.InferOutput<typeof AfmSchema>;
 export type AfmSchemaType = v.GenericSchema<AfmType>;

package/src/schemas/field/amka/index.ts

@@ -1,22 +1,20 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const AmkaDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('amka'),
-    'component-params': v.nullish(
-      v.strictObject({
-        textColor: v.nullish(v.string()),
-      })
-    ),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const AmkaSchema = v.strictObject({
+const AmkaSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  attribute: v.nullish(v.string()),
   display: AmkaDisplaySchema,
-  datatype: v.nullish(v.literal('amka')),
   'default-value': v.nullish(v.string()),
 });
 

package/src/schemas/field/attachment/index.ts

@@ -1,40 +1,26 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
-
-const CommonAttachmentComponentParamsSchema = v.strictObject({
-  filetype: v.nullish(v.picklist(['pdf', 'pdf-for-mark'])),
-  'file-max-size': v.nullish(v.number()),
-});
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const AttachmentDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('attachment'),
     'component-params': v.nullish(
-      v.strictObject({
-        ...CommonAttachmentComponentParamsSchema.entries,
+      createComponentParams({
+        filetype: v.nullish(v.picklist(['pdf', 'pdf-for-mark'])),
+        'file-max-size': v.nullish(v.number()),
         multiplicity: v.nullish(v.number()),
       })
     ),
-  }),
-  v.strictObject({
-    component: v.literal('attachment'),
-    'component-params': v.nullish(
-      // TODO: Make pdf component-params also inherit default component-params
-      v.strictObject({
-        ...CommonAttachmentComponentParamsSchema.entries,
-        coordinates: v.nullish(v.array(v.nullable(v.number()))),
-      })
-    ),
   })
 );
 
-const AttachmentSchema = v.strictObject({
+const AttachmentSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required', 'display']),
-  datatype: v.nullish(v.literal('attachment')),
-  attribute: v.nullish(v.string()),
   display: AttachmentDisplaySchema,
-  sources: v.nullish(v.string()),
-  'value-constructor': v.nullish(v.string()),
   'validation-download-attachment-fn': v.nullish(v.string()),
 });
 

package/src/schemas/field/captcha/index.ts

@@ -1,14 +1,19 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const CaptchaDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('captcha'),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const CaptchaSchema = v.strictObject({
-  'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
+const CaptchaSchema = createFieldSchema({
+  'user-input-mode': v.literal('required'),
   display: CaptchaDisplaySchema,
 });
 

package/src/schemas/field/choice/index.ts

@@ -1,5 +1,9 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const ChoiceDisplaySchema = createFieldDisplay(
   v.strictObject({
@@ -7,7 +11,7 @@ const ChoiceDisplaySchema = createFieldDisplay(
     choices: v.nullish(v.union([v.string(), v.record(v.string(), v.string())])),
     'choices-order': v.nullish(v.string()),
     'component-params': v.nullish(
-      v.strictObject({
+      createComponentParams({
         autocomplete: v.nullish(v.boolean()),
         'legacy-mode': v.nullish(v.boolean()),
         'format-title': v.nullish(v.boolean()),
@@ -16,13 +20,11 @@ const ChoiceDisplaySchema = createFieldDisplay(
   })
 );
 
-const ChoiceSchema = v.strictObject({
+const ChoiceSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
   display: ChoiceDisplaySchema,
   'default-value': v.nullish(v.string()),
   'choices-source-fn': v.nullish(v.string()),
-  attribute: v.nullish(v.string()),
-  datatype: v.nullish(v.picklist(['choice', 'string'])),
 });
 
 export type ChoiceType = v.InferOutput<typeof ChoiceSchema>;

package/src/schemas/field/common.spec.ts

@@ -39,9 +39,6 @@ const DisplaySchema = createFieldDisplay(
   v.strictObject({
     label: v.string(),
     value: v.number(),
-  }),
-  v.strictObject({
-    flag: v.boolean(),
   })
 );
 

package/src/schemas/field/common.ts

@@ -1,16 +1,13 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
 import * as v from 'valibot';
-import {
-  DisplayLang,
-  DisplayModeSchema,
-  DisplayLangSchema as BaseDisplayLangSchema,
-} from '@uides/stepwise/schemas/common';
+import { DisplayLang } from '@uides/stepwise/schemas/common';
 import { resolveDisplay } from '@uides/stepwise/schemas/resolve';
 import { isFailureDataset } from '@uides/stepwise/utils';
 
+const KNOWN_DISPLAY_MODES = ['default', 'web', 'pdf'] as const;
+
 // TODO: Make default lang mandatory?
 const FieldDisplayLangSchema = v.pipe(
-  v.record(BaseDisplayLangSchema, v.any()),
+  v.record(v.string(), v.any()),
   v.check((val) => {
     if (!val) return false;
     if (Object.keys(val).length === 0) return false;
@@ -20,20 +17,39 @@ const FieldDisplayLangSchema = v.pipe(
 
 // TODO: Make default mode mandatory?
 export const DisplayModeAndLangSchema = v.pipe(
-  v.record(DisplayModeSchema, FieldDisplayLangSchema),
-  v.check((val) => {
-    if (!val) return false;
-    if (Object.keys(val).length === 0) return false;
-    return true;
-  }, 'At least one display mode must be defined.')
+  v.record(v.string(), v.any()),
+  v.rawCheck<Record<string, unknown>>(({ dataset, addIssue }) => {
+    if (isFailureDataset(dataset)) return;
+    const val = dataset.value;
+    if (!val || Object.keys(val).length === 0) {
+      addIssue({ message: 'At least one display mode must be defined.' });
+      return;
+    }
+    for (const [key, value] of Object.entries(val)) {
+      if (!(KNOWN_DISPLAY_MODES as readonly string[]).includes(key)) continue;
+      const result = v.safeParse(FieldDisplayLangSchema, value);
+      if (result.issues) {
+        result.issues.forEach((issue) => {
+          addIssue({
+            message: issue.message,
+            path: issue.path,
+            input: issue.input,
+            expected: issue.expected ?? undefined,
+            received: issue.received,
+          });
+        });
+      }
+    }
+  })
 );
 
+const VALIDATED_DISPLAY_MODES = ['default', 'web'] as const;
+
 type AnyGenericSchema = v.GenericSchema<unknown, unknown>;
 
 export interface DisplayType<
   DefaultDisplaySchema extends AnyGenericSchema,
   WebDisplaySchema extends AnyGenericSchema = AnyGenericSchema,
-  PdfDisplaySchema extends AnyGenericSchema = AnyGenericSchema,
 > {
   default?: Partial<
     Record<
@@ -47,17 +63,11 @@ export interface DisplayType<
       v.InferOutput<WebDisplaySchema> | (unknown & Record<never, never>)
     >
   >;
-  pdf?: Partial<
-    Record<
-      DisplayLang,
-      v.InferOutput<PdfDisplaySchema> | (unknown & Record<never, never>)
-    >
-  >;
 }
 
 // TODO: Is type too big?
 /**
- * Creates a field display schema with specified default and PDF display properties.
+ * Creates a field display schema with specified default display properties.
  *
  * Defaults are:
  * - title
@@ -70,19 +80,10 @@ export interface DisplayType<
  *   - md
  * - example
  */
-export function createFieldDisplay<
-  D extends v.ObjectEntries,
-  P extends v.ObjectEntries = never,
->(
+export function createFieldDisplay<D extends v.ObjectEntries>(
   DefaultDisplay:
     | v.StrictObjectSchema<D, undefined>
-    | v.LooseObjectSchema<D, undefined>,
-  // TODO: Add PDF validation
-
-  // @ts-expect-error value not used
-  PdfDisplay?:
-    | v.StrictObjectSchema<P, undefined>
-    | v.LooseObjectSchema<P, undefined>
+    | v.LooseObjectSchema<D, undefined>
 ) {
   // Base schema for display modes
   // Use loose or strict object based on DefaultDisplay schema type
@@ -99,34 +100,16 @@ export function createFieldDisplay<
     v.record(v.string(), defaultDisplayContent)
   );
 
-  // const pdfDisplayContent = v.strictObject({
-  //   ...FieldDisplayModeBaseSchema.entries,
-  //   ...v.partial(DefaultDisplay).entries,
-  //   ...PdfDisplay?.entries,
-  // });
-  // const pdfDisplaySchema = v.record(
-  //   v.string(),
-  //   v.record(v.string(), pdfDisplayContent)
-  // );
-
   const DisplaySchema = v.pipe(
     v.record(v.string(), v.any()),
     v.rawCheck<
-      DisplayType<
-        typeof defaultDisplayContent,
-        typeof defaultDisplayContent,
-        typeof defaultDisplayContent
-      >
+      DisplayType<typeof defaultDisplayContent, typeof defaultDisplayContent>
     >(({ addIssue, dataset }) => {
       if (isFailureDataset(dataset)) return;
       const display = dataset.value;
 
-      DisplayModeSchema.options.forEach((displayMode) => {
-        if (
-          !(displayMode in display && display[displayMode]) ||
-          displayMode === 'pdf' // TODO: Add PDF validation
-        )
-          return;
+      VALIDATED_DISPLAY_MODES.forEach((displayMode) => {
+        if (!(displayMode in display && display[displayMode])) return;
         Object.keys(display[displayMode]).forEach((displayLang) => {
           const resolvedDisplay = resolveDisplay(
             displayMode,
@@ -178,3 +161,82 @@ const FieldDisplayModeBaseSchema = v.strictObject({
     })
   ),
 });
+
+export const COMMON_FIELD_ATTRS = {
+  attribute: v.nullish(v.any()),
+  sources: v.nullish(v.any()),
+  'value-constructor': v.nullish(v.any()),
+  datatype: v.nullish(v.any()),
+  'is-display-field': v.nullish(v.any()),
+  'default-on-empty': v.nullish(v.any()),
+} as const;
+
+/**
+ * Creates a field schema with common attributes pre-applied.
+ *
+ * Common attributes are backend-related concerns that the UI does not use, mostly related to PDF.
+ * Per-field entries override common ones.
+ *
+ * @param entries - Field-specific entries.
+ * @param mode - `'strict'` (default) or `'loose'` object schema.
+ */
+export function createFieldSchema<E extends v.ObjectEntries>(
+  entries: E,
+  mode: 'strict' | 'loose' = 'strict'
+) {
+  // const factory = mode === 'loose' ? v.looseObject : v.strictObject;
+  if (mode === 'strict') {
+    return v.strictObject({
+      ...COMMON_FIELD_ATTRS,
+      ...entries,
+    });
+  } else {
+    return v.looseObject({
+      ...COMMON_FIELD_ATTRS,
+      ...entries,
+    });
+  }
+}
+
+export const COMMON_COMPONENT_PARAMS_ATTRS = {
+  coordinates: v.nullish(v.any()),
+  'later-pages': v.nullish(v.any()),
+  fontSize: v.nullish(v.any()),
+  fontName: v.nullish(v.any()),
+  leading: v.nullish(v.any()),
+  textColor: v.nullish(v.any()),
+  backColor: v.nullish(v.any()),
+  bold: v.nullish(v.any()),
+  format: v.nullish(v.any()),
+  emph: v.nullish(v.any()),
+  ignore_emph: v.nullish(v.any()),
+  cell_valign: v.nullish(v.any()),
+  position: v.nullish(v.any()),
+  attachment_retrieval: v.nullish(v.any()),
+} as const;
+
+/**
+ * Creates a `component-params` schema with common attributes pre-applied.
+ *
+ * Common attributes are backend-related concerns that the UI does not use, mostly related to PDF.
+ * Per-field entries override common ones.
+ *
+ * @param entries - Field-specific entries.
+ * @param mode - `'strict'` (default) or `'loose'` object schema.
+ */
+export function createComponentParams<E extends v.ObjectEntries>(
+  entries: E,
+  mode: 'strict' | 'loose' = 'strict'
+) {
+  if (mode === 'strict') {
+    return v.strictObject({
+      ...COMMON_COMPONENT_PARAMS_ATTRS,
+      ...entries,
+    });
+  } else {
+    return v.looseObject({
+      ...COMMON_COMPONENT_PARAMS_ATTRS,
+      ...entries,
+    });
+  }
+}

package/src/schemas/field/date/index.ts

@@ -1,37 +1,21 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const DateDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('date'),
-    'component-params': v.nullish(
-      v.strictObject({
-        'format-title': v.nullish(v.boolean()),
-        cell_valign: v.nullish(v.picklist(['BOTTOM', 'MIDDLE', 'TOP'])),
-        bold: v.nullish(v.boolean()),
-        position: v.nullish(v.picklist(['left', 'right', 'center', 'justify'])),
-        textColor: v.nullish(v.string()),
-        labels: v.nullish(
-          v.strictObject({
-            day: v.string(),
-            month: v.string(),
-            year: v.string(),
-          })
-        ),
-      })
-    ),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const DateSchema = v.strictObject({
-  'user-input-mode': v.picklist(['noinput', 'required', 'optional']),
+const DateSchema = createFieldSchema({
+  'user-input-mode': v.picklist(['noinput']),
   display: DateDisplaySchema,
-  attribute: v.nullish(v.string()),
-  sources: v.nullish(v.string()),
-  datatype: v.nullish(v.literal('date')),
-  'value-constructor': v.nullish(v.string()),
   value: v.nullish(v.string()),
-  'is-display-field': v.nullish(v.boolean()),
 });
 
 export type DateType = v.InferOutput<typeof DateSchema>;

package/src/schemas/field/doc_subtitle/index.ts

@@ -1,18 +1,21 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const DocSubtitleDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('doc_subtitle'),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const DocSubtitleSchema = v.strictObject({
+const DocSubtitleSchema = createFieldSchema({
   display: DocSubtitleDisplaySchema,
   'user-input-mode': v.literal('noinput'),
   value: v.nullish(v.string()),
-  datatype: v.nullish(v.literal('string')),
-  attribute: v.nullish(v.string()),
 });
 
 export type DocSubtitleType = v.InferOutput<typeof DocSubtitleSchema>;

package/src/schemas/field/doc_title/index.ts

@@ -1,29 +1,22 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
-
-const CommonDocTitleParamsSchema = v.nullish(
-  v.strictObject({
-    leading: v.nullish(v.number()),
-  })
-);
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const DocTitleDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('doc_title'),
-    'component-params': CommonDocTitleParamsSchema,
-  }),
-  v.strictObject({
-    component: v.literal('doc_title'),
-    'component-params': CommonDocTitleParamsSchema,
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const DocTitleSchema = v.strictObject({
+const DocTitleSchema = createFieldSchema({
   display: DocTitleDisplaySchema,
   'user-input-mode': v.literal('noinput'),
   value: v.nullish(v.string()),
   'default-value': v.nullish(v.string()),
-  attribute: v.nullish(v.string()),
 });
 
 export type DocTitleType = v.InferOutput<typeof DocTitleSchema>;

package/src/schemas/field/dynamically-filled-text/index.ts

@@ -1,34 +1,26 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const DynamicallyFilledTextDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('dynamically-filled-text'),
     'component-params': v.nullish(
-      v.strictObject({
+      createComponentParams({
         fill: v.nullish(v.boolean()),
-        position: v.nullish(v.picklist(['center', 'justify', 'left', 'right'])),
-        format: v.nullish(v.literal('plaintext')),
-        textColor: v.nullish(v.string()),
-        emph: v.nullish(v.boolean()),
-        bold: v.nullish(v.boolean()),
-        cell_valign: v.nullish(v.string()),
-        leading: v.nullish(v.number()),
       })
     ),
   })
 );
 
-const DynamicallyFilledTextSchema = v.strictObject({
+const DynamicallyFilledTextSchema = createFieldSchema({
   value: v.nullish(v.string()),
   display: DynamicallyFilledTextDisplaySchema,
   'user-input-mode': v.picklist(['noinput', 'display']),
   'default-value': v.nullish(v.string()),
-  sources: v.nullish(v.string()),
-  'value-constructor': v.nullish(v.string()),
-  attribute: v.nullish(v.string()),
-  datatype: v.nullish(v.literal('string')),
-  'is-display-field': v.nullish(v.boolean()),
 });
 
 export type DynamicallyFilledTextType = v.InferOutput<

package/src/schemas/field/email/index.ts

@@ -1,23 +1,21 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const EmailDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('email'),
-    'component-params': v.nullish(
-      v.strictObject({
-        multiplicity: v.nullish(v.number()),
-      })
-    ),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const EmailSchema = v.strictObject({
+const EmailSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
   display: EmailDisplaySchema,
-  attribute: v.nullish(v.string()),
   'default-value': v.nullish(v.string()),
-  datatype: v.nullish(v.literal('email')),
 });
 
 export type EmailType = v.InferOutput<typeof EmailSchema>;

package/src/schemas/field/fillable-string/index.ts

@@ -1,27 +1,23 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const FillableStringDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('fillable-string'),
-    'component-params': v.nullish(
-      v.strictObject({
-        emph: v.nullish(v.boolean()),
-      })
-    ),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const FillableStringSchema = v.strictObject({
+const FillableStringSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'display', 'optional']),
   display: FillableStringDisplaySchema,
-  attribute: v.nullish(v.string()),
   'default-value': v.nullish(v.string()),
-  'value-constructor': v.nullish(v.string()),
   value: v.nullish(v.string()),
   safe: v.nullish(v.boolean()),
-  sources: v.nullish(v.string()),
-  datatype: v.nullish(v.literal('string')),
 });
 
 export type FillableStringType = v.InferOutput<typeof FillableStringSchema>;

package/src/schemas/field/five-block-date/index.ts

@@ -1,13 +1,18 @@
 import * as v from 'valibot';
-import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
+import {
+  createComponentParams,
+  createFieldDisplay,
+  createFieldSchema,
+} from '@uides/stepwise/schemas/field/common';
 
 const FiveBlockDateDisplaySchema = createFieldDisplay(
   v.strictObject({
     component: v.literal('five-block-date'),
+    'component-params': v.nullish(createComponentParams({})),
   })
 );
 
-const FiveBlockDateSchema = v.strictObject({
+const FiveBlockDateSchema = createFieldSchema({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
   display: FiveBlockDateDisplaySchema,
 });