@adobe/uix-core 0.6.5 → 0.7.1-nightly.20230114

package/src/object-simulator.test.ts

@@ -0,0 +1,328 @@
+import { NS_ROOT } from "./constants";
+import { EventEmitter } from "eventemitter3";
+import { ObjectSimulator } from "./object-simulator";
+import { FakeFinalizationRegistry } from "./__mocks__/mock-finalization-registry";
+import { wait } from "./promises/wait";
+import { DefMessage } from "./object-walker";
+
+describe("function simulator exchanges functions and tickets", () => {
+  let objectSimulator: ObjectSimulator;
+  beforeEach(() => {
+    jest.spyOn(console, "error").mockImplementation(() => {});
+    const emitter = new EventEmitter();
+    objectSimulator = ObjectSimulator.create(emitter, FakeFinalizationRegistry);
+  });
+  it("turns an object with functions into an object with tickets", async () => {
+    const invokeIt = (blorp: CallableFunction) => blorp();
+    const gnorf = {
+      slorf: {
+        blorf: (x: number) => x + 1,
+      },
+    };
+    const toBeTicketed = {
+      list: [
+        {
+          what: 8,
+          doa: invokeIt,
+        },
+      ],
+      gnorf,
+      harbl: 3,
+    };
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "gnorf": {
+          "slorf": {
+            "blorf": {
+              "_\$pg": {
+                "fnId": "blorf_2",
+              },
+            },
+          },
+        },
+        "harbl": 3,
+        "list": [
+          {
+            "doa": {
+              "_\$pg": {
+                "fnId": "invokeIt_1",
+              },
+            },
+            "what": 8,
+          },
+        ],
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "gnorf": {
+          "slorf": {
+            "blorf": [Function],
+          },
+        },
+        "harbl": 3,
+        "list": [
+          {
+            "doa": [Function],
+            "what": 8,
+          },
+        ],
+      }
+    `);
+    const remoteInvokeIt = unticketed.list[0].doa;
+    await expect(remoteInvokeIt(() => "oh noes")).resolves.toBe("oh noes");
+    await expect(unticketed.gnorf.slorf.blorf(9)).resolves.toBe(10);
+  });
+  it("dies when an object has an unrecognizable value", () => {
+    expect(() =>
+      objectSimulator.simulate({
+        lol: Symbol("lol"),
+      })
+    ).toThrowError("Bad value");
+  });
+  it("passes through tickets when unexpected", () => {
+    const hasTicket = {
+      [NS_ROOT]: {
+        some: "ticket",
+      },
+    };
+    const doTicket = () => objectSimulator.simulate({ hasTicket });
+    expect(doTicket).not.toThrowError();
+    expect(doTicket()).toMatchObject({ hasTicket });
+  });
+  it("strips unserializable props, but throws on unserializable values", () => {
+    expect(() =>
+      objectSimulator.simulate({
+        lol: Symbol("lol"),
+      })
+    ).toThrowError("Bad value");
+    expect(() =>
+      objectSimulator.simulate({
+        [Symbol("lol")]: "lol",
+      })
+    ).not.toThrowError();
+  });
+  it("can handle root functions", async () => {
+    let called = false;
+    const ticketedLoneFn = objectSimulator.simulate(() => {
+      called = true;
+    });
+    expect(ticketedLoneFn).toMatchInlineSnapshot(`
+      {
+        "_$pg": {
+          "fnId": "<anonymous>_1",
+        },
+      }
+    `);
+    const loneFn = objectSimulator.materialize(ticketedLoneFn);
+    await expect(loneFn()).resolves.not.toThrowError();
+    expect(called).toBe(true);
+  });
+  it("Unwraps prototypes and exchange all functions to tickets", async () => {
+    class ca {
+      pa: number;
+      constructor() {
+        this.pa = 4;
+      }
+      getPa() {
+        return this.pa;
+      }
+    }
+    class cb {
+      pb: number;
+      ca: ca;
+      constructor(aa: number) {
+        this.pb = aa;
+        this.ca = new ca();
+      }
+      getNumber() {
+        return this.pb;
+      }
+      giftOne() {
+        this.pb--;
+      }
+    }
+    class cd extends cb {
+      giftOne() {
+        this.pb++;
+      }
+      robOne() {
+        this.pb--;
+      }
+    }
+
+    const toBeTicketed = new cd(5);
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "ca": {
+          "getPa": {
+            "_\$pg": {
+              "fnId": "getPa_1",
+            },
+          },
+          "pa": 4,
+        },
+        "getNumber": {
+          "_\$pg": {
+            "fnId": "getNumber_4",
+          },
+        },
+        "giftOne": {
+          "_\$pg": {
+            "fnId": "giftOne_2",
+          },
+        },
+        "pb": 5,
+        "robOne": {
+          "_\$pg": {
+            "fnId": "robOne_3",
+          },
+        },
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "ca": {
+          "getPa": [Function],
+          "pa": 4,
+        },
+        "getNumber": [Function],
+        "giftOne": [Function],
+        "pb": 5,
+        "robOne": [Function],
+      }
+    `);
+
+    await expect(unticketed.getNumber()).resolves.toBe(5);
+    await unticketed.giftOne();
+    await expect(unticketed.getNumber()).resolves.toBe(6);
+    await unticketed.robOne();
+    await expect(unticketed.getNumber()).resolves.toBe(5);
+    await expect(unticketed.ca.getPa()).resolves.toBe(4);
+  });
+
+  it("Ignores circular dependencies in properties, but relove them through the methods", async () => {
+    class ca {
+      pa: ca;
+      constructor() {
+        this.pa = this;
+      }
+      getPa() {
+        return this.pa;
+      }
+    }
+
+    const toBeTicketed = new ca();
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "getPa": {
+          "_$pg": {
+            "fnId": "getPa_1",
+          },
+        },
+        "pa": "[[Circular]]",
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "getPa": [Function],
+        "pa": "[[Circular]]",
+      }
+    `);
+    expect(
+      Reflect.has(
+        await (await (await unticketed.getPa()).getPa()).getPa(),
+        "getPa"
+      )
+    ).toBeTruthy();
+  });
+  it("Supports classes wrapped in other classes", async () => {
+    class ca {
+      pa: number;
+      constructor() {
+        this.pa = 5;
+      }
+      getPa() {
+        return this.pa;
+      }
+    }
+    class cb {
+      pb: ca;
+      constructor() {
+        this.pb = new ca();
+      }
+      getCaValue() {
+        return this.pb.getPa();
+      }
+    }
+    const toBeTicketed = new cb();
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "getCaValue": {
+          "_$pg": {
+            "fnId": "getCaValue_2",
+          },
+        },
+        "pb": {
+          "getPa": {
+            "_$pg": {
+              "fnId": "getPa_1",
+            },
+          },
+          "pa": 5,
+        },
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "getCaValue": [Function],
+        "pb": {
+          "getPa": [Function],
+          "pa": 5,
+        },
+      }
+    `);
+    await expect(unticketed.pb.getPa()).resolves.toBe(5);
+  });
+
+  it("Supports objects with null prototypes", async () => {
+    const toBeTicketed = Object.create(null);
+    toBeTicketed["key1"] = "val1";
+    toBeTicketed["key2"] = "val2";
+    const ticketed = objectSimulator.simulate(toBeTicketed);
+    expect(ticketed).toMatchInlineSnapshot(`
+      {
+        "key1": "val1",
+        "key2": "val2",
+      }
+    `);
+    const unticketed = objectSimulator.materialize(ticketed);
+    expect(unticketed).toMatchInlineSnapshot(`
+      {
+        "key1": "val1",
+        "key2": "val2",
+      }
+    `);
+  });
+
+  it("notifies remote when FinalizationRegistry calls cleanup handler", async () => {
+    const willBeGCed = objectSimulator.simulate(() => {}) as DefMessage;
+    objectSimulator.materialize(willBeGCed);
+    const { subject } = objectSimulator;
+    const fakeTicket = willBeGCed[NS_ROOT];
+    const gcHandler = jest.fn();
+    subject.onOutOfScope(fakeTicket, gcHandler);
+    const lastCleanupHandler = FakeFinalizationRegistry.mock.cleanupHandler;
+    lastCleanupHandler(fakeTicket.fnId);
+    await wait(100);
+    expect(gcHandler).toHaveBeenCalled();
+  });
+});

package/src/object-simulator.ts

@@ -0,0 +1,145 @@
+import { isWrapped, unwrap, wrap } from "./message-wrapper";
+import EventEmitter from "eventemitter3";
+import type { DefMessage, Materialized, Simulated } from "./object-walker";
+import { NOT_TRANSFORMED, transformRecursive } from "./object-walker";
+import { makeCallSender, receiveCalls } from "./rpc";
+import type { Simulator } from "./remote-subject";
+import { RemoteSubject } from "./remote-subject";
+import type { DefTicket } from "./tickets";
+import { hasProp } from "./value-assertions";
+
+function isDefMessage(value: unknown): value is DefMessage {
+  return isWrapped(value) && hasProp(unwrap(value), "fnId");
+}
+
+const bindAll = <T>(inst: T, methods: (keyof T)[]) => {
+  for (const methodName of methods) {
+    const method = inst[methodName];
+    if (typeof method === "function") {
+      inst[methodName] = method.bind(inst);
+    }
+  }
+};
+
+interface CleanupNotifier {
+  // #region Public Methods
+
+  register(obj: any, heldValue: string, ref?: any): void;
+  unregister(ref: any): void;
+
+  // #endregion Public Methods
+}
+
+interface CleanupNotifierConstructor {
+  new (callback: (heldValue: unknown) => void): CleanupNotifier;
+}
+
+export class ObjectSimulator implements Simulator {
+  // #region Properties
+
+  private cleanupNotifier: CleanupNotifier;
+  private fnCounter = 0;
+  private receiverTicketCache: WeakMap<CallableFunction, DefTicket> =
+    new WeakMap();
+  private senderCache: WeakMap<DefTicket, CallableFunction> = new WeakMap();
+
+  subject: RemoteSubject;
+
+  // #endregion Properties
+
+  // #region Constructors
+
+  constructor(subject: RemoteSubject, cleanupNotifier: CleanupNotifier) {
+    this.cleanupNotifier = cleanupNotifier;
+    this.subject = subject;
+
+    bindAll(this, ["makeSender", "makeReceiver", "simulate", "materialize"]);
+  }
+
+  // #endregion Constructors
+
+  // #region Public Static Methods
+
+  static create(
+    emitter: EventEmitter,
+    Cleanup: CleanupNotifierConstructor
+  ): ObjectSimulator {
+    let simulator: Simulator;
+    // proxy simulator, so as not to have cyclic dependency
+    const simulatorInterface: Simulator = {
+      simulate: (x) => simulator.simulate(x),
+      materialize: (x) => simulator.materialize(x),
+    };
+
+    const subject = new RemoteSubject(emitter, simulatorInterface);
+
+    const cleanupNotifier = new Cleanup((fnId: string) => {
+      return subject.notifyCleanup({ fnId });
+    });
+
+    simulator = new ObjectSimulator(subject, cleanupNotifier);
+
+    return simulator as ObjectSimulator;
+  }
+
+  // #endregion Public Static Methods
+
+  // #region Public Methods
+
+  makeReceiver(fn: CallableFunction, parent?: Object) {
+    if (typeof fn !== "function") {
+      return NOT_TRANSFORMED;
+    }
+    let fnTicket = this.receiverTicketCache.get(fn);
+    if (!fnTicket) {
+      fnTicket = {
+        fnId: `${fn.name || "<anonymous>"}_${++this.fnCounter}`,
+      };
+      // Bind function to parent object if it exists
+      let boundFunction = fn;
+      if (parent) {
+        boundFunction = fn.bind(parent);
+      }
+      const cleanup = receiveCalls(
+        boundFunction,
+        fnTicket,
+        new WeakRef(this.subject)
+      );
+      this.subject.onOutOfScope(fnTicket, cleanup);
+      this.receiverTicketCache.set(boundFunction, fnTicket);
+    }
+    return wrap(fnTicket);
+  }
+
+  makeSender(message: unknown) {
+    if (!isDefMessage(message)) {
+      return NOT_TRANSFORMED;
+    }
+    const ticket = unwrap(message);
+    /* istanbul ignore else: preopt */
+    if (!this.senderCache.has(ticket)) {
+      const sender = makeCallSender(ticket, new WeakRef(this.subject));
+      this.cleanupNotifier.register(sender, ticket.fnId, sender);
+      this.senderCache.set(ticket, sender);
+      return sender;
+    } else {
+      return this.senderCache.get(ticket) as CallableFunction;
+    }
+  }
+
+  materialize<T>(simulated: T) {
+    return transformRecursive<CallableFunction>(
+      this.makeSender,
+      simulated
+    ) as Materialized<T>;
+  }
+
+  simulate<T>(localObject: T) {
+    return transformRecursive<DefMessage>(
+      this.makeReceiver,
+      localObject
+    ) as Simulated<T>;
+  }
+
+  // #endregion Public Methods
+}

package/src/object-walker.ts

@@ -0,0 +1,132 @@
+import type { WrappedMessage } from "./message-wrapper";
+import type { DefTicket } from "./tickets";
+import {
+  Primitive,
+  isPlainObject,
+  isPrimitive,
+  isIterable,
+  isObjectWithPrototype,
+} from "./value-assertions";
+
+/**
+ * Extract keys of T whose values are assignable to U.
+ * @internal
+ */
+type ExtractKeys<T, U> = {
+  [P in keyof T]: T[P] extends U ? P : never;
+}[keyof T];
+
+/**
+ * Convert all functions anywhere in T to async functions.
+ * @internal
+ */
+export type Asynced<T> = T extends (...args: infer A) => infer R
+  ? (...args: A) => Promise<R>
+  : {
+      [K in ExtractKeys<
+        T,
+        Function | object | any[] | [any, any]
+      >]: T[K] extends (...args: any) => PromiseLike<any>
+        ? T[K]
+        : T[K] extends [infer U, infer V]
+        ? [Asynced<U>, Asynced<V>]
+        : T[K] extends (infer U)[]
+        ? Asynced<U>[]
+        : T[K] extends (...args: infer A) => infer R
+        ? (...args: A) => Promise<R>
+        : Asynced<T[K]>;
+    };
+
+/** @internal */
+export type Materialized<T> = T extends Primitive
+  ? T
+  : // : T extends (...args: infer A) => infer R
+  // ? (...args: A) => Promise<R>
+  T extends Simulated<infer U>
+  ? Asynced<U>
+  : Asynced<T>;
+
+/** @internal */
+export type DefMessage = WrappedMessage<DefTicket>;
+
+/** @internal */
+export type Simulated<T> = {
+  [K in ExtractKeys<T, Function | object>]: T[K] extends (
+    ...args: unknown[]
+  ) => unknown
+    ? DefMessage
+    : Simulated<T[K]>;
+};
+
+export const NOT_TRANSFORMED = Symbol.for("NOT_TRANSFORMED");
+export const CIRCULAR = "[[Circular]]";
+
+export function transformRecursive<To>(
+  transform: (source: unknown, parent?: Object) => To | typeof NOT_TRANSFORMED,
+  value: unknown,
+  parent?: Object,
+  _refs: WeakSet<object> = new WeakSet()
+): To {
+  if (isPrimitive(value)) {
+    return value as To;
+  }
+  const transformed = transform(value, parent);
+  if (transformed !== NOT_TRANSFORMED) {
+    return transformed;
+  }
+  if (isIterable(value)) {
+    const outArray = [];
+    for (const item of value) {
+      outArray.push(transformRecursive(transform, item, undefined, _refs));
+    }
+    return outArray as To;
+  }
+  if (isPlainObject(value)) {
+    if (_refs.has(value)) {
+      return CIRCULAR as To;
+    }
+    _refs.add(value);
+    const outObj = {};
+    for (const key of Reflect.ownKeys(value)) {
+      Reflect.set(
+        outObj,
+        key,
+        transformRecursive(transform, Reflect.get(value, key), undefined, _refs)
+      );
+    }
+    return outObj as To;
+  }
+  if (isObjectWithPrototype(value)) {
+    if (_refs.has(value)) {
+      return CIRCULAR as To;
+    }
+    _refs.add(value);
+    const getObjectKeys = (obj: Object): (string | symbol)[] => {
+      const result: Set<string | symbol> = new Set();
+      do {
+        if (Reflect.getPrototypeOf(obj) !== null) {
+          for (const prop of Object.getOwnPropertyNames(obj)) {
+            if (prop === "constructor") {
+              continue;
+            }
+            result.add(prop);
+          }
+        }
+      } while ((obj = Reflect.getPrototypeOf(obj)));
+
+      return [...result];
+    };
+    const outObj = {};
+    const properties = getObjectKeys(value);
+    for (const key of properties) {
+      Reflect.set(
+        outObj,
+        key,
+        transformRecursive(transform, Reflect.get(value, key), value, _refs)
+      );
+    }
+    return outObj as To;
+  }
+
+  throw new Error(`Bad value! ${Object.prototype.toString.call(value)}`);
+}

package/src/promises/index.ts

@@ -0,0 +1,2 @@
+export * from "./timed";
+export * from "./wait";

package/src/promises/promise-wrappers.test.ts

@@ -0,0 +1,63 @@
+import { wait } from "./wait";
+import { timeoutPromise } from "./timed";
+
+describe("promise wrappers", () => {
+  const DONE = {};
+  const finish = jest.fn().mockReturnValue(DONE);
+  beforeEach(() => {
+    finish.mockClear();
+    jest.useFakeTimers();
+  });
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+  describe("wait(ms)", () => {
+    it("returns a promise that resolves after n ms", async () => {
+      const sayDone = wait(500).then(finish);
+      jest.advanceTimersByTime(300);
+      expect(finish).not.toHaveBeenCalled();
+      jest.advanceTimersByTime(300);
+      await expect(sayDone).resolves.toBe(DONE);
+      expect(finish).toHaveBeenCalled();
+    });
+  });
+  describe("timeoutPromise(promise, ms, cleanup) returns a promise", () => {
+    const cleanup = jest.fn();
+    beforeEach(() => cleanup.mockReset());
+    it("that resolves with the original promise within ms", async () => {
+      const makesIt = timeoutPromise(
+        "should not fail",
+        wait(50).then(finish),
+        100,
+        cleanup
+      );
+      jest.advanceTimersByTime(75);
+      await expect(makesIt).resolves.toBe(DONE);
+      expect(cleanup).not.toHaveBeenCalled();
+    });
+    it("that rejects if the original promise did not resolve within ms", async () => {
+      const makesIt = timeoutPromise(
+        "took too long",
+        wait(200).then(finish),
+        100,
+        cleanup
+      );
+      jest.advanceTimersByTime(200);
+      await expect(makesIt).rejects.toThrowError(
+        "took too long timed out after 100ms"
+      );
+      expect(cleanup).toHaveBeenCalled();
+    });
+    it("runs the cleanup function if the promise rejects before timeout", async () => {
+      const ngmi = timeoutPromise(
+        "not a chance",
+        Promise.reject(new Error("loool")),
+        100,
+        cleanup
+      );
+      jest.advanceTimersByTime(50);
+      await expect(ngmi).rejects.toThrowError("loool");
+      expect(cleanup).toHaveBeenCalled();
+    });
+  });
+});

package/src/promises/timed.ts

@@ -0,0 +1,41 @@
+/**
+ * Add a timeout to a Promise. The returned Promise will resolve to the value of
+ * the original Promise, but if it doesn't resolve within the timeout interval,
+ * it will reject with a timeout error.
+ *
+ * @param description - Job description to be used in the timeout error
+ * @param promise - Original promise to set a timeout for
+ * @param timeoutMs - Time to wait (ms) before rejecting
+ * @param onReject - Run when promise times out to clean up handles
+ * @returns - Promise that rejects with informative error after X milliseconds have passed
+ *
+ * @internal
+ */
+export function timeoutPromise<T>(
+  description: string,
+  promise: Promise<T>,
+  ms: number,
+  onReject: (e: Error) => void
+): Promise<T> {
+  return new Promise((resolve, reject) => {
+    const cleanupAndReject = async (e: Error) => {
+      try {
+        await onReject(e);
+      } finally {
+        reject(e);
+      }
+    };
+    const timeout = setTimeout(() => {
+      cleanupAndReject(new Error(`${description} timed out after ${ms}ms`));
+    }, ms);
+    promise
+      .then((result) => {
+        clearTimeout(timeout);
+        resolve(result);
+      })
+      .catch((e) => {
+        clearTimeout(timeout);
+        cleanupAndReject(e);
+      });
+  });
+}