get it building/typechecking again

Author: runspired

packages/schema-record/src/-private/fields/compute.ts

@@ -1,8 +1,13 @@
 import type { Future } from '@ember-data/request';
 import type Store from '@ember-data/store';
 import type { StoreRequestInput } from '@ember-data/store';
-import { defineSignal, RelatedCollection as ManyArray } from '@ember-data/store/-private';
-import { getSignal, peekSignal } from '@ember-data/tracking/-private';
+import {
+  consumeInternalSignal,
+  defineSignal,
+  getOrCreateInternalSignal,
+  RelatedCollection as ManyArray,
+  withSignalStore,
+} from '@ember-data/store/-private';
 import { DEBUG } from '@warp-drive/build-config/env';
 import type { StableRecordIdentifier } from '@warp-drive/core-types';
 import { getOrSetGlobal } from '@warp-drive/core-types/-private';
@@ -40,14 +45,10 @@ export const ManagedObjectMap = getOrSetGlobal(
 );
 
 export function computeLocal(record: typeof Proxy<SchemaRecord>, field: LocalField, prop: string): unknown {
-  let signal = peekSignal(record, prop);
-
-  if (!signal) {
-    signal = getSignal(record, prop, false);
-    signal.lastValue = field.options?.defaultValue ?? null;
-  }
-
-  return signal.lastValue;
+  const signals = withSignalStore(record);
+  const signal = getOrCreateInternalSignal(signals, record, prop, field.options?.defaultValue ?? null);
+  consumeInternalSignal(signal);
+  return signal.value;
 }
 
 export function peekManagedArray(record: SchemaRecord, field: FieldSchema): ManyArray | ManagedArray | undefined {

packages/schema-record/src/-private/fields/managed-object.ts

@@ -2,6 +2,7 @@ import {
   consumeInternalSignal,
   entangleSignal,
   notifyInternalSignal,
+  OBJECT_SIGNAL,
   type WarpDriveSignal,
   withSignalStore,
 } from '@ember-data/store/-private';
@@ -14,7 +15,7 @@ import type { ObjectField, SchemaObjectField } from '@warp-drive/core-types/sche
 
 import type { SchemaRecord } from '../record';
 import type { SchemaService } from '../schema';
-import { Editable, EmbeddedPath, Legacy, MUTATE, OBJECT_SIGNAL, Parent, SOURCE } from '../symbols';
+import { Editable, EmbeddedPath, Legacy, MUTATE, Parent, SOURCE } from '../symbols';
 
 export function notifyObject(obj: ManagedObject) {
   notifyInternalSignal(obj[OBJECT_SIGNAL]);

packages/schema-record/src/-private/record.ts

@@ -7,12 +7,13 @@ import type { RelatedCollection as ManyArray } from '@ember-data/store/-private'
 import {
   ARRAY_SIGNAL,
   entangleSignal,
+  getOrCreateInternalSignal,
   notifyInternalSignal,
+  OBJECT_SIGNAL,
   recordIdentifierFor,
   setRecordIdentifier,
   withSignalStore,
 } from '@ember-data/store/-private';
-import { getSignal, invalidateSignal, type Signal, Signals } from '@ember-data/tracking/-private';
 import { DEBUG } from '@warp-drive/build-config/env';
 import { assert } from '@warp-drive/build-config/macros';
 import type { StableRecordIdentifier } from '@warp-drive/core-types';
@@ -47,18 +48,7 @@ const getLegacySupport = macroCondition(dependencySatisfies('@ember-data/model',
 
 export { Editable, Legacy, Checkout } from './symbols';
 const IgnoredGlobalFields = new Set<string>(['length', 'nodeType', 'then', 'setInterval', 'document', STRUCTURED]);
-const symbolList = [
-  Destroy,
-  RecordStore,
-  Identifier,
-  Editable,
-  Parent,
-  Checkout,
-  Legacy,
-  Signals,
-  EmbeddedPath,
-  EmbeddedType,
-];
+const symbolList = [Destroy, RecordStore, Identifier, Editable, Parent, Checkout, Legacy, EmbeddedPath, EmbeddedType];
 const RecordSymbols = new Set(symbolList);
 
 type RecordSymbol = (typeof symbolList)[number];
@@ -89,7 +79,6 @@ export class SchemaRecord {
   declare [EmbeddedPath]: string[] | null;
   declare [Editable]: boolean;
   declare [Legacy]: boolean;
-  declare [Signals]: Map<string, Signal>;
   declare [Symbol.toStringTag]: `SchemaRecord<${string}>`;
   declare ___notifications: object;
 
@@ -306,10 +295,7 @@ export class SchemaRecord {
             // TODO pass actual cache value not {}
             return schema.hashFn(field)({}, field.options ?? null, field.name ?? null);
           case '@local': {
-            // FIXME the signal is the local storage, don't need the double entangle
-            const lastValue = computeLocal(receiver, field, prop as string);
-            entangleSignal(signals, receiver, prop as string, null);
-            return lastValue;
+            return computeLocal(receiver, field, prop as string);
           }
           case 'field':
             entangleSignal(signals, receiver, field.name, null);
@@ -439,10 +425,15 @@ export class SchemaRecord {
             return true;
           }
           case '@local': {
-            const signal = getSignal(receiver, prop as string, true);
-            if (signal.lastValue !== value) {
-              signal.lastValue = value;
-              invalidateSignal(signal);
+            const signal = getOrCreateInternalSignal(
+              signals,
+              receiver,
+              prop as string | symbol,
+              field.options?.defaultValue ?? null
+            );
+            if (signal.value !== value) {
+              signal.value = value;
+              notifyInternalSignal(signal);
             }
             return true;
           }
@@ -615,7 +606,7 @@ export class SchemaRecord {
             if (identityField.name && identityField.kind === '@id') {
               const signal = signals.get('@identity');
               if (signal) {
-                invalidateSignal(signal);
+                notifyInternalSignal(signal);
               }
             }
             break;
@@ -645,7 +636,7 @@ export class SchemaRecord {
                 // console.log(`Notification for ${key} on ${identifier.type}`, self);
                 const signal = signals.get(key);
                 if (signal) {
-                  invalidateSignal(signal);
+                  notifyInternalSignal(signal);
                 }
                 const field = fields.get(key);
                 if (field?.kind === 'array' || field?.kind === 'schema-array') {
@@ -656,16 +647,14 @@ export class SchemaRecord {
                       ARRAY_SIGNAL in peeked
                     );
                     const arrSignal = peeked[ARRAY_SIGNAL];
-                    arrSignal.isStale = true;
-                    invalidateSignal(arrSignal);
+                    notifyInternalSignal(arrSignal);
                   }
                 }
                 if (field?.kind === 'object') {
                   const peeked = peekManagedObject(self, field);
                   if (peeked) {
                     const objSignal = peeked[OBJECT_SIGNAL];
-                    objSignal.isStale = true;
-                    invalidateSignal(objSignal);
+                    notifyInternalSignal(objSignal);
                   }
                 }
               }
@@ -685,7 +674,7 @@ export class SchemaRecord {
                   // console.log(`Notification for ${key} on ${identifier.type}`, self);
                   const signal = signals.get(key);
                   if (signal) {
-                    invalidateSignal(signal);
+                    notifyInternalSignal(signal);
                   }
                   // FIXME
                 } else if (field.kind === 'resource') {
@@ -721,7 +710,7 @@ export class SchemaRecord {
                     if (field.options.async) {
                       const signal = signals.get(key);
                       if (signal) {
-                        invalidateSignal(signal);
+                        notifyInternalSignal(signal);
                       }
                     }
                   }

packages/schema-record/src/-private/schema.ts

@@ -170,7 +170,7 @@ function makeCachedDerivation<R, T, FM extends ObjectValue | null>(
   derivation: Derivation<R, T, FM>
 ): Derivation<R, T, FM> {
   const memoizedDerivation = (record: R, options: FM, prop: string): T => {
-    const signals = withSignalStore(record);
+    const signals = withSignalStore(record as object);
     let signal = signals.get(prop);
     if (!signal) {
       signal = createMemo(() => {

packages/store/src/-private.ts

@@ -81,4 +81,5 @@ export {
   withSignalStore,
   notifyInternalSignal,
   consumeInternalSignal,
+  getOrCreateInternalSignal,
 } from './-private/new-core-tmp/reactivity/internal';

packages/store/src/-private/record-arrays/identifier-array.ts

@@ -182,9 +182,9 @@ export class IdentifierArray<T = unknown> {
   _updatingPromise: Promise<IdentifierArray<T>> | null = null;
   readonly identifier: StableDocumentIdentifier | null;
 
-  [IS_COLLECTION] = true;
+  declare [IS_COLLECTION]: boolean;
   declare [ARRAY_SIGNAL]: WarpDriveSignal;
-  [SOURCE]: StableRecordIdentifier[];
+  declare [SOURCE]: StableRecordIdentifier[];
 
   declare links: Links | PaginationLinks | null;
   declare meta: Record<string, unknown> | null;
@@ -225,6 +225,7 @@ export class IdentifierArray<T = unknown> {
     this._manager = options.manager;
     this.identifier = options.identifier || null;
     this[SOURCE] = options.identifiers;
+    this[IS_COLLECTION] = true;
 
     // TODO this likely should be entangled on the proxy/receiver not this class
     // FIXME before we entangled legacy array signals on the proxy too
@@ -264,6 +265,10 @@ export class IdentifierArray<T = unknown> {
           return identifier && store._instanceCache.getRecord(identifier);
         }
 
+        if (prop === ARRAY_SIGNAL) {
+          return _SIGNAL;
+        }
+
         if (prop === 'meta') return consumeInternalSignal(_SIGNAL), PrivateState.meta;
         if (prop === 'links') return consumeInternalSignal(_SIGNAL), PrivateState.links;
         if (prop === '[]') return consumeInternalSignal(_SIGNAL), receiver;
@@ -324,7 +329,7 @@ export class IdentifierArray<T = unknown> {
         }
 
         if (isSelfProp(self, prop)) {
-          if (prop === ARRAY_SIGNAL || prop === SOURCE) {
+          if (prop === SOURCE) {
             return self[prop];
           }