How to use optimal - 10 common examples

{
        appName: string()
          .required()
          .notEmpty()
          .match(APP_NAME_PATTERN),
        appPath: string()
          .required()
          .notEmpty(),
        argOptions: object(),
        configBlueprint: object(),
        configName: string().custom(value => {
          if (value && !value.match(CONFIG_NAME_PATTERN)) {
            throw new Error('Config file name must be camel case without extension.');
          }
        }),
        footer: string(),
        header: string(),
        root: string(process.cwd()),
        scoped: bool(),
        settingsBlueprint: object(),
        workspaceRoot: string(),
      },
      {
        name: this.constructor.name,
      },
    );

    this.appPath = Path.resolve(this.options.appPath);
    this.rootPath = Path.resolve(this.options.root);

    // Set environment variables
    env('DEBUG_GLOBAL_NAMESPACE', this.options.appName);

.required()
          .notEmpty()
          .match(APP_NAME_PATTERN),
        appPath: string()
          .required()
          .notEmpty(),
        argOptions: object(),
        configBlueprint: object(),
        configName: string().custom(value => {
          if (value && !value.match(CONFIG_NAME_PATTERN)) {
            throw new Error('Config file name must be camel case without extension.');
          }
        }),
        footer: string(),
        header: string(),
        root: string(process.cwd()),
        scoped: bool(),
        settingsBlueprint: object(),
        workspaceRoot: string(),
      },
      {
        name: this.constructor.name,
      },
    );

    this.appPath = Path.resolve(this.options.appPath);
    this.rootPath = Path.resolve(this.options.root);

    // Set environment variables
    env('DEBUG_GLOBAL_NAMESPACE', this.options.appName);

    // Core debugger, logger, and translator for the entire tool

// prettier-ignore
      pluginsBlueprint[pluralName] = array(union>([
        string().notEmpty(),
        shape({ [singularName]: string().notEmpty() }),
        instance(contract, true),
      ], []));
    });

    const config = optimal(
      this.inheritFromArgs(this.parseAndExtend(configPath), args),
      {
        ...configBlueprint,
        ...pluginsBlueprint,
        debug: bool(),
        extends: array(string()),
        locale: string(),
        output: number(2).between(1, 3, true),
        // shape() requires a non-empty object
        settings: isEmpty(settingsBlueprint) ? object() : shape(settingsBlueprint),
        silent: bool(),
        theme: string('default').notEmpty(),
      },
      {
        file: configPath instanceof Path ? configPath.name() : '',
        name: 'ConfigLoader',
        unknown: true,
      },
    );

    return (config as unknown) as T;
  }

], []));
    });

    const config = optimal(
      this.inheritFromArgs(this.parseAndExtend(configPath), args),
      {
        ...configBlueprint,
        ...pluginsBlueprint,
        debug: bool(),
        extends: array(string()),
        locale: string(),
        output: number(2).between(1, 3, true),
        // shape() requires a non-empty object
        settings: isEmptyObject(settingsBlueprint) ? object() : shape(settingsBlueprint),
        silent: bool(),
        theme: string('default').notEmpty(),
      },
      {
        file: typeof configPath === 'string' ? path.basename(configPath) : '',
        name: 'ConfigLoader',
        unknown: true,
      },
    );

    return config as T;
  }

constructor(options: Options, attribute: string, config: Partial = {}) {
    super(options, attribute, config, false);

    this.config = optimal(
      this.config,
      {
        constant: bool(),
        nullable: bool(),
        optional: bool(),
        type: string('enum').notEmpty(),
        valueType: this.createUnionType(),
        // `valueType` must be validated before values
        values: array(custom(this.validateValue, ''))
          .notEmpty()
          .required(),
      },
      {
        name: 'EnumDefinition',
        unknown: true,
      },
    );
  }

this.debug('Generating %s blueprint', chalk.magenta(singularName));

      // prettier-ignore
      pluginsBlueprint[pluralName] = array(union>([
        string().notEmpty(),
        shape({ [singularName]: string().notEmpty() }),
        instance(contract as Constructor, true),
      ], []));
    });

    const config = optimal(
      this.inheritFromArgs(this.parseAndExtend(configPath), args),
      {
        ...configBlueprint,
        ...pluginsBlueprint,
        debug: bool(),
        extends: array(string()),
        locale: string(),
        output: number(2).between(1, 3, true),
        // shape() requires a non-empty object
        settings: isEmptyObject(settingsBlueprint) ? object() : shape(settingsBlueprint),
        silent: bool(),
        theme: string('default').notEmpty(),
      },
      {
        file: typeof configPath === 'string' ? path.basename(configPath) : '',
        name: 'ConfigLoader',
        unknown: true,
      },
    );

    return config as T;

instance(contract as Constructor, true),
      ], []));
    });

    const config = optimal(
      this.inheritFromArgs(this.parseAndExtend(configPath), args),
      {
        ...configBlueprint,
        ...pluginsBlueprint,
        debug: bool(),
        extends: array(string()),
        locale: string(),
        output: number(2).between(1, 3, true),
        // shape() requires a non-empty object
        settings: isEmptyObject(settingsBlueprint) ? object() : shape(settingsBlueprint),
        silent: bool(),
        theme: string('default').notEmpty(),
      },
      {
        file: typeof configPath === 'string' ? path.basename(configPath) : '',
        name: 'ConfigLoader',
        unknown: true,
      },
    );

    return config as T;
  }

protected toString(state: ProgressState): string {
    const { color, current, style: styleName, template, total, transparent } = optimal(
      state,
      {
        color: bool(),
        current: number()
          .required()
          .gte(0),
        style: string('bar').oneOf(Object.keys(STYLES) as ProgressStyle[]),
        template: string('{percent} {bar} {progress}').notEmpty(),
        total: number()
          .required()
          .gt(0),
        transparent: bool(),
      },
      {
        name: 'ProgressOutput',
      },
    );

    // Mark as final for convenience

constructor(reporter: Tr, options: Partial = {}) {
    super();

    this.reporter = reporter;
    this.options = optimal(options, {
      footer: string().empty(),
      header: string().empty(),
      silent: bool(),
    });

    // Avoid binding listeners while testing
    if (process.env.NODE_ENV === 'test') {
      return;
    }

    // Start early so we may capture uncaught/unhandled
    this.start();
  }

constructor(options: Options, attribute: string, config: Partial = {}) {
    super(options, attribute, config, false);

    this.config = optimal(
      this.config,
      {
        constant: bool(),
        nullable: bool(),
        optional: bool(),
        type: string('enum').notEmpty(),
        valueType: this.createUnionType(),
        // `valueType` must be validated before values
        values: array(custom(this.validateValue, ''))
          .notEmpty()
          .required(),
      },
      {
        name: 'EnumDefinition',
        unknown: true,
      },