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

package/src/schemas/action.ts

@@ -1,129 +1,127 @@
 import * as v from 'valibot';
 import {
-  DisplayLang,
-  DisplayMode,
-  nullish,
-  object,
+  DisplayLangSchema,
+  DisplayModeSchema,
 } from '@uides/stepwise/schemas/common';
 
-const RetrySpec = object({
+const RetrySpecSchema = v.strictObject({
   retry_limit: v.number(),
   retry_delay: v.number(),
 });
 
-const PollSpec = object({
-  retry: RetrySpec,
+const PollSpecSchema = v.strictObject({
+  retry: RetrySpecSchema,
   id_field: v.string(),
   endpoint: v.string(),
 });
 
-const ActionDisplayBase = object({
+const ActionDisplayBaseSchema = v.strictObject({
   /** The text to display on the button */
-  label: nullish(v.string()),
-  icon: nullish(v.string()),
+  label: v.nullish(v.string()),
+  icon: v.nullish(v.string()),
   /** The explanatory title of the action */
-  title: nullish(v.string()),
+  title: v.nullish(v.string()),
   /** An explanatory subtitle for the action */
-  helptext: nullish(v.string()),
+  helptext: v.nullish(v.string()),
   /**
    * Whether it is considered a primary action
    *
    * This also determines the styling of the action button
    */
-  primary: nullish(v.boolean()),
-  url: nullish(v.string()),
+  primary: v.nullish(v.boolean()),
+  url: v.nullish(v.string()),
   /** @default false */
-  self: nullish(v.boolean()),
+  self: v.nullish(v.boolean()),
   /**
    * Confirmation dialog title
    *
    * Title of dialog to display when the user clicks on the action button
    */
-  confirm_title: nullish(v.string()),
+  confirm_title: v.nullish(v.string()),
   /**
    * Confirmation dialog description
    *
    * Description of dialog to display when the user clicks on the action button
    */
-  confirm_message: nullish(v.string()),
+  confirm_message: v.nullish(v.string()),
   /**
    * Confirmation dialog 'confirm' button label
    *
    * Label of 'confirm' button included in dialog displayed when the user clicks on the action button
    */
-  confirm_confirm_label: nullish(v.string()),
+  confirm_confirm_label: v.nullish(v.string()),
   /**
    * Confirmation dialog 'cancel' button label
    *
    * Label of 'cancel' button included in dialog displayed when the user clicks on the action button
    */
-  confirm_cancel_label: nullish(v.string()),
-  warning: nullish(v.boolean()),
-  autocall: nullish(v.boolean()),
-  retry: nullish(RetrySpec),
-  poll: nullish(PollSpec),
+  confirm_cancel_label: v.nullish(v.string()),
+  warning: v.nullish(v.boolean()),
+  autocall: v.nullish(v.boolean()),
+  retry: v.nullish(RetrySpecSchema),
+  poll: v.nullish(PollSpecSchema),
 });
 
 function createActionDisplay<T extends v.ObjectEntries>(
-  Display: v.ObjectSchema<T, v.NeverSchema>
+  Display: v.StrictObjectSchema<T, undefined>
 ) {
   return v.record(
-    DisplayMode,
+    DisplayModeSchema,
     v.record(
-      DisplayLang,
-      v.object(
-        { ...v.partial(Display).entries, ...ActionDisplayBase.entries },
-        v.unknown()
-      )
+      DisplayLangSchema,
+      v.looseObject({
+        ...v.partial(Display).entries,
+        ...ActionDisplayBaseSchema.entries,
+      })
     )
   );
 }
 
-export const TemporarySave = object({
+export const TemporarySaveSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-temporary-save'),
     })
   ),
 });
-export type TemporarySave = v.Output<typeof TemporarySave>;
+export type TemporarySave = v.InferOutput<typeof TemporarySaveSchema>;
 
-export const Pdf = object({
+export const PdfSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-download-pdf'),
     })
   ),
-  'component-params': nullish(
-    object({
+  'component-params': v.nullish(
+    v.strictObject({
       filename: v.string(),
-      sign: nullish(v.boolean()),
+      sign: v.nullish(v.boolean()),
     })
   ),
 });
-export type Pdf = v.Output<typeof Pdf>;
+export type Pdf = v.InferOutput<typeof PdfSchema>;
 
-export const ResendOtp = object({
+export const ResendOtpSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-resend-otp'),
     })
   ),
 });
-export type ResendOtp = v.Output<typeof ResendOtp>;
+export type ResendOtp = v.InferOutput<typeof ResendOtpSchema>;
 
-export const Cancel = object({
+export const CancelSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-dismiss'),
     })
   ),
 });
-export type Cancel = v.Output<typeof Cancel>;
+export type Cancel = v.InferOutput<typeof CancelSchema>;
 
-export const Update = object({
+export const UpdateSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.picklist([
         'document-update',
         'document-collect',
@@ -131,171 +129,171 @@ export const Update = object({
       ]),
     })
   ),
-  'component-params': nullish(
-    object({
-      issue: nullish(v.boolean()),
-      mark_submitting: nullish(v.boolean()),
-      'ensure-no-input': nullish(v.boolean()),
+  'component-params': v.nullish(
+    v.strictObject({
+      issue: v.nullish(v.boolean()),
+      mark_submitting: v.nullish(v.boolean()),
+      'ensure-no-input': v.nullish(v.boolean()),
     })
   ),
 });
-export type Update = v.Output<typeof Update>;
+export type Update = v.InferOutput<typeof UpdateSchema>;
 
-export const Create = object({
+export const CreateSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-create'),
     })
   ),
 });
-export type Create = v.Output<typeof Create>;
+export type Create = v.InferOutput<typeof CreateSchema>;
 
-export const AnonCreate = object({
+export const AnonCreateSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-anon-create'),
     })
   ),
 });
-export type AnonCreate = v.Output<typeof AnonCreate>;
+export type AnonCreate = v.InferOutput<typeof AnonCreateSchema>;
 
-export const Revoke = object({
+export const RevokeSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-revoke'),
     })
   ),
-  'component-params': nullish(
-    object({
+  'component-params': v.nullish(
+    v.strictObject({
       next_step: v.string(),
     })
   ),
 });
-export type Revoke = v.Output<typeof Revoke>;
+export type Revoke = v.InferOutput<typeof RevokeSchema>;
 
-export const Share = object({
+export const ShareSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-share'),
     })
   ),
 });
-export type Share = v.Output<typeof Share>;
+export type Share = v.InferOutput<typeof ShareSchema>;
 
-export const Email = object({
+export const EmailSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-email'),
     })
   ),
-  'component-params': nullish(
-    object({
+  'component-params': v.nullish(
+    v.strictObject({
       template: v.string(),
       email_field: v.string(),
       subject: v.string(),
     })
   ),
 });
-export type Email = v.Output<typeof Email>;
+export type Email = v.InferOutput<typeof EmailSchema>;
 
-export const Sms = object({
+export const SmsSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-sms'),
     })
   ),
-  'component-params': nullish(
-    object({
+  'component-params': v.nullish(
+    v.strictObject({
       sms_field: v.string(),
       template: v.string(),
     })
   ),
 });
-export type Sms = v.Output<typeof Sms>;
+export type Sms = v.InferOutput<typeof SmsSchema>;
 
-export const Communication = object({
+export const CommunicationSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('entity-send-message'),
     })
   ),
-  'component-params': nullish(
-    object({
+  'component-params': v.nullish(
+    v.strictObject({
       'contact-phone-field': v.string(),
       'contact-email-field': v.string(),
-      'message-subject': nullish(v.string()),
+      'message-subject': v.nullish(v.string()),
     })
   ),
 });
-export type Communication = v.Output<typeof Communication>;
+export type Communication = v.InferOutput<typeof CommunicationSchema>;
 
-export const Forward = object({
+export const ForwardSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('entity-forward'),
     })
   ),
-  'component-params': nullish(
-    object({
-      notify_user: nullish(v.boolean()),
-      'message-subject': nullish(v.string()),
-      message: nullish(v.string()),
+  'component-params': v.nullish(
+    v.strictObject({
+      notify_user: v.nullish(v.boolean()),
+      'message-subject': v.nullish(v.string()),
+      message: v.nullish(v.string()),
     })
   ),
 });
-export type Forward = v.Output<typeof Forward>;
+export type Forward = v.InferOutput<typeof ForwardSchema>;
 
-export const AuthorizedPdf = object({
+export const AuthorizedPdfSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('entity-print-pdf'),
     })
   ),
 });
-export type AuthorizedPdf = v.Output<typeof AuthorizedPdf>;
+export type AuthorizedPdf = v.InferOutput<typeof AuthorizedPdfSchema>;
 
-export const Reply = object({
+export const ReplySchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.picklist(['entity-reply', 'hidden']),
     })
   ),
-  'component-params': nullish(
-    object({
-      'reply-templates': v.record(v.any()), // TODO: Replace any with actual type
+  'component-params': v.nullish(
+    v.strictObject({
+      'reply-templates': v.record(v.string(), v.any()), // TODO: Replace any with actual type
     })
   ),
 });
-export type Reply = v.Output<typeof Reply>;
+export type Reply = v.InferOutput<typeof ReplySchema>;
 
-export const WebPrint = object({
+export const WebPrintSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('web-print'),
     })
   ),
 });
-export type WebPrint = v.Output<typeof WebPrint>;
+export type WebPrint = v.InferOutput<typeof WebPrintSchema>;
 
-export const NewDeclOrTempSavePreview = object({
+export const NewDeclOrTempSavePreviewSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('link'),
     })
   ),
 });
-export type NewDeclOrTempSavePreview = v.Output<
-  typeof NewDeclOrTempSavePreview
+export type NewDeclOrTempSavePreview = v.InferOutput<
+  typeof NewDeclOrTempSavePreviewSchema
 >;
 
-export const Backstep = object({
+export const BackstepSchema = v.strictObject({
   display: createActionDisplay(
-    object({
+    v.strictObject({
       component: v.literal('document-backstep'),
     })
   ),
 });
-export type Backstep = v.Output<typeof Backstep>;
+export type Backstep = v.InferOutput<typeof BackstepSchema>;
 
 /**
  * Describes the action that can be performed on a step
@@ -303,28 +301,31 @@ export type Backstep = v.Output<typeof Backstep>;
  * An action is usually translated as a button in the UI, which the user can click
  * to perform an action, like downloading a PDF or going to the next step.
  */
-export const Action = v.variant('display', [
-  TemporarySave,
-  Pdf,
-  ResendOtp,
-  Cancel,
-  Update,
-  Create,
-  AnonCreate,
-  Revoke,
-  Share,
-  Email,
-  Sms,
-  Communication,
-  Forward,
-  AuthorizedPdf,
-  Reply,
-  WebPrint,
-  NewDeclOrTempSavePreview,
-  Backstep,
+export const ActionSchema = v.variant('display', [
+  TemporarySaveSchema,
+  PdfSchema,
+  ResendOtpSchema,
+  CancelSchema,
+  UpdateSchema,
+  CreateSchema,
+  AnonCreateSchema,
+  RevokeSchema,
+  ShareSchema,
+  EmailSchema,
+  SmsSchema,
+  CommunicationSchema,
+  ForwardSchema,
+  AuthorizedPdfSchema,
+  ReplySchema,
+  WebPrintSchema,
+  NewDeclOrTempSavePreviewSchema,
+  BackstepSchema,
 ]);
-export type Action = v.Output<typeof Action>;
+export type Action = v.InferOutput<typeof ActionSchema>;
 export default Action;
 
 export type Actions = Record<string, Action>;
-export const ActionsSchema = v.record(Action) as v.BaseSchema<Actions, Actions>;
+export const ActionsSchema = v.record(
+  v.string(),
+  ActionSchema
+) as v.GenericSchema<Actions, Actions>;

package/src/schemas/application.ts

@@ -1,10 +1,9 @@
 import * as v from 'valibot';
-import { nullish, object } from '@uides/stepwise/schemas/common';
 
 /**
  * As defined in application_data_schema.py
  */
-export const ApplicationDataSpec = object({
+export const ApplicationDataSpecSchema = v.strictObject({
   application_name: v.string(),
   key_schema: v.any(),
   data_schema: v.any(),
@@ -13,10 +12,10 @@ export const ApplicationDataSpec = object({
 /**
  * As defined in application_schema.py
  */
-export const ApplicationSpec = object({
-  TEMPLATES: nullish(v.any()),
-  DATASETS: nullish(v.any()),
-  CLAIMS: nullish(v.any()),
-  RESOURCES: nullish(v.any()),
-  APPLICATION_DATA: nullish(v.any()),
+export const ApplicationSpecSchema = v.strictObject({
+  TEMPLATES: v.nullish(v.any()),
+  DATASETS: v.nullish(v.any()),
+  CLAIMS: v.nullish(v.any()),
+  RESOURCES: v.nullish(v.any()),
+  APPLICATION_DATA: v.nullish(v.any()),
 });

package/src/schemas/attributes.ts

@@ -14,7 +14,7 @@ import * as v from 'valibot';
  * @value 'mobile_certified_login' Mobile certified login.
  * @value 'mobile_certified_nnc' Mobile certified NNC.
  */
-export const Attribute = v.picklist([
+export const AttributeSchema = v.picklist([
   'firstname',
   'surname',
   'afm',

package/src/schemas/common.ts

@@ -1,11 +1,11 @@
 import * as v from 'valibot';
 
-export const DisplayLang = v.picklist(['default', 'el', 'en', 'fr']);
-export type DisplayLang = v.Output<typeof DisplayLang>;
+export const DisplayLangSchema = v.picklist(['default', 'el', 'en', 'fr']);
+export type DisplayLang = v.InferOutput<typeof DisplayLangSchema>;
 
-export const DisplayMode = v.picklist(['default', 'web', 'pdf']);
-export type DisplayMode = v.Output<typeof DisplayMode>;
-export const Font = v.picklist([
+export const DisplayModeSchema = v.picklist(['default', 'web', 'pdf']);
+export type DisplayMode = v.InferOutput<typeof DisplayModeSchema>;
+export const FontSchema = v.picklist([
   'Font-Regular',
   'Font-Bold',
   'Font-Mono',
@@ -14,89 +14,22 @@ export const Font = v.picklist([
   'OpenSans-Light',
 ]);
 
-export const ComponentLayout = object({
-  grid: nullish(v.boolean()),
-  xs: nullish(v.string()),
-  sm: nullish(v.string()),
-  md: nullish(v.string()),
-  lg: nullish(v.string()),
-  xl: nullish(v.string()),
+export const ComponentLayoutSchema = v.strictObject({
+  grid: v.nullish(v.boolean()),
+  xs: v.nullish(v.string()),
+  sm: v.nullish(v.string()),
+  md: v.nullish(v.string()),
+  lg: v.nullish(v.string()),
+  xl: v.nullish(v.string()),
 });
 
-export function nullish<TWrapped extends v.BaseSchema>(
-  wrapped: TWrapped
-): v.OptionalSchema<v.NullableSchema<TWrapped>> {
-  return v.optional(v.nullable(wrapped));
-}
-
-export function object<TEntries extends v.ObjectEntries>(
-  entries: TEntries,
-  pipe?: v.Pipe<v.ObjectOutput<TEntries, undefined>>
-): v.ObjectSchema<TEntries, v.NeverSchema> {
-  return v.object(entries, v.never(), pipe);
-}
-
-type FieldValidation<TInput> = v.BaseValidation<TInput> & {
-  /**
-   * The validation type.
-   */
-  type: 'field-validation';
-  /**
-   * The validated field.
-   */
-  field: keyof TInput;
-  /**
-   * The validation function.
-   */
-  requirement: (input: TInput) => boolean;
-};
-
 // TODO: Allow for custom error message
 export function validateField<TInput, TKey extends keyof TInput>(
   key: TKey,
   callback: (v: TInput[TKey], values: TInput) => boolean
-): FieldValidation<TInput> {
-  const customValidationResult = v.custom<TInput>((values) => {
+) {
+  return v.check((values: TInput) => {
     const value = values[key];
     return callback(value, values);
-  });
-  return {
-    ...customValidationResult,
-    message: `Invalid field '${key.toString()}'`,
-    type: 'field-validation',
-    field: key,
-  };
-}
-
-export interface SpecialSchemaWithNestedSchema<TInput, TOutput = TInput>
-  extends v.BaseSchema<TInput, TOutput> {
-  /** The schema type. */
-  type: 'special';
-  /** The type check function. */
-  check: (input: TInput) => v.SchemaIssues | undefined;
-  /** The error message. */
-  message: v.ErrorMessage | undefined;
-  /** The validation and transformation pipeline. */
-  pipe: v.Pipe<TInput> | undefined;
-}
-
-export function specialWithNestedSchema<TInput>(
-  check: (input: TInput) => v.SchemaIssues | undefined,
-  arg2?: v.Pipe<TInput> | v.ErrorMessage,
-  arg3?: v.Pipe<TInput>
-): SpecialSchemaWithNestedSchema<TInput> {
-  const [message, pipe] = v.defaultArgs(arg2, arg3);
-
-  return {
-    type: 'special',
-    expects: 'unknown',
-    async: false,
-    check,
-    message,
-    pipe,
-    _parse(input, config) {
-      const issues = this.check(input as TInput);
-      return v.pipeResult(this, input as TInput, config, issues);
-    },
-  };
+  }, `Invalid field '${key.toString()}'`);
 }