Make types more consistent

ember-resources/src/function-based/types.ts

@@ -131,7 +131,7 @@ export type ResourceFunction<Value = unknown> = (hooks: ResourceAPI) => Value |
  * of the resource is the result of the collapsed functions
  * passed to `resource`
  */
-export type ResourceFn<Value = unknown> = (hooks: ResourceAPI) => Value;
+export type ResourceFn<Value = unknown> = Value & ((hooks: ResourceAPI) => Value);
 
 export type Destructor = () => void;
 export type Cache = object;

test-app/app/components/implicit-current.gts

@@ -17,5 +17,6 @@ export const Now = resource(({ on }) => {
 
 <template>
   It is: <time>{{Now}}</time>
+
   It is: <time>{{Now.current}}</time>
 </template>

test-app/tests/core/implicit-current-test.gts

@@ -0,0 +1,38 @@
+import { on } from '@ember/modifier';
+import { click, render, settled } from '@ember/test-helpers';
+import { module, test } from 'qunit';
+import { setupRenderingTest } from 'ember-qunit';
+
+import { cell, resource, resourceFactory } from 'ember-resources';
+
+
+module('.current and implicit .current', function (hooks) {
+  setupRenderingTest(hooks);
+
+  test('A resource has a current property', async function (assert) {
+    let change = () => 0;
+    const Now = resource(() => {
+      const now = cell(0);
+
+      change = () => now.current++;
+
+      return now;
+    });
+
+    await render(
+      <template>
+        <out id="implicit">{{Now}}</out>
+        <out id="explicit">{{Now.current}}</out>
+      </template>
+    );
+
+    assert.dom('#implicit').hasText('0');
+    assert.dom('explicit').hasText('0');
+
+    change();
+    await settled();
+
+    assert.dom('#implicit').hasText('1');
+    assert.dom('explicit').hasText('1');
+  });
+});

test-app/tests/type-tests/function-based.ts

@@ -1,4 +1,5 @@
 import { resource } from 'ember-resources';
+import { expectTypeOf } from 'expect-type';
 import { expectType } from 'ts-expect';
 
 /*
@@ -13,3 +14,6 @@ import { expectType } from 'ts-expect';
  */
 expectType<string>(resource(() => 'hi'));
 expectType<string>(resource(() => () => 'hi'));
+
+expectTypeOf(resource(() => 'hi')).toMatchTypeOf<string>();
+expectTypeOf(resource(() => 'hi')).toMatchTypeOf<Resource<string>>();