cubing 0.23.0 → 0.24.0-pre1

package/src/cubing/twisty/controllers/stream/timeline-move-calculation-draft.ts

@@ -1,162 +0,0 @@
-import { Move, QuantumMove } from "../../../alg";
-import type { Duration, Timestamp } from "../AnimationTypes";
-
-interface Event {
-  timeStamp: Timestamp;
-  move: Move;
-}
-
-export interface TimelineEntry {
-  event: Event;
-  start: Timestamp;
-  end: Timestamp;
-}
-
-type Timeline = TimelineEntry[];
-
-function isSameAxis(move1: Move, move2: Move): boolean {
-  const familyRoots =
-    move1.family[0].toLowerCase() + move2.family[0].toLowerCase();
-  // console.log(familyRoots);
-  return ![
-    "uu",
-    "ud",
-    "du",
-    "dd",
-    "ll",
-    "lr",
-    "rl",
-    "rr",
-    "ff",
-    "fb",
-    "bf",
-    "bb",
-  ].includes(familyRoots);
-}
-
-export function toAxes(
-  events: Event[],
-  diameterMs: Duration,
-): TimelineEntry[][] {
-  const axes: TimelineEntry[][] = [];
-  const axisMoveTracker = new Map();
-  let lastEntry: TimelineEntry | null = null;
-  for (const event of events) {
-    if (!lastEntry) {
-      lastEntry = {
-        event,
-        start: event.timeStamp - diameterMs / 2,
-        end: event.timeStamp + diameterMs / 2,
-      };
-      axes.push([lastEntry]);
-      axisMoveTracker.set(lastEntry.event.move.quantum.toString(), lastEntry);
-      continue;
-    }
-    const newEntry: TimelineEntry = {
-      event,
-      start: event.timeStamp - diameterMs / 2,
-      end: event.timeStamp + diameterMs / 2,
-    };
-    if (isSameAxis(lastEntry.event.move, event.move)) {
-      const quarterName = newEntry.event.move.quantum.toString();
-      // console.log(quarterName);
-      const prev = axisMoveTracker.get(quarterName);
-      // console.log("prev", prev);
-      if (
-        prev &&
-        prev.end > newEntry.start &&
-        Math.sign(prev.event.move.amount) ===
-          Math.sign(newEntry.event.move.amount)
-      ) {
-        prev.event.move = new Move(
-          new QuantumMove(
-            prev.event.move.family,
-            prev.event.move.innerLayer,
-            prev.event.move.outerLayer,
-          ),
-          (prev.event.move.amount as number) + newEntry.event.move.amount,
-        );
-      } else {
-        axes[axes.length - 1].push(newEntry);
-        axisMoveTracker.set(quarterName, newEntry);
-      }
-    } else {
-      // console.log("--", algPartToStringForTesting(newEntry.event.move));
-      axes.push([newEntry]);
-      axisMoveTracker.clear();
-      axisMoveTracker.set(newEntry.event.move.quantum.toString(), newEntry);
-      if (newEntry.start < lastEntry.end) {
-        const midpoint = (newEntry.start + lastEntry.end) / 2;
-        newEntry.start = midpoint;
-        lastEntry.end = midpoint;
-      }
-    }
-    lastEntry = newEntry;
-  }
-  return axes;
-}
-
-// TODO: turn into an optional param
-const defaultDiameterMs: Duration = 200;
-
-export function toTimeline(
-  events: Event[],
-  diameterMs: number = defaultDiameterMs,
-): Timeline {
-  const axes: TimelineEntry[][] = toAxes(events, diameterMs);
-  // console.log(axes);
-  return axes.flat();
-}
-
-/*
-
-Input: list of {move: {base, amount}}, centerTime} events sorted by centerTime of halfway through "quarter" turns.
-Output list of {move, centerTime, start, end}
-Options:
-  - radius # milliseconds
-  - maxImbalance # maximum ratio of (centerTime - end)/(centerTime - start)
-
-eventsToTimeline(events):
-  frontier = empty set # only needed for performance, not correctness
-  for e of events:
-    add event to timeline with range {start: e.centerTime - radius, end: e.centerTime + radius}
-    for each event d of the frontier:
-      if d.base == e.base && sign(d.amount) == sign(e.amount): # d and e have the same base move in the same direction:
-        coalesce(d, e)
-        continue outer loop
-      if d.end > e.start and conflicts(d, e):
-        d.end   = min(e.end, (d.centerTime + e.centerTime) / 2)
-        e.start = max(e.end, (d.centerTime + e.centerTime) / 2)
-        remove d from the frontier
-      if d.centerTime < e.centerTime - radius
-        drop d from the frontier # optimization: too old to overlap with future events
-    e.end = min(e.end, e.centerTime + maxImbalance * (e.centerTime - e.start))
-    add e to the frontier
-
-coalesce(d, e):
-  {
-    start: d.start
-    centerTime: weighted_avg(
-      d.centerTime with weight abs(d.amount)
-      e.centerTime with weight abs(e.amount)
-    )
-    end: e.end
-  }
-
-conflicts(d, e):
-  if d.base == e.base && sign(d.amount) != sign(e.amount):
-    return true
-  # else, depends on the puzzle
-
-Thoughts:
-- Alternative to max imbalance: animate first and second part separately?
-- Fingertrick mode: allow an optional overlap amount between any two conflicting moves (possibly depending on the moves)
-
-Properties:
-- An event's start time will never change after it is added.
-- An event might take up less time than it "can".
-  - i.e. its start and/or end time could be extended after the algorithm finishes, without overlapping with conflicting moves.
-  - This is an acceptable compromise for simplicity.
-- As written, moves are only removed from the frontier opportunistically. This shouldn't be a problem.
-
-*/

package/src/cubing/twisty/heavy-code-imports/3d.ts

@@ -1,18 +0,0 @@
-import { from } from "../../vendor/p-lazy/p-lazy";
-
-// TODO can we remove the cached proxy?
-
-// In theory we can, but we've run into situations where imports are not properly cached.
-let cachedConstructorProxy: Promise<
-  typeof import("./dynamic-entries/3d")
-> | null = null;
-
-export async function proxy3D(): Promise<
-  typeof import("./dynamic-entries/3d")
-> {
-  return (cachedConstructorProxy ??= import("./dynamic-entries/3d"));
-}
-
-export const THREEJS: Promise<typeof import("three")> = from(
-  async () => (await proxy3D()).T3I,
-);

package/src/cubing/twisty/heavy-code-imports/dynamic-entries/3d.ts

@@ -1,31 +0,0 @@
-import { cube3x3x3, PuzzleLoader } from "../../../puzzles";
-import type { HintFaceletStyle } from "../../model/props/puzzle/display/HintFaceletProp";
-import { Cube3D, Cube3DOptions } from "../../views/3D/puzzles/Cube3D";
-import { PG3D } from "../../views/3D/puzzles/PG3D";
-
-// Mangled to avoid autocompleting.
-// This must not be imported directly.
-export * as T3I from "three";
-export { Cube3D } from "../../views/3D/puzzles/Cube3D";
-export { PG3D } from "../../views/3D/puzzles/PG3D";
-export { Twisty3DScene } from "../../views/3D/Twisty3DScene";
-
-export async function cube3DShim(options?: Cube3DOptions): Promise<Cube3D> {
-  const renderCallbackShim = () => {};
-  return new Cube3D(await cube3x3x3.def(), renderCallbackShim, options);
-}
-
-// TODO: take loader?
-export async function pg3dShim(
-  puzzleLoader: PuzzleLoader,
-  hintFacelets: HintFaceletStyle,
-): Promise<PG3D> {
-  const renderCallbackShim = () => {};
-  return new PG3D(
-    renderCallbackShim,
-    await puzzleLoader.def(),
-    (await puzzleLoader.pg!()).get3d(),
-    true,
-    hintFacelets === "floating",
-  );
-}

package/src/cubing/twisty/index.ts

@@ -1,24 +0,0 @@
-export { TwistyPlayer } from "./views/TwistyPlayer";
-export { TwistyAlgViewer } from "./views/TwistyAlgViewer";
-export { TwistyAlgEditor } from "./views/TwistyAlgEditor/TwistyAlgEditor";
-export type { TwistyPlayerConfig } from "./views/TwistyPlayer";
-export { experimentalForceNewRendererSharing } from "./views/3D/Twisty3DVantage";
-
-export { NO_VALUE as EXPERIMENTAL_PROP_NO_VALUE } from "./model/props/TwistyProp";
-export { ExperimentalStickering } from "./model/props/puzzle/display/StickeringProp";
-export {
-  BackViewLayout,
-  backViewLayouts,
-} from "./model/props/viewer/BackViewProp";
-export type { PuzzleID } from "./model/props/puzzle/structure/PuzzleIDRequestProp";
-export { VisualizationFormat } from "./model/props/viewer/VisualizationProp";
-
-export { debugShowRenderStats as experimentalDebugShowRenderStats } from "./views/3D/Twisty3DVantage";
-
-// Older
-export { Cube3D } from "./views/3D/puzzles/Cube3D";
-export { PG3D } from "./views/3D/puzzles/PG3D";
-export type { AlgIndexer } from "./controllers/indexer/AlgIndexer";
-export { SimpleAlgIndexer } from "./controllers/indexer/SimpleAlgIndexer";
-export { TreeAlgIndexer } from "./controllers/indexer/tree/TreeAlgIndexer";
-export { KPuzzleWrapper as KSolvePuzzle } from "./views/3D/puzzles/KPuzzleWrapper";

package/src/cubing/twisty/model/PromiseFreshener.ts

@@ -1,49 +0,0 @@
-// TODO: Pick a much better name.
-export class PromiseFreshener<T> {
-  #latestAssignedIdx = 0;
-  #latestResolvedIdx = 0;
-
-  // TODO: reject instead? Drop?
-  async queue(
-    p: Promise<T>,
-  ): Promise<{ fresh: false } | { fresh: true; result: T }> {
-    const idx = ++this.#latestAssignedIdx;
-    const result = await p;
-    if (idx > this.#latestResolvedIdx) {
-      this.#latestResolvedIdx = idx;
-      return {
-        fresh: true,
-        result: result,
-      };
-    } else {
-      return { fresh: false };
-    }
-  }
-}
-
-// This will silenty drop a queued Promise (i.e. not resolve it) if a
-// newer queued one already resolved first. This is useful for classes that want
-// to know the "latest" state of something without jumping back to an older
-// value by accident.
-// TODO: Remove this because it's too easy to misuse?
-export class StaleDropper<T> {
-  #latestAssignedIdx = 0;
-  #latestResolvedIdx = 0;
-
-  queue(p: Promise<T>): Promise<T> {
-    // This is a very rare case where we *do* want to drop a Promise sometimes.
-    // eslint-disable-next-line no-async-promise-executor
-    return new Promise(async (resolve, reject) => {
-      try {
-        const idx = ++this.#latestAssignedIdx;
-        const result = await p;
-        if (idx > this.#latestResolvedIdx) {
-          this.#latestResolvedIdx = idx;
-          resolve(result);
-        }
-      } catch (e) {
-        reject(e);
-      }
-    });
-  }
-}

package/src/cubing/twisty/model/TwistyPlayerModel.ts

@@ -1,256 +0,0 @@
-import { AlgProp } from "./props/puzzle/state/AlgProp";
-import { BackgroundProp } from "./props/viewer/BackgroundProp";
-import { BackViewProp } from "./props/viewer/BackViewProp";
-import { ControlPanelProp } from "./props/viewer/ControlPanelProp";
-import { HintFaceletProp } from "./props/puzzle/display/HintFaceletProp";
-import { IndexerConstructorRequestProp } from "./props/puzzle/state/IndexerConstructorRequestProp";
-import { LatitudeLimitProp } from "./props/viewer/LatitudeLimit";
-import { OrbitCoordinatesRequestProp } from "./props/viewer/OrbitCoordinatesRequestProp";
-import { PlayingInfoProp } from "./props/timeline/PlayingInfoProp";
-import { PGPuzzleDescriptionStringProp } from "./props/puzzle/structure/PuzzleDescriptionProp";
-import { PuzzleIDRequestProp } from "./props/puzzle/structure/PuzzleIDRequestProp";
-import { PuzzleLoaderProp } from "./props/puzzle/structure/PuzzleLoaderProp";
-import { SetupAnchorProp } from "./props/puzzle/state/SetupAnchorProp";
-import { StickeringProp } from "./props/puzzle/display/StickeringProp";
-import { TempoScaleProp } from "./props/timeline/TempoScaleProp";
-import { TimestampRequestProp } from "./props/timeline/TimestampRequestProp";
-import { URLProp } from "./props/general/URLProp";
-import { ViewerLinkProp } from "./props/viewer/ViewerLinkProp";
-import { VisualizationFormatProp } from "./props/viewer/VisualizationProp";
-import { OrbitCoordinatesProp } from "./props/viewer/OrbitCoordinatesProp";
-import { PuzzleIDProp } from "./props/puzzle/structure/PuzzleIDProp";
-import { SpriteProp } from "./props/puzzle/display/SpriteProp";
-import { VisualizationStrategyProp } from "./props/viewer/VisualizationStrategyProp";
-import { IndexerConstructorProp } from "./props/puzzle/state/IndexerConstructorProp";
-import { PuzzleAlgProp } from "./props/puzzle/state/PuzzleAlgProp";
-import { AlgTransformationProp } from "./props/puzzle/state/AlgTransformationProp";
-import { IndexerProp } from "./props/puzzle/state/IndexerProp";
-import { AnchoredStartProp } from "./props/puzzle/state/AnchoredStartProp";
-import { TimeRangeProp } from "./props/viewer/TimeRangeProp";
-import { DetailedTimelineInfoProp } from "./props/timeline/DetailedTimelineInfoProp";
-import { CoarseTimelineInfoProp } from "./props/timeline/CoarseTimelineInfoProp";
-import { CurrentLeavesProp } from "./props/puzzle/state/CurrentLeavesProp";
-import { ButtonAppearanceProp } from "./props/viewer/ButtonAppearanceProp";
-import { CurrentLeavesSimplifiedProp } from "./props/puzzle/state/CurrentLeavesSimplified";
-import { CurrentTransformationProp } from "./props/puzzle/state/CurrentTransformationProp";
-import { LegacyPositionProp } from "./props/puzzle/state/LegacyPositionProp";
-import { PuzzleDefProp } from "./props/puzzle/structure/PuzzleDefProp";
-import { UserVisibleErrorTracker } from "./UserVisibleErrorTracker";
-import { CatchUpMoveProp } from "./props/puzzle/state/CatchUpMoveProp";
-import { experimentalAppendMove, Move } from "../../alg";
-import { NaiveMoveCountProp } from "./props/puzzle/state/NaiveMoveCountProp";
-import { MovePressInputProp } from "./props/puzzle/state/MovePressInputProp";
-import { FoundationDisplayProp } from "./props/puzzle/display/FoundationDisplayProp";
-
-export class TwistyPlayerModel {
-  // TODO: incorporate error handling into the entire prop graph.
-  // TODO: Make this something that can't get confused with normal props?
-  userVisibleErrorTracker = new UserVisibleErrorTracker();
-
-  // TODO: Redistribute and group props with controllers.
-
-  // Depth 0
-  algProp = new AlgProp();
-  backgroundProp = new BackgroundProp();
-  backViewProp = new BackViewProp();
-  controlPanelProp = new ControlPanelProp();
-  catchUpMoveProp = new CatchUpMoveProp();
-  foundationDisplayProp = new FoundationDisplayProp();
-  foundationStickerSpriteURL = new URLProp();
-  hintFaceletProp = new HintFaceletProp();
-  hintStickerSpriteURL = new URLProp();
-  indexerConstructorRequestProp = new IndexerConstructorRequestProp();
-  latitudeLimitProp = new LatitudeLimitProp();
-  movePressInputProp = new MovePressInputProp();
-  orbitCoordinatesRequestProp: OrbitCoordinatesRequestProp =
-    new OrbitCoordinatesRequestProp();
-  playingInfoProp = new PlayingInfoProp();
-  puzzleDescriptionRequestProp = new PGPuzzleDescriptionStringProp();
-  puzzleIDRequestProp = new PuzzleIDRequestProp();
-  setupAnchorProp = new SetupAnchorProp();
-  setupProp = new AlgProp();
-  stickeringProp = new StickeringProp();
-  tempoScaleProp = new TempoScaleProp();
-  timestampRequestProp = new TimestampRequestProp();
-  viewerLinkProp = new ViewerLinkProp();
-  visualizationFormatProp = new VisualizationFormatProp();
-
-  // Depth 1
-  foundationStickerSprite = new SpriteProp({
-    spriteURL: this.foundationStickerSpriteURL,
-  });
-
-  hintStickerSprite = new SpriteProp({
-    spriteURL: this.hintStickerSpriteURL,
-  });
-
-  puzzleLoaderProp = new PuzzleLoaderProp(
-    {
-      puzzleIDRequest: this.puzzleIDRequestProp,
-      puzzleDescriptionRequest: this.puzzleDescriptionRequestProp,
-    },
-    this.userVisibleErrorTracker,
-  );
-
-  // Depth 2
-  puzzleDefProp = new PuzzleDefProp({ puzzleLoader: this.puzzleLoaderProp });
-
-  puzzleIDProp = new PuzzleIDProp({ puzzleLoader: this.puzzleLoaderProp });
-
-  // Depth 3
-
-  puzzleAlgProp = new PuzzleAlgProp({
-    algWithIssues: this.algProp,
-    puzzleDef: this.puzzleDefProp,
-  });
-
-  puzzleSetupProp = new PuzzleAlgProp({
-    algWithIssues: this.setupProp,
-    puzzleDef: this.puzzleDefProp,
-  });
-
-  visualizationStrategyProp = new VisualizationStrategyProp({
-    visualizationRequest: this.visualizationFormatProp,
-    puzzleID: this.puzzleIDProp,
-  });
-
-  // Depth 4
-  indexerConstructorProp = new IndexerConstructorProp({
-    alg: this.algProp,
-    puzzle: this.puzzleIDProp,
-    visualizationStrategy: this.visualizationStrategyProp,
-    indexerConstructorRequest: this.indexerConstructorRequestProp,
-  });
-
-  moveCountProp = new NaiveMoveCountProp({ alg: this.puzzleAlgProp });
-
-  orbitCoordinatesProp = new OrbitCoordinatesProp({
-    orbitCoordinatesRequest: this.orbitCoordinatesRequestProp,
-    latitudeLimit: this.latitudeLimitProp,
-    puzzleID: this.puzzleIDProp,
-    strategy: this.visualizationStrategyProp,
-  });
-
-  setupTransformationProp = new AlgTransformationProp({
-    alg: this.puzzleSetupProp,
-    def: this.puzzleDefProp,
-  });
-
-  // Depth 5
-  indexerProp = new IndexerProp({
-    indexerConstructor: this.indexerConstructorProp,
-    algWithIssues: this.puzzleAlgProp,
-    def: this.puzzleDefProp,
-  });
-
-  // Depth 6
-  anchoredStartProp = new AnchoredStartProp({
-    setupAnchor: this.setupAnchorProp,
-    setupTransformation: this.setupTransformationProp,
-    indexer: this.indexerProp,
-    def: this.puzzleDefProp,
-  });
-
-  timeRangeProp = new TimeRangeProp({
-    indexer: this.indexerProp,
-  });
-
-  // Depth 7
-  detailedTimelineInfoProp: DetailedTimelineInfoProp =
-    new DetailedTimelineInfoProp({
-      timestampRequest: this.timestampRequestProp,
-      timeRange: this.timeRangeProp,
-      setupAnchor: this.setupAnchorProp,
-    });
-
-  // Depth 8
-  coarseTimelineInfoProp = new CoarseTimelineInfoProp({
-    detailedTimelineInfo: this.detailedTimelineInfoProp,
-    playingInfo: this.playingInfoProp,
-  });
-
-  currentLeavesProp = new CurrentLeavesProp({
-    indexer: this.indexerProp,
-    detailedTimelineInfo: this.detailedTimelineInfoProp,
-    catchUpMove: this.catchUpMoveProp,
-  });
-
-  // Depth 9
-  // TODO: Inline Twisty3D management.
-  buttonAppearanceProp = new ButtonAppearanceProp({
-    coarseTimelineInfo: this.coarseTimelineInfoProp,
-    viewerLink: this.viewerLinkProp,
-  });
-
-  currentLeavesSimplifiedProp = new CurrentLeavesSimplifiedProp({
-    currentMoveInfo: this.currentLeavesProp,
-  });
-
-  // Depth 10
-  currentTransformationProp = new CurrentTransformationProp({
-    anchoredStart: this.anchoredStartProp,
-    currentLeavesSimplified: this.currentLeavesSimplifiedProp,
-    indexer: this.indexerProp,
-    def: this.puzzleDefProp,
-  });
-
-  // Depth 11
-  legacyPositionProp = new LegacyPositionProp({
-    currentMoveInfo: this.currentLeavesProp,
-    transformation: this.currentTransformationProp,
-  });
-
-  public async twizzleLink(): Promise<string> {
-    const url = new URL("https://alpha.twizzle.net/edit/");
-
-    const [puzzle, alg, setup, anchor, experimentalStickering] = await Promise.all([
-      this.puzzleIDProp.get(),
-      this.algProp.get(),
-      this.setupProp.get(),
-      this.setupAnchorProp.get(),
-      this.stickeringProp.get(),
-    ]);
-
-    if (!alg.alg.experimentalIsEmpty()) {
-      url.searchParams.set("alg", alg.alg.toString());
-    }
-    if (!setup.alg.experimentalIsEmpty()) {
-      url.searchParams.set("setup-alg", setup.alg.toString());
-    }
-    if (anchor !== "start") {
-      url.searchParams.set("setup-anchor", anchor);
-    }
-    if (experimentalStickering !== "full") {
-      url.searchParams.set(
-        "experimental-stickering",
-        experimentalStickering,
-      );
-    }
-    if (puzzle !== "3x3x3") {
-      url.searchParams.set("puzzle", puzzle);
-    }
-    return url.toString();
-  }
-
-  // TODO: Animate the new move.
-  experimentalAddMove(
-    flexibleMove: Move | string,
-    options: { coalesce?: boolean; mod?: number } = {},
-  ): void {
-    const move =
-      typeof flexibleMove === "string" ? new Move(flexibleMove) : flexibleMove;
-    (async () => {
-      const alg = (await this.algProp.get()).alg;
-      const newAlg = experimentalAppendMove(alg, move, {
-        coalesce: options?.coalesce,
-        mod: options?.mod,
-      });
-      this.algProp.set(newAlg);
-      this.timestampRequestProp.set("end");
-      this.catchUpMoveProp.set({
-        move: move,
-        amount: 0,
-      });
-    })();
-  }
-}

package/src/cubing/twisty/model/UserVisibleErrorTracker.ts

@@ -1,22 +0,0 @@
-import { arrayEquals } from "./helpers";
-import { SimpleTwistyPropSource } from "./props/TwistyProp";
-
-interface UserVisibleError {
-  errors: string[];
-}
-
-const EMPTY_ERRORS = { errors: [] };
-
-export class UserVisibleErrorTracker extends SimpleTwistyPropSource<UserVisibleError> {
-  override getDefaultValue(): UserVisibleError {
-    return EMPTY_ERRORS;
-  }
-
-  reset() {
-    this.set(this.getDefaultValue());
-  }
-
-  canReuseValue(_v1: UserVisibleError, _v2: UserVisibleError): boolean {
-    return arrayEquals(_v1.errors, _v2.errors);
-  }
-}

package/src/cubing/twisty/model/helpers.ts

@@ -1,47 +0,0 @@
-export function arrayEquals<T>(a: readonly T[], b: readonly T[]): boolean {
-  if (a === b) {
-    return true;
-  }
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-export function arrayEqualsCompare<T>(
-  a: readonly T[],
-  b: readonly T[],
-  compare: (a: T, b: T) => boolean,
-): boolean {
-  if (a === b) {
-    return true;
-  }
-  if (a.length !== b.length) {
-    return false;
-  }
-  for (let i = 0; i < a.length; i++) {
-    if (!compare(a[i], b[i])) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// Assumes `offset > 0`. Will produce invalid values if not!
-// We don't check for that, since this can be a hot path.
-export function mod(v: number, m: number, offset = 0): number {
-  return (((v % m) + m + offset) % m) - offset;
-}
-
-export function modIntoRange(
-  v: number,
-  rangeMin: number,
-  rangeMax: number,
-): number {
-  return mod(v - rangeMin, rangeMax - rangeMin) + rangeMin;
-}

package/src/cubing/twisty/model/props/TwistyProp.spec.ts

@@ -1,38 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { SimpleTwistyPropSource, TwistyPropDerived } from "./TwistyProp";
-
-describe("operation", () => {
-  it("can set, get, and save prop values", async () => {
-    class NumProp extends SimpleTwistyPropSource<number> {
-      getDefaultValue() {
-        return 4;
-      }
-    }
-    class AddProp extends TwistyPropDerived<{ a: number; b: number }, number> {
-      derive(inputs: { a: number; b: number }): number {
-        return inputs.a + inputs.b;
-      }
-    }
-
-    const a = new NumProp();
-    const b = new NumProp(10);
-    const sum = new AddProp({ a, b });
-
-    expect(await sum.get()).toEqual(14);
-
-    // sum.addFreshListener((value: number) => {
-    //   console.log(value);
-    // });
-
-    a.set(8);
-    const savedSum = sum.get();
-    a.set(10);
-    expect(await savedSum).toEqual(18);
-    expect(await sum.get()).toEqual(20);
-
-    await new Promise((resolve) => setTimeout(resolve, 1000));
-  });
-});