added initial value support for Computed Class

Author: bennobuilder

packages/core/src/computed/computed.ts

@@ -50,12 +50,20 @@ export class Computed<ComputedValueType = any> extends State<
   constructor(
     agileInstance: Agile,
     computeFunction: ComputeFunctionType<ComputedValueType>,
-    config: CreateComputedConfigInterface = {}
+    config: CreateComputedConfigInterface<ComputedValueType> = {}
   ) {
-    super(agileInstance, null as any, {
-      key: config.key,
-      dependents: config.dependents,
-    });
+    super(
+      agileInstance,
+      Object.prototype.hasOwnProperty.call(config, 'initialValue')
+        ? config.initialValue
+        : !isAsyncFunction(computeFunction)
+        ? computeFunction()
+        : (null as any),
+      {
+        key: config.key,
+        dependents: config.dependents,
+      }
+    );
     config = defineConfig(config, {
       computedDeps: [],
       autodetect: !isAsyncFunction(computeFunction),
@@ -205,7 +213,8 @@ export type ComputeFunctionType<ComputedValueType = any> = () =>
   | ComputedValueType
   | Promise<ComputedValueType>;
 
-export interface CreateComputedConfigInterface extends StateConfigInterface {
+export interface CreateComputedConfigInterface<ComputedValueType = any>
+  extends StateConfigInterface {
   /**
    * Hard-coded dependencies the Computed Class should depend on.
    * @default []
@@ -221,6 +230,15 @@ export interface CreateComputedConfigInterface extends StateConfigInterface {
    * @default true if the compute method isn't asynchronous, otherwise false
    */
   autodetect?: boolean;
+  /**
+   * Initial value of the Computed
+   * which is temporarily set until the first computation has been completed.
+   *
+   * Note: Only really relevant if an async compute method is used.
+   *
+   * @default undefined
+   */
+  initialValue?: ComputedValueType;
 }
 
 export interface ComputedConfigInterface {

packages/core/tests/unit/computed/computed.test.ts

@@ -45,10 +45,10 @@ describe('Computed Tests', () => {
     expect(computed._key).toBeUndefined();
     expect(computed.isSet).toBeFalsy();
     expect(computed.isPlaceholder).toBeFalsy();
-    expect(computed.initialStateValue).toBe(null);
-    expect(computed._value).toBe(null);
-    expect(computed.previousStateValue).toBe(null);
-    expect(computed.nextStateValue).toBe(null);
+    expect(computed.initialStateValue).toBe(computedFunction());
+    expect(computed._value).toBe(computedFunction());
+    expect(computed.previousStateValue).toBe(computedFunction());
+    expect(computed.nextStateValue).toBe(computedFunction());
     expect(computed.observers['value']).toBeInstanceOf(StateObserver);
     expect(Array.from(computed.observers['value'].dependents)).toStrictEqual(
       []
@@ -73,6 +73,7 @@ describe('Computed Tests', () => {
       dependents: [dummyObserver1],
       computedDeps: [dummyObserver2, undefined as any, dummyState],
       autodetect: false,
+      initialValue: 'initialValue',
     });
 
     expect(computed.computeFunction).toBe(computedFunction);
@@ -109,10 +110,10 @@ describe('Computed Tests', () => {
     expect(computed._key).toBe('coolComputed');
     expect(computed.isSet).toBeFalsy();
     expect(computed.isPlaceholder).toBeFalsy();
-    expect(computed.initialStateValue).toBe(null);
-    expect(computed._value).toBe(null);
-    expect(computed.previousStateValue).toBe(null);
-    expect(computed.nextStateValue).toBe(null);
+    expect(computed.initialStateValue).toBe('initialValue');
+    expect(computed._value).toBe('initialValue');
+    expect(computed.previousStateValue).toBe('initialValue');
+    expect(computed.nextStateValue).toBe('initialValue');
     expect(computed.observers['value']).toBeInstanceOf(StateObserver);
     expect(Array.from(computed.observers['value'].dependents)).toStrictEqual([
       dummyObserver1,