refactor(typealias): add Readonly modifier

package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-base-utilities-js",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Utilities for React applications.",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",

src/hoc.distinctprop.ts

@@ -2,15 +2,15 @@ import * as React from 'react';
 import {Component, ComponentType} from 'react';
 import {getComponentDisplayName} from './util';
 
-export type DistinctPropsHOCOptions<Props> = {
+export type DistinctPropsHOCOptions<Props> = Readonly<{
   /**
    * If this is not specified, use all keys of the component's props, but
    * beware that some keys may be optional.
    */
-  readonly propKeysForComparison?: (keyof Props)[];
-  readonly propKeysToIgnore?: (keyof Props)[];
-  readonly checkEquality: (obj1: unknown, obj2: unknown) => boolean;
-};
+  propKeysForComparison?: (keyof Props)[];
+  propKeysToIgnore?: (keyof Props)[];
+  checkEquality: (obj1: unknown, obj2: unknown) => boolean;
+}>;
 
 /**
  * Filter out duplicate props for some keys.

src/hoc.lifecycle.ts

@@ -2,15 +2,15 @@ import * as React from 'react';
 import {Component, ComponentType, StatelessComponent} from 'react';
 import {getComponentDisplayName} from './util';
 
-export type LifecycleHOCHooks = {
-  readonly onConstruction?: () => void;
-  readonly componentDidMount?: () => void;
-  readonly componentWillUnmount?: () => void;
-};
-
-export type LifecycleHooksHOCOptions = {
-  readonly lifecycleHooks: LifecycleHOCHooks;
-};
+export type LifecycleHOCHooks = Readonly<{
+  onConstruction?: () => void;
+  componentDidMount?: () => void;
+  componentWillUnmount?: () => void;
+}>;
+
+export type LifecycleHooksHOCOptions = Readonly<{
+  lifecycleHooks: LifecycleHOCHooks;
+}>;
 
 /**
  * Set up hooks for component lifecycle.

src/hoc.loadable.tsx

@@ -3,14 +3,15 @@ import {ComponentType} from 'react';
 import * as Loadable from 'react-loadable';
 import {Options, OptionsWithoutRender} from 'react-loadable';
 
-export type LoadableHOCHooks = {
-  readonly beforeComponentLoaded?: () => void;
-};
+export type LoadableHOCHooks = Readonly<{
+  beforeComponentLoaded?: () => void;
+}>;
 
-export type LoadableHOCOptions<Props, Exports extends object> = {
-  readonly hooks?: LoadableHOCHooks;
-  readonly displayName?: string;
-} & Options<Props, Exports>;
+export type LoadableHOCOptions<Props, Exports extends object> = Readonly<{
+  hooks?: LoadableHOCHooks;
+  displayName?: string;
+}> &
+  Options<Props, Exports>;
 
 /**
  * Convert a component to Loadable.

src/hoc.viewmodel.ts

@@ -2,24 +2,27 @@ import {NeverProp, Objects, Omit, Types} from 'javascriptutilities';
 import * as React from 'react';
 import {Component, ComponentType, StatelessComponent} from 'react';
 import {getComponentDisplayName} from './util';
-import {ReduxType, RootType} from './viewmodel';
+import {ReduxViewModel, RootViewModel} from './viewmodel';
 export type ViewModelHOCProps<VM> = {readonly viewModel: VM};
 export type ViewModelFactoryHOCProps = {readonly viewModelFactory: unknown};
 
 export type FactorifiedViewModelHOCProps<
   Props extends ViewModelHOCProps<any>
 > = Omit<Props, 'viewModel'> & ViewModelFactoryHOCProps;
 
-export type ViewModelHOCHooks = {
-  readonly beforeViewModelCreated?: () => void;
-};
+export type ViewModelHOCHooks = Readonly<{
+  beforeViewModelCreated?: () => void;
+}>;
 
-export type ViewModelHOCOptions<VM, Props extends ViewModelHOCProps<VM>> = {
-  readonly viewModelHooks?: ViewModelHOCHooks;
-  readonly createViewModel: (
+export type ViewModelHOCOptions<
+  VM,
+  Props extends ViewModelHOCProps<VM>
+> = Readonly<{
+  viewModelHooks?: ViewModelHOCHooks;
+  createViewModel: (
     props: Omit<Props, 'viewModel'> & ViewModelFactoryHOCProps
   ) => VM;
-};
+}>;
 
 export type TargetViewModelHOCComponent<
   VM,
@@ -69,17 +72,19 @@ export function withViewModel<VM, Props extends ViewModelHOCProps<VM>, State>(
     public componentDidMount() {
       let {viewModel} = this;
 
-      if (Types.isInstance<RootType>(viewModel, 'initialize')) {
+      if (Types.isInstance<RootViewModel>(viewModel, 'initialize')) {
         viewModel.initialize();
       }
 
-      if (Types.isInstance<ReduxType<State>>(viewModel, 'setUpStateCallback')) {
+      if (
+        Types.isInstance<ReduxViewModel<State>>(viewModel, 'setUpStateCallback')
+      ) {
         viewModel.setUpStateCallback(state => this.setState(state));
       }
     }
 
     public componentWillUnmount() {
-      if (Types.isInstance<RootType>(this.viewModel, 'deinitialize')) {
+      if (Types.isInstance<RootViewModel>(this.viewModel, 'deinitialize')) {
         this.viewModel.deinitialize();
       }
     }

src/index.ts

@@ -1,31 +1,7 @@
-export {
-  CompleteSetupHOCOptions,
-  withCompleteSetup,
-  withTestCompleteSetup,
-} from './hoc.all';
-export {DistinctPropsHOCOptions, withDistinctProps} from './hoc.distinctprop';
-export {
-  LifecycleHOCHooks,
-  LifecycleHooksHOCOptions,
-  withLifecycleHooks,
-} from './hoc.lifecycle';
-export {
-  LoadableHOCOptions,
-  LoadableHOCHooks,
-  withLoadable,
-  withTestLoadable,
-} from './hoc.loadable';
-export {
-  FactorifiedViewModelHOCProps,
-  TargetViewModelHOCComponent,
-  ViewModelFactoryHOCProps,
-  ViewModelHOCOptions,
-  ViewModelHOCProps,
-  ViewModelHOCHooks,
-  withViewModel,
-} from './hoc.viewmodel';
-export {getComponentDisplayName} from './util';
-export {
-  ReduxType as ReduxViewModel,
-  RootType as RootViewModel,
-} from './viewmodel';
+export * from './hoc.all';
+export * from './hoc.distinctprop';
+export * from './hoc.lifecycle';
+export * from './hoc.loadable';
+export * from './hoc.viewmodel';
+export * from './util';
+export * from './viewmodel';

src/viewmodel.ts

@@ -1,17 +1,17 @@
 /**
  * Root view model type.
  */
-export interface RootType {
+export interface RootViewModel {
   initialize(): void;
   deinitialize(): void;
 }
 
 /**
  * Provide the relevant state stream for the component state.
- * @extends {RootType} Root type extension.
+ * @extends {RootViewModel} Root type extension.
  * @template State State generics.
  */
-export interface ReduxType<State> extends RootType {
+export interface ReduxViewModel<State> extends RootViewModel {
   /**
    * Listen to state changes.
    * @param {(state: State) => void} callback A state callback.