@uides/stepwise 1.1.0-d0adc9fb → 2.0.0-07ee8440

package/src/schemas/field/index.ts

@@ -1,47 +1,77 @@
 import * as v from 'valibot';
-import {
-  DisplayLang,
-  DisplayMode,
-  specialWithNestedSchema,
-} from '@uides/stepwise/schemas/common';
-import Afm from '@uides/stepwise/schemas/field/afm';
-import Amka from '@uides/stepwise/schemas/field/amka';
-import Attachment from '@uides/stepwise/schemas/field/attachment';
-import Captcha from '@uides/stepwise/schemas/field/captcha';
-import Choice from '@uides/stepwise/schemas/field/choice';
+import { DisplayLang, DisplayModeSchema } from '@uides/stepwise/schemas/common';
+import Afm, { AfmType } from '@uides/stepwise/schemas/field/afm';
+import Amka, { AmkaType } from '@uides/stepwise/schemas/field/amka';
+import Attachment, {
+  AttachmentType,
+} from '@uides/stepwise/schemas/field/attachment';
+import Captcha, { CaptchaType } from '@uides/stepwise/schemas/field/captcha';
+import Choice, { ChoiceType } from '@uides/stepwise/schemas/field/choice';
 import { DisplayModeAndLangSchema } from '@uides/stepwise/schemas/field/common';
-import DateField from '@uides/stepwise/schemas/field/date';
-import DocSubtitle from '@uides/stepwise/schemas/field/doc_subtitle';
-import DocTitle from '@uides/stepwise/schemas/field/doc_title';
-import DynamicallyFilledText from '@uides/stepwise/schemas/field/dynamically-filled-text';
-import Email from '@uides/stepwise/schemas/field/email';
-import FillableString from '@uides/stepwise/schemas/field/fillable-string';
-import FiveBlockDate from '@uides/stepwise/schemas/field/five-block-date';
-import GreenPassQrcode from '@uides/stepwise/schemas/field/green-pass-qrcode';
-import Hidden from '@uides/stepwise/schemas/field/hidden';
-import HierarchicalSelector from '@uides/stepwise/schemas/field/hierarchical-selector';
-import Iban from '@uides/stepwise/schemas/field/iban';
-import Image from '@uides/stepwise/schemas/field/image';
-import Int from '@uides/stepwise/schemas/field/int';
-import LabResults from '@uides/stepwise/schemas/field/lab-results';
-import LandlinePhone from '@uides/stepwise/schemas/field/landline_phone';
-import MobilePhone from '@uides/stepwise/schemas/field/mobile_phone';
-import MultipleChoice from '@uides/stepwise/schemas/field/multiple-choice';
-import PdfImage from '@uides/stepwise/schemas/field/pdf-image';
-import PostalCode from '@uides/stepwise/schemas/field/postal_code';
-import Qrcode from '@uides/stepwise/schemas/field/qrcode';
-import Quote from '@uides/stepwise/schemas/field/quote';
-import RadioChoice from '@uides/stepwise/schemas/field/radio-choice';
-import Rate from '@uides/stepwise/schemas/field/rate';
-import Recipient from '@uides/stepwise/schemas/field/recipient';
-import Redirect from '@uides/stepwise/schemas/field/redirect';
-import Refcode from '@uides/stepwise/schemas/field/refcode';
-import StringField from '@uides/stepwise/schemas/field/string';
-import Text from '@uides/stepwise/schemas/field/text';
-import ThreeBlockDate from '@uides/stepwise/schemas/field/three-block-date';
+import DateField, { DateType } from '@uides/stepwise/schemas/field/date';
+import DocSubtitle, {
+  DocSubtitleType,
+} from '@uides/stepwise/schemas/field/doc_subtitle';
+import DocTitle, {
+  DocTitleType,
+} from '@uides/stepwise/schemas/field/doc_title';
+import DynamicallyFilledText, {
+  DynamicallyFilledTextType,
+} from '@uides/stepwise/schemas/field/dynamically-filled-text';
+import Email, { EmailType } from '@uides/stepwise/schemas/field/email';
+import FillableString, {
+  FillableStringType,
+} from '@uides/stepwise/schemas/field/fillable-string';
+import FiveBlockDate, {
+  FiveBlockDateType,
+} from '@uides/stepwise/schemas/field/five-block-date';
+import GreenPassQrcode, {
+  GreenPassQrcodeType,
+} from '@uides/stepwise/schemas/field/green-pass-qrcode';
+import Hidden, { HiddenType } from '@uides/stepwise/schemas/field/hidden';
+import HierarchicalSelector, {
+  HierarchicalSelectorType,
+} from '@uides/stepwise/schemas/field/hierarchical-selector';
+import Iban, { IbanType } from '@uides/stepwise/schemas/field/iban';
+import Image, { ImageType } from '@uides/stepwise/schemas/field/image';
+import Int, { IntType } from '@uides/stepwise/schemas/field/int';
+import LabResults, {
+  LabResultsType,
+} from '@uides/stepwise/schemas/field/lab-results';
+import LandlinePhone, {
+  LandlinePhoneType,
+} from '@uides/stepwise/schemas/field/landline_phone';
+import MobilePhone, {
+  MobilePhoneType,
+} from '@uides/stepwise/schemas/field/mobile_phone';
+import MultipleChoice, {
+  MultipleChoiceType,
+} from '@uides/stepwise/schemas/field/multiple-choice';
+import PdfImage, {
+  PdfImageType,
+} from '@uides/stepwise/schemas/field/pdf-image';
+import PostalCode, {
+  PostalCodeType,
+} from '@uides/stepwise/schemas/field/postal_code';
+import Qrcode, { QrcodeType } from '@uides/stepwise/schemas/field/qrcode';
+import Quote, { QuoteType } from '@uides/stepwise/schemas/field/quote';
+import RadioChoice, {
+  RadioChoiceType,
+} from '@uides/stepwise/schemas/field/radio-choice';
+import Rate, { RateType } from '@uides/stepwise/schemas/field/rate';
+import Recipient, {
+  RecipientType,
+} from '@uides/stepwise/schemas/field/recipient';
+import Redirect, { RedirectType } from '@uides/stepwise/schemas/field/redirect';
+import Refcode, { RefcodeType } from '@uides/stepwise/schemas/field/refcode';
+import StringField, { StringType } from '@uides/stepwise/schemas/field/string';
+import Text, { TextType } from '@uides/stepwise/schemas/field/text';
+import ThreeBlockDate, {
+  ThreeBlockDateType,
+} from '@uides/stepwise/schemas/field/three-block-date';
 import { resolveDisplay } from '@uides/stepwise/schemas/resolve';
 
-const fieldOptions = {
+const allFieldSchemas = {
   afm: Afm,
   amka: Amka,
   attachment: Attachment,
@@ -77,25 +107,45 @@ const fieldOptions = {
   text: Text,
   'three-block-date': ThreeBlockDate,
 };
-type FieldOptions = (typeof fieldOptions)[keyof typeof fieldOptions];
 
-const Field = specialWithNestedSchema<v.Output<FieldOptions>>(
-  (field) => {
-    const { display, ...fieldAttrs } = field;
+const FieldSchema = v.pipe(
+  v.record(v.string(), v.any()), // TODO: Unnecessary?
+  v.rawCheck<Field>(({ dataset, addIssue }) => {
+    const { display, ...fieldAttrs } = dataset.value as Record<string, any>;
     if (!display) {
-      const result = fieldOptions['string']._parse(fieldAttrs);
-      return result.issues;
+      const result = v.safeParse(allFieldSchemas['string'], fieldAttrs);
+      // TODO: DRY
+      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;
     }
-    let issues: v.SchemaIssues | undefined;
     const result = v.safeParse(DisplayModeAndLangSchema, display);
     if (result.issues) {
-      issues?.push(...result.issues);
-    }
-    if (!issues) {
-      issues = 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',
+        });
+      });
     }
-    DisplayMode.options.forEach((displayMode) => {
-      if (!display[displayMode]) return;
+    DisplayModeSchema.options.forEach((displayMode) => {
+      if (!(display && display[displayMode])) return;
       Object.keys(display[displayMode] as NonNullable<unknown>).forEach(
         (displayLang) => {
           const resolvedDisplay = resolveDisplay(
@@ -118,41 +168,82 @@ const Field = specialWithNestedSchema<v.Output<FieldOptions>>(
           };
 
           const component = resolvedDisplay?.['component'] ?? 'string';
-          const result =
-            fieldOptions[component as keyof typeof fieldOptions]._parse(
-              fieldToValidate
-            );
+          const result = v.safeParse(
+            allFieldSchemas[component as keyof typeof allFieldSchemas],
+            fieldToValidate
+          );
           if (result.issues) {
-            issues?.push(...result.issues);
-          }
-          if (!issues) {
-            issues = 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;
-  },
-  [
-    v.custom((values) => {
-      if (!('value' in values)) return true;
-      const value = values.value;
-      const userInputMode = values['user-input-mode'];
-      if (
-        value &&
-        !(userInputMode === 'noinput' || userInputMode === 'display')
-      ) {
-        return false;
-      }
-      return true;
-    }, 'Field with value cannot be editable'),
-  ]
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-) as any;
-export default Field as FieldOptions;
+  }),
+  v.check((values) => {
+    if (!('value' in values)) return true;
+    const value = values['value'];
+    const userInputMode = values['user-input-mode'];
+    if (
+      value &&
+      !(userInputMode === 'noinput' || userInputMode === 'display')
+    ) {
+      return false;
+    }
+    return true;
+  }, 'Field with value cannot be editable')
+);
+
+export default FieldSchema;
+
+export type Field =
+  | AfmType
+  | AmkaType
+  | AttachmentType
+  | CaptchaType
+  | ChoiceType
+  | DateType
+  | DocSubtitleType
+  | DocTitleType
+  | DynamicallyFilledTextType
+  | EmailType
+  | FillableStringType
+  | FiveBlockDateType
+  | GreenPassQrcodeType
+  | HiddenType
+  | HierarchicalSelectorType
+  | IbanType
+  | ImageType
+  | IntType
+  | LabResultsType
+  | LandlinePhoneType
+  | MobilePhoneType
+  | MultipleChoiceType
+  | PdfImageType
+  | PostalCodeType
+  | QrcodeType
+  | QuoteType
+  | RadioChoiceType
+  | RateType
+  | RecipientType
+  | RedirectType
+  | RefcodeType
+  | StringType
+  | TextType
+  | ThreeBlockDateType;
+
+export type Fields = Record<string, Field>;
 
-export type Fields = Record<
-  string,
-  NonNullable<FieldOptions['_types']>['input']
->;
-export const FieldsSchema = v.record(Field) as v.BaseSchema<Fields, Fields>;
+export const FieldsSchema = v.record(
+  v.string(),
+  FieldSchema
+) as v.GenericSchema<Fields>;

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

@@ -1,23 +1,24 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const IntDisplay = createFieldDisplay(
-  object({
+const IntDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('int'),
-    'component-params': nullish(
-      object({
+    'component-params': v.nullish(
+      v.strictObject({
         enforceUppercase: v.boolean(),
       })
     ),
   })
 );
 
-const Int = object({
+const IntSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  display: IntDisplay,
-  'default-value': nullish(v.string()),
+  display: IntDisplaySchema,
+  'default-value': v.nullish(v.string()),
 });
-export type IntType = v.BaseSchema<v.Output<typeof Int>>;
 
-export default Int as IntType;
+export type IntType = v.InferOutput<typeof IntSchema>;
+export type IntSchemaType = v.GenericSchema<IntType>;
+
+export default IntSchema as IntSchemaType;

package/src/schemas/field/lab-results/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 LabResultsDisplay = createFieldDisplay(
-  object({
+const LabResultsDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('lab-results'),
   })
 );
 
-const LabResults = object({
+const LabResultsSchema = v.strictObject({
   'user-input-mode': v.literal('noinput'),
-  display: LabResultsDisplay,
-  'default-value': nullish(v.string()),
+  display: LabResultsDisplaySchema,
+  'default-value': v.nullish(v.string()),
   attribute: v.string(),
 });
-export type LabResultsType = v.BaseSchema<v.Output<typeof LabResults>>;
 
-export default LabResults as LabResultsType;
+export type LabResultsType = v.InferOutput<typeof LabResultsSchema>;
+export type LabResultsSchemaType = v.GenericSchema<LabResultsType>;
+
+export default LabResultsSchema as LabResultsSchemaType;

package/src/schemas/field/landline_phone/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 LandlinePhoneDisplay = createFieldDisplay(
-  object({
+const LandlinePhoneDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('landline_phone'),
   })
 );
 
-const LandlinePhone = object({
+const LandlinePhoneSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional']),
-  display: LandlinePhoneDisplay,
+  display: LandlinePhoneDisplaySchema,
 });
-export type LandlinePhoneType = v.BaseSchema<v.Output<typeof LandlinePhone>>;
 
-export default LandlinePhone as LandlinePhoneType;
+export type LandlinePhoneType = v.InferOutput<typeof LandlinePhoneSchema>;
+export type LandlinePhoneSchemaType = v.GenericSchema<LandlinePhoneType>;
+
+export default LandlinePhoneSchema as LandlinePhoneSchemaType;

package/src/schemas/field/mobile_phone/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 MobilePhoneDisplay = createFieldDisplay(
-  object({
+const MobilePhoneDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('mobile_phone'),
   })
 );
 
-const MobilePhoneAttribute = nullish(
+const MobilePhoneAttributeSchema = v.nullish(
   v.picklist([
     'civil_registry:mobile',
     'find_onomatodosia:mobile_phone',
@@ -19,13 +18,15 @@ const MobilePhoneAttribute = nullish(
   ])
 );
 
-const MobilePhone = object({
+const MobilePhoneSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  attribute: MobilePhoneAttribute,
-  display: MobilePhoneDisplay,
-  'default-value': nullish(v.string()),
-  datatype: nullish(v.literal('mobile_phone')),
+  attribute: MobilePhoneAttributeSchema,
+  display: MobilePhoneDisplaySchema,
+  'default-value': v.nullish(v.string()),
+  datatype: v.nullish(v.literal('mobile_phone')),
 });
-export type MobilePhoneType = v.BaseSchema<v.Output<typeof MobilePhone>>;
 
-export default MobilePhone as MobilePhoneType;
+export type MobilePhoneType = v.InferOutput<typeof MobilePhoneSchema>;
+export type MobilePhoneSchemaType = v.GenericSchema<MobilePhoneType>;
+
+export default MobilePhoneSchema as MobilePhoneSchemaType;

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

@@ -1,28 +1,29 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const MultipleChoiceDisplay = createFieldDisplay(
-  object({
+const MultipleChoiceDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('multiple-choice'),
-    choices: v.record(v.string()),
+    choices: v.record(v.string(), v.string()),
     'choices-order': v.string(),
-    'component-params': nullish(
-      object({
-        'legacy-mode': nullish(v.boolean()),
-        showcase: nullish(v.picklist(['comma_separated', 'one_per_line'])),
+    'component-params': v.nullish(
+      v.strictObject({
+        'legacy-mode': v.nullish(v.boolean()),
+        showcase: v.nullish(v.picklist(['comma_separated', 'one_per_line'])),
       })
     ),
   })
 );
 
-const MultipleChoice = object({
+const MultipleChoiceSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  display: MultipleChoiceDisplay,
-  'default-value': nullish(v.string()),
+  display: MultipleChoiceDisplaySchema,
+  'default-value': v.nullish(v.string()),
   attribute: v.optional(v.null_()),
-  datatype: nullish(v.picklist(['multiple-choice', 'string'])),
+  datatype: v.nullish(v.picklist(['multiple-choice', 'string'])),
 });
-export type MultipleChoiceType = v.BaseSchema<v.Output<typeof MultipleChoice>>;
 
-export default MultipleChoice as MultipleChoiceType;
+export type MultipleChoiceType = v.InferOutput<typeof MultipleChoiceSchema>;
+export type MultipleChoiceSchemaType = v.GenericSchema<MultipleChoiceType>;
+
+export default MultipleChoiceSchema as MultipleChoiceSchemaType;

package/src/schemas/field/pdf-image/index.ts

@@ -1,20 +1,19 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 import { createFieldDisplay } from '@uides/stepwise/schemas/field/common';
 
-const PdfImageDisplay = createFieldDisplay(
-  object({
+const PdfImageDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('pdf-image'),
-    'component-params': nullish(
-      object({
+    'component-params': v.nullish(
+      v.strictObject({
         coordinates: v.array(v.nullable(v.number())),
-        position: nullish(v.picklist(['left', 'right', 'center', 'justify'])),
+        position: v.nullish(v.picklist(['left', 'right', 'center', 'justify'])),
       })
     ),
   })
 );
 
-const PdfImageValue = v.picklist([
+const PdfImageValueSchema = v.picklist([
   'amea_footer_1_pdf',
   'amea_opeka_logo_pdf',
   'daktylios_backgroud_pdf',
@@ -28,12 +27,14 @@ const PdfImageValue = v.picklist([
   'AADE_logo_small_pdf',
 ]);
 
-const PdfImage = object({
-  display: PdfImageDisplay,
-  value: PdfImageValue,
+const PdfImageSchema = v.strictObject({
+  display: PdfImageDisplaySchema,
+  value: PdfImageValueSchema,
   'user-input-mode': v.picklist(['noinput', 'display']),
-  datatype: nullish(v.literal('string')),
+  datatype: v.nullish(v.literal('string')),
 });
-export type PdfImageType = v.BaseSchema<v.Output<typeof PdfImage>>;
 
-export default PdfImage as PdfImageType;
+export type PdfImageType = v.InferOutput<typeof PdfImageSchema>;
+export type PdfImageSchemaType = v.GenericSchema<PdfImageType>;
+
+export default PdfImageSchema as PdfImageSchemaType;

package/src/schemas/field/postal_code/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 PostalCodeDisplay = createFieldDisplay(
-  object({
+const PostalCodeDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('postal_code'),
   })
 );
 
-const PostalCode = object({
+const PostalCodeSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'optional', 'required']),
-  display: PostalCodeDisplay,
-  datatype: nullish(v.literal('postal_code')),
+  display: PostalCodeDisplaySchema,
+  datatype: v.nullish(v.literal('postal_code')),
   attribute: v.optional(v.null_()),
 });
-export type PostalCodeType = v.BaseSchema<v.Output<typeof PostalCode>>;
 
-export default PostalCode as PostalCodeType;
+export type PostalCodeType = v.InferOutput<typeof PostalCodeSchema>;
+export type PostalCodeSchemaType = v.GenericSchema<PostalCodeType>;
+
+export default PostalCodeSchema as PostalCodeSchemaType;

package/src/schemas/field/qrcode/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 QrcodeDisplay = createFieldDisplay(
-  object({
+const QrcodeDisplaySchema = createFieldDisplay(
+  v.strictObject({
     component: v.literal('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 Qrcode = object({
+const QrcodeSchema = v.strictObject({
   'user-input-mode': v.picklist(['noinput', 'display']),
-  display: QrcodeDisplay,
-  attribute: nullish(v.string()),
-  sources: nullish(v.string()),
-  value: nullish(v.string()),
-  'value-constructor': nullish(v.string()),
-  'is-display-field': nullish(v.boolean()),
+  display: QrcodeDisplaySchema,
+  attribute: v.nullish(v.string()),
+  sources: v.nullish(v.string()),
+  value: v.nullish(v.string()),
+  'value-constructor': v.nullish(v.string()),
+  'is-display-field': v.nullish(v.boolean()),
 });
-export type QrcodeType = v.BaseSchema<v.Output<typeof Qrcode>>;
 
-export default Qrcode as QrcodeType;
+export type QrcodeType = v.InferOutput<typeof QrcodeSchema>;
+export type QrcodeSchemaType = v.GenericSchema<QrcodeType>;
+
+export default QrcodeSchema as QrcodeSchemaType;