Maybe progress

Author: NullVoxPopuli

ember-resources/src/intermediate-representation.ts

@@ -10,6 +10,7 @@ import { ReadonlyCell } from './cell.ts';
 import { ResourceManagerFactory } from './resource-manager.ts';
 import { CURRENT, INTERNAL } from './types.ts';
 import { registerUsable, TYPE_KEY } from './use.ts';
+import { shallowFlat } from './utils.ts';
 
 import type { Destructor, Reactive, ResourceFunction } from './types.ts';
 import type Owner from '@ember/owner';
@@ -79,8 +80,9 @@ const TYPE = 'function-based';
 
 registerUsable(TYPE, (context: object, config: Builder<unknown>) => {
   let owner = getOwner(context) || context;
+  let instance = config.create(owner as Owner);
 
-  return config.create(owner as Owner)[RESOURCE_CACHE];
+  return instance[RESOURCE_CACHE];
 });
 
 /**
@@ -131,7 +133,7 @@ export class Resource<Value> {
           );
           assert(
             `Expected the resource's \`use(...)\` utility to have been passed another resource, but something else was passed.`,
-            INTERNAL in usable,
+            INTERNAL in usable || usable instanceof Builder,
           );
 
           let previousCache = this.#usableCache.get(usable);
@@ -175,17 +177,7 @@ export class Resource<Value> {
   }
 
   get current() {
-    let maybeValue = getValue(this.#cache);
-
-    if (typeof maybeValue === 'function') {
-      return maybeValue();
-    }
-
-    if (isReactive(maybeValue)) {
-      return maybeValue[CURRENT];
-    }
-
-    return maybeValue;
+    return shallowFlat(this.#cache);
   }
 
   [DEBUG_NAME]() {
@@ -194,7 +186,3 @@ export class Resource<Value> {
 }
 
 setHelperManager(ResourceManagerFactory, Builder.prototype);
-
-function isReactive<Value>(maybe: unknown): maybe is Reactive<Value> {
-  return typeof maybe === 'object' && maybe !== null && CURRENT in maybe;
-}

ember-resources/src/use.ts

@@ -9,6 +9,7 @@ import { associateDestroyableChild } from '@ember/destroyable';
 import { invokeHelper } from '@ember/helper';
 
 import { ReadonlyCell } from './cell.ts';
+import { getCurrentValue, shallowFlat } from './utils.ts';
 
 import type {
   INTERNAL,
@@ -107,17 +108,6 @@ export function use(
   assert(`Unknown arity for \`use\`. Received ${args.length} arguments`, false);
 }
 
-function getCurrentValue<Value>(value: Value | Reactive<Value>): Value {
-  /**
-   * If we are working with a cell, forward the '.current' call to it.
-   */
-  if (typeof value === 'object' && value !== null && 'current' in value) {
-    return value.current;
-  }
-
-  return value;
-}
-
 function classContextLink<Value>(
   context: object,
   definition: Value | (() => Value),
@@ -214,8 +204,6 @@ function descriptorGetter(initializer: unknown | (() => unknown)) {
 
         let usable = USABLES.get(config.type) || USABLES.get(config[TYPE_KEY]);
 
-        console.log({ usable });
-
         assert(
           `Expected the initialized value with @use to have been a registerd "usable". Available usables are: ${[
             ...USABLES.keys(),
@@ -231,9 +219,7 @@ function descriptorGetter(initializer: unknown | (() => unknown)) {
         associateDestroyableChild(this, cache);
       }
 
-      let value = getValue(cache);
-
-      return getCurrentValue(value);
+      return shallowFlat(cache);
     },
   };
 }

ember-resources/src/utils.ts

@@ -1,15 +1,41 @@
 // @ts-ignore
-import { getValue } from '@glimmer/tracking/primitives/cache';
+import { type createCache, getValue } from '@glimmer/tracking/primitives/cache';
 import { assert } from '@ember/debug';
-// @ts-ignore
-import { invokeHelper } from '@ember/helper';
 
-import { INTERMEDIATE_VALUE } from './types.ts';
+import { CURRENT, INTERMEDIATE_VALUE, type Reactive } from './types.ts';
 
 import type { Builder, Resource } from './intermediate-representation.ts';
-import type { InternalFunctionResourceConfig } from './types.ts';
 import type Owner from '@ember/owner';
 
+export function shallowFlat<Value>(cache: ReturnType<typeof createCache>): Value {
+  let maybeValue = getValue(cache);
+
+  if (typeof maybeValue === 'function') {
+    return maybeValue();
+  }
+
+  if (isReactive(maybeValue)) {
+    return maybeValue[CURRENT] as Value;
+  }
+
+  return maybeValue as Value;
+}
+
+export function isReactive<Value>(maybe: unknown): maybe is Reactive<Value> {
+  return typeof maybe === 'object' && maybe !== null && CURRENT in maybe;
+}
+
+export function getCurrentValue<Value>(value: Value | Reactive<Value>): Value {
+  /**
+   * If we are working with a cell, forward the '.current' call to it.
+   */
+  if (typeof value === 'object' && value !== null && 'current' in value) {
+    return value.current;
+  }
+
+  return value;
+}
+
 /**
  * This is what allows resource to be used without @use.
  * The caveat though is that a property must be accessed