@uides/stepwise 1.1.0-rc.26 → 2.0.0-b15d5d44

package/src/schemas/field/common.ts

@@ -1,57 +1,54 @@
 import * as v from 'valibot';
 import {
-  DisplayMode,
   DisplayLang,
-  nullish,
-  object,
-  specialWithNestedSchema,
+  DisplayModeSchema,
+  DisplayLangSchema as BaseDisplayLangSchema,
 } from '@uides/stepwise/schemas/common';
 import { resolveDisplay } from '@uides/stepwise/schemas/resolve';
 
 // TODO: Make default lang mandatory?
-const DisplayLangSchema = v.record(DisplayLang, v.any(), [
-  v.custom((val) => {
+const FieldDisplayLangSchema = v.pipe(
+  v.record(BaseDisplayLangSchema, v.any()),
+  v.check((val) => {
     if (!val) return false;
     if (Object.keys(val).length === 0) return false;
     return true;
-  }, 'At least one display lang must be defined.'),
-]);
+  }, 'At least one display lang must be defined.')
+);
 
 // TODO: Make default mode mandatory?
-export const DisplayModeAndLangSchema = v.record(
-  DisplayMode,
-  DisplayLangSchema,
-  [
-    v.custom((val) => {
-      if (!val) return false;
-      if (Object.keys(val).length === 0) return false;
-      return true;
-    }, 'At least one display mode must be defined.'),
-  ]
+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.')
 );
 
-type AnyBaseSchema = v.BaseSchema<unknown, unknown>;
+type AnyGenericSchema = v.GenericSchema<unknown, unknown>;
+
 export interface DisplayType<
-  DefaultDisplaySchema extends AnyBaseSchema = AnyBaseSchema,
-  WebDisplaySchema extends AnyBaseSchema = AnyBaseSchema,
-  PdfDisplaySchema extends AnyBaseSchema = AnyBaseSchema,
+  DefaultDisplaySchema extends AnyGenericSchema,
+  WebDisplaySchema extends AnyGenericSchema = AnyGenericSchema,
+  PdfDisplaySchema extends AnyGenericSchema = AnyGenericSchema,
 > {
   default?: Partial<
     Record<
       DisplayLang,
-      v.Output<DefaultDisplaySchema> | (unknown & Record<never, never>)
+      v.InferOutput<DefaultDisplaySchema> | (unknown & Record<never, never>)
     >
   >;
   web?: Partial<
     Record<
       DisplayLang,
-      v.Output<WebDisplaySchema> | (unknown & Record<never, never>)
+      v.InferOutput<WebDisplaySchema> | (unknown & Record<never, never>)
     >
   >;
   pdf?: Partial<
     Record<
       DisplayLang,
-      v.Output<PdfDisplaySchema> | (unknown & Record<never, never>)
+      v.InferOutput<PdfDisplaySchema> | (unknown & Record<never, never>)
     >
   >;
 }
@@ -61,77 +58,98 @@ export function createFieldDisplay<
   D extends v.ObjectEntries,
   P extends v.ObjectEntries = never,
 >(
-  DefaultDisplay: v.ObjectSchema<D, v.NeverSchema>,
-  PdfDisplay?: v.ObjectSchema<P, v.NeverSchema>
+  DefaultDisplay: v.StrictObjectSchema<D, undefined>,
+  PdfDisplay?: v.StrictObjectSchema<P, undefined>
 ) {
+  const defaultDisplayContent = v.strictObject({
+    ...FieldDisplayModeBaseSchema.entries,
+    ...DefaultDisplay.entries,
+  });
   const defaultDisplaySchema = v.record(
     v.string(),
-    v.record(
-      object({
-        ...FieldDisplayModeBase.entries,
-        ...DefaultDisplay.entries,
-      })
-    )
+    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(
-      object({
-        ...FieldDisplayModeBase.entries,
-        ...v.partial(DefaultDisplay).entries,
-        ...PdfDisplay?.entries,
-      })
-    )
+    v.record(v.string(), pdfDisplayContent)
   );
-  const DisplaySchema = specialWithNestedSchema<
-    DisplayType<
-      typeof defaultDisplaySchema,
-      typeof defaultDisplaySchema,
-      typeof pdfDisplaySchema
-    >
-  >((display) => {
-    if (!display) return undefined;
-    let issues: v.SchemaIssues | undefined;
-    DisplayMode.options.forEach((displayMode) => {
-      if (!display[displayMode]) return;
-      Object.keys(display[displayMode] as NonNullable<unknown>).forEach(
-        (displayLang) => {
-          const resolvedDisplay = resolveDisplay(
-            displayMode,
-            displayLang as DisplayLang,
-            display
-          );
-          const displaySchema =
-            displayMode === 'pdf' ? pdfDisplaySchema : defaultDisplaySchema;
-          const result = v.safeParse(displaySchema, {
-            [displayMode]: {
-              [displayLang]: resolvedDisplay,
-            },
-          });
-          if (result.issues) {
-            issues?.push(...result.issues);
-          }
-          if (!issues) {
-            issues = result.issues;
+
+  const DisplaySchema = v.pipe(
+    v.record(v.string(), v.any()), // TODO: Unnecessary?
+    v.rawCheck<
+      DisplayType<
+        typeof defaultDisplayContent,
+        typeof defaultDisplayContent,
+        typeof pdfDisplayContent
+      >
+    >(({ addIssue, dataset }) => {
+      const display = dataset.value;
+      if (!(display && typeof display === 'object')) {
+        addIssue({
+          message: 'Display must be an object.',
+        });
+        return;
+      }
+
+      DisplayModeSchema.options.forEach((displayMode) => {
+        if (
+          !(
+            displayMode in display &&
+            display[displayMode as keyof typeof display]
+          )
+        )
+          return;
+        Object.keys(display[displayMode as keyof typeof display]).forEach(
+          (displayLang) => {
+            const resolvedDisplay = resolveDisplay(
+              displayMode,
+              displayLang as DisplayLang,
+              display
+            );
+            const displaySchema =
+              displayMode === 'pdf' ? pdfDisplaySchema : defaultDisplaySchema;
+            const result = v.safeParse(displaySchema, {
+              [displayMode]: {
+                [displayLang]: resolvedDisplay,
+              },
+            });
+            if (result.issues) {
+              // TODO: Add subissues
+              result.issues.forEach((issue) => {
+                addIssue({
+                  message: issue.message,
+                  path: issue.path,
+                  input: issue.input,
+                  expected: issue.expected ?? undefined,
+                  received: issue.received,
+                  label: 'Display schema',
+                });
+              });
+            }
           }
-        }
-      );
-    });
-    return issues;
-  });
+        );
+      });
+    })
+  );
   return DisplaySchema;
 }
 
-const FieldDisplayModeBase = object({
-  title: nullish(v.string()),
-  title_md: nullish(v.number()),
-  value_md: nullish(v.number()),
-  hint: nullish(v.string()),
-  hint_md: nullish(v.string()),
-  template_hint: nullish(v.string()),
-  example: nullish(v.string()),
-  layout: nullish(
-    object({
+const FieldDisplayModeBaseSchema = v.strictObject({
+  title: v.nullish(v.string()),
+  title_md: v.nullish(v.number()),
+  value_md: v.nullish(v.number()),
+  hint: v.nullish(v.string()),
+  hint_md: v.nullish(v.string()),
+  template_hint: v.nullish(v.string()),
+  example: v.nullish(v.string()),
+  layout: v.nullish(
+    v.strictObject({
       md: v.string(),
     })
   ),

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

@@ -1,19 +1,18 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const DateDisplay = createFieldDisplay(
-  object({
+const DateDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('date'),
-    'component-params': nullish(
-      object({
-        'format-title': nullish(v.boolean()),
-        cell_valign: nullish(v.picklist(['BOTTOM', 'MIDDLE', 'TOP'])),
-        bold: nullish(v.boolean()),
-        position: nullish(v.picklist(['left', 'right', 'center', 'justify'])),
-        textColor: nullish(v.string()),
-        labels: nullish(
-          object({
+    '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(),
@@ -24,7 +23,7 @@ const DateDisplay = createFieldDisplay(
   })
 );
 
-const DateAttribute = nullish(
+const DateAttributeSchema = v.nullish(
   v.picklist([
     'covid19_negative_test_2:birthDate',
     'covid19_negative_test_2:dateOfResult',
@@ -45,22 +44,24 @@ const DateAttribute = nullish(
   ])
 );
 
-const DateField = object({
+const DateSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'required']),
-  display: DateDisplay,
-  attribute: DateAttribute,
-  sources: nullish(v.literal('declaration:timestamp')),
-  datatype: nullish(v.picklist(['date', 'string'])),
-  'value-constructor': nullish(
+  display: DateDisplaySchema,
+  attribute: DateAttributeSchema,
+  sources: v.nullish(v.literal('declaration:timestamp')),
+  datatype: v.nullish(v.picklist(['date', 'string'])),
+  'value-constructor': v.nullish(
     v.picklist([
       'dilosi.interop_logic.common.get_local_date',
       'dilosi.interop_logic.common.get_local_date_time',
       'dilosi.interop_logic.common.get_local_date_time_sec',
     ])
   ),
-  value: nullish(v.string()),
-  'is-display-field': nullish(v.boolean()),
+  value: v.nullish(v.string()),
+  'is-display-field': v.nullish(v.boolean()),
 });
-export type DateFieldType = v.BaseSchema<v.Output<typeof DateField>>;
 
-export default DateField as DateFieldType;
+export type DateType = v.InferOutput<typeof DateSchema>;
+export type DateSchemaType = v.GenericSchema<DateType>;
+
+export default DateSchema as DateSchemaType;

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

@@ -1,19 +1,20 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const DocSubtitleDisplay = createFieldDisplay(
-  object({
+const DocSubtitleDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('doc_subtitle'),
   })
 );
 
-const DocSubtitle = object({
-  display: DocSubtitleDisplay,
+const DocSubtitleSchema = v.strictObject({
+  display: DocSubtitleDisplaySchema,
   'user-input-mode': v.literal('noinput'),
-  value: nullish(v.string()),
-  datatype: nullish(v.literal('string')),
+  value: v.nullish(v.string()),
+  datatype: v.nullish(v.literal('string')),
 });
-export type DocSubtitleType = v.BaseSchema<v.Output<typeof DocSubtitle>>;
 
-export default DocSubtitle as DocSubtitleType;
+export type DocSubtitleType = v.InferOutput<typeof DocSubtitleSchema>;
+export type DocSubtitleSchemaType = v.GenericSchema<DocSubtitleType>;
+
+export default DocSubtitleSchema as DocSubtitleSchemaType;

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

@@ -1,22 +1,21 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const DocTitleDisplay = createFieldDisplay(
-  object({
+const DocTitleDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('doc_title'),
   }),
-  object({
+  v.strictObject({
     component: v.literal('doc_title'),
-    'component-params': nullish(
-      object({
-        leading: nullish(v.number()),
+    'component-params': v.nullish(
+      v.strictObject({
+        leading: v.nullish(v.number()),
       })
     ),
   })
 );
 
-const DocTitleAttribute = nullish(
+const DocTitleAttributeSchema = v.nullish(
   v.picklist([
     'chosen_degree:pdf_title',
     'digital_diploma:pdfTitle',
@@ -24,15 +23,17 @@ const DocTitleAttribute = nullish(
   ])
 );
 
-const DocTitle = object({
-  display: DocTitleDisplay,
+const DocTitleSchema = v.strictObject({
+  display: DocTitleDisplaySchema,
   'user-input-mode': v.literal('noinput'),
-  value: nullish(v.string()),
-  'default-value': nullish(v.string()),
-  'value-constructor': nullish(v.string()),
-  sources: nullish(v.string()),
-  attribute: DocTitleAttribute,
+  value: v.nullish(v.string()),
+  'default-value': v.nullish(v.string()),
+  'value-constructor': v.nullish(v.string()),
+  sources: v.nullish(v.string()),
+  attribute: DocTitleAttributeSchema,
 });
-export type DocTitleType = v.BaseSchema<v.Output<typeof DocTitle>>;
 
-export default DocTitle as DocTitleType;
+export type DocTitleType = v.InferOutput<typeof DocTitleSchema>;
+export type DocTitleSchemaType = v.GenericSchema<DocTitleType>;
+
+export default DocTitleSchema as DocTitleSchemaType;

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

@@ -1,39 +1,41 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const DynamicallyFilledTextDisplay = createFieldDisplay(
-  object({
+const DynamicallyFilledTextDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('dynamically-filled-text'),
-    'component-params': nullish(
-      object({
-        fill: nullish(v.boolean()),
-        position: nullish(v.picklist(['center', 'justify', 'left', 'right'])),
-        format: nullish(v.literal('plaintext')),
-        textColor: nullish(v.string()),
-        emph: nullish(v.boolean()),
-        bold: nullish(v.boolean()),
-        cell_valign: nullish(v.string()),
-        leading: nullish(v.number()),
+    'component-params': v.nullish(
+      v.strictObject({
+        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 DynamicallyFilledText = object({
-  value: nullish(v.string()),
-  display: DynamicallyFilledTextDisplay,
+const DynamicallyFilledTextSchema = v.strictObject({
+  value: v.nullish(v.string()),
+  display: DynamicallyFilledTextDisplaySchema,
   'user-input-mode': v.picklist(['noinput', 'display']),
-  'default-value': nullish(v.string()),
-  sources: nullish(v.literal('field:page_3_year')),
-  'value-constructor': nullish(
+  'default-value': v.nullish(v.string()),
+  sources: v.nullish(v.literal('field:page_3_year')),
+  'value-constructor': v.nullish(
     v.literal('dilosi.interop_logic.metavivasi_akinitou.get_page_3_text')
   ),
-  'is-display-field': nullish(v.boolean()),
-  attribute: nullish(v.string()),
+  'is-display-field': v.nullish(v.boolean()),
+  attribute: v.nullish(v.string()),
 });
-export type DynamicallyFilledTextType = v.BaseSchema<
-  v.Output<typeof DynamicallyFilledText>
+
+export type DynamicallyFilledTextType = v.InferOutput<
+  typeof DynamicallyFilledTextSchema
 >;
+export type DynamicallyFilledTextSchemaType =
+  v.GenericSchema<DynamicallyFilledTextType>;
 
-export default DynamicallyFilledText as DynamicallyFilledTextType;
+export default DynamicallyFilledTextSchema as DynamicallyFilledTextSchemaType;

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

@@ -1,14 +1,13 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const EmailDisplay = createFieldDisplay(
-  object({
+const EmailDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('email'),
   })
 );
 
-const EmailAttribute = nullish(
+const EmailAttributeSchema = v.nullish(
   v.picklist([
     'civil_registry:email',
     'find_onomatodosia:email',
@@ -16,13 +15,15 @@ const EmailAttribute = nullish(
   ])
 );
 
-const Email = object({
+const EmailSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  display: EmailDisplay,
-  attribute: EmailAttribute,
-  'default-value': nullish(v.string()),
-  datatype: nullish(v.literal('email')),
+  display: EmailDisplaySchema,
+  attribute: EmailAttributeSchema,
+  'default-value': v.nullish(v.string()),
+  datatype: v.nullish(v.literal('email')),
 });
-export type EmailType = v.BaseSchema<v.Output<typeof Email>>;
 
-export default Email as EmailType;
+export type EmailType = v.InferOutput<typeof EmailSchema>;
+export type EmailSchemaType = v.GenericSchema<EmailType>;
+
+export default EmailSchema as EmailSchemaType;

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

@@ -1,29 +1,30 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const FillableStringDisplay = createFieldDisplay(
-  object({
+const FillableStringDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('fillable-string'),
-    'component-params': nullish(
-      object({
-        emph: nullish(v.boolean()),
+    'component-params': v.nullish(
+      v.strictObject({
+        emph: v.nullish(v.boolean()),
       })
     ),
   })
 );
 
-const FillableString = object({
+const FillableStringSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'display']),
-  display: FillableStringDisplay,
-  attribute: nullish(v.string()),
-  'default-value': nullish(v.string()),
-  'value-constructor': nullish(v.string()),
-  value: nullish(v.string()),
-  safe: nullish(v.boolean()),
-  sources: nullish(v.string()),
-  datatype: nullish(v.literal('string')),
+  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.BaseSchema<v.Output<typeof FillableString>>;
 
-export default FillableString as FillableStringType;
+export type FillableStringType = v.InferOutput<typeof FillableStringSchema>;
+export type FillableStringSchemaType = v.GenericSchema<FillableStringType>;
+
+export default FillableStringSchema as FillableStringSchemaType;

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

@@ -1,17 +1,18 @@
 import * as v from 'valibot';
-import { object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const FiveBlockDateDisplay = createFieldDisplay(
-  object({
+const FiveBlockDateDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('five-block-date'),
   })
 );
 
-const FiveBlockDate = object({
+const FiveBlockDateSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  display: FiveBlockDateDisplay,
+  display: FiveBlockDateDisplaySchema,
 });
-export type FiveBlockDateType = v.BaseSchema<v.Output<typeof FiveBlockDate>>;
 
-export default FiveBlockDate as FiveBlockDateType;
+export type FiveBlockDateType = v.InferOutput<typeof FiveBlockDateSchema>;
+export type FiveBlockDateSchemaType = v.GenericSchema<FiveBlockDateType>;
+
+export default FiveBlockDateSchema as FiveBlockDateSchemaType;

package/src/schemas/field/green-pass-qrcode/index.ts

@@ -1,28 +1,27 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const GreenPassQrcodeDisplay = createFieldDisplay(
-  object({
+const GreenPassQrcodeDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('green-pass-qrcode'),
-    'component-params': nullish(
-      object({
-        coordinates: nullish(v.array(v.nullable(v.number()))),
-        position: nullish(v.picklist(['left', 'right', 'center', 'justify'])),
-        size: nullish(v.number()),
+    'component-params': v.nullish(
+      v.strictObject({
+        coordinates: v.nullish(v.array(v.nullable(v.number()))),
+        position: v.nullish(v.picklist(['left', 'right', 'center', 'justify'])),
+        size: v.nullish(v.number()),
       })
     ),
   })
 );
 
-const GreenPassQrcode = object({
+const GreenPassQrcodeSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'display']),
-  display: GreenPassQrcodeDisplay,
+  display: GreenPassQrcodeDisplaySchema,
   datatype: v.literal('string'),
-  attribute: nullish(v.string()),
+  attribute: v.nullish(v.string()),
 });
-export type GreenPassQrcodeType = v.BaseSchema<
-  v.Output<typeof GreenPassQrcode>
->;
 
-export default GreenPassQrcode as GreenPassQrcodeType;
+export type GreenPassQrcodeType = v.InferOutput<typeof GreenPassQrcodeSchema>;
+export type GreenPassQrcodeSchemaType = v.GenericSchema<GreenPassQrcodeType>;
+
+export default GreenPassQrcodeSchema as GreenPassQrcodeSchemaType;