feat: Support constant type

Author: joshuat

docs/api/types.md

@@ -89,6 +89,38 @@ schema({
 });
 ```
 
+## `constant`
+
+Creates a constant value. Useful for creating discriminated unions with the `oneOf` type.
+
+**Parameters:**
+
+| Name               | Type             | Attribute |
+| ------------------ | ---------------- | --------- |
+| `value`            | `TValue`         | required  |
+| `options`          | `GenericOptions` | optional  |
+| `options.required` | `boolean`        | optional  |
+
+**Example:**
+
+```ts
+import { schema, types } from 'papr';
+
+schema({
+  shape: types.oneOf([
+    types.object({
+      type: types.constant('circle' as const, { required: true }),
+      radius: types.number({ required: true }),
+    }),
+    types.object({
+      type: types.constant('rectangle' as const, { required: true }),
+      width: types.number({ required: true }),
+      length: types.number({ required: true }),
+    }),
+  ]),
+});
+```
+
 ## `date`
 
 Creates a date type.

src/__tests__/types.test.ts

@@ -393,6 +393,29 @@ describe('types', () => {
       });
     });
 
+    describe('constant', () => {
+      test('default', () => {
+        const value = types.constant('foo' as const);
+
+        expect(value).toEqual({
+          enum: ['foo'],
+        });
+        expectType<'foo' | undefined>(value);
+      });
+
+      test('required', () => {
+        const value = types.constant('foo' as const, { required: true });
+
+        expect(value).toEqual({
+          enum: ['foo'],
+          $required: true,
+        });
+        expectType<'foo'>(value);
+        // @ts-expect-error `value` should not be undefined
+        expectType<typeof value>(undefined);
+      });
+    });
+
     describe('object', () => {
       test('default', () => {
         const value = types.object({

src/types.ts

@@ -136,6 +136,16 @@ function array<Item, Options extends ArrayOptions>(
   } as unknown as GetType<NonNullable<Item>[], Options>;
 }
 
+function constant<Value, Options extends GenericOptions>(
+  value: Value,
+  options?: Options
+): GetType<Value, Options> {
+  return {
+    ...(options?.required ? { $required: true } : {}),
+    enum: [value],
+  } as unknown as GetType<Value, Options>;
+}
+
 function enumType<Enum, Options extends GenericOptions>(
   values: Enum[],
   options?: Options
@@ -323,6 +333,32 @@ export default {
    */
   boolean: createSimpleType<boolean>('boolean'),
 
+  /**
+   * Creates a constant value. Useful for creating discriminated unions with the `oneOf` type.
+   *
+   * @param value {TValue}
+   * @param [options] {GenericOptions}
+   * @param [options.required] {boolean}
+   *
+   * @example
+   * import { schema, types } from 'papr';
+   *
+   * schema({
+   *   shape: types.oneOf([
+   *     types.object({
+   *       type: types.constant('circle' as const, { required: true }),
+   *       radius: types.number({ required: true }),
+   *     }),
+   *     types.object({
+   *       type: types.constant('rectangle' as const, { required: true }),
+   *       width: types.number({ required: true }),
+   *       length: types.number({ required: true }),
+   *     }),
+   *   ]),
+   * });
+   */
+  constant,
+
   /**
    * Creates a date type.
    *