@mintjamsinc/ichigojs 0.1.89 → 0.1.90

package/dist/types/ichigo/VBindings.d.ts

@@ -111,6 +111,11 @@ export declare class VBindings {
      * @param key The computed property name.
      */
     markComputedDirty(key: string): void;
+    /**
+     * Indicates whether a computed property is marked dirty and not yet recomputed.
+     * @param key The computed property name.
+     */
+    isComputedDirty(key: string): boolean;
     /**
      * Reads the currently cached value of a computed property without triggering pull-based
      * re-evaluation. Used by the recompute routine to obtain the previous value for change
@@ -152,10 +157,14 @@ export declare class VBindings {
      * path fits the identifier (not evaluated yet, a raw object, a short-circuited read),
      * the identifier keeps matching every index.
      *
+     * The recorded paths also count as dependencies of their own: they include what a
+     * method called by the expression read, such as `this[key]`, which the identifiers
+     * found in the source cannot name.
+     *
      * @param changes The change paths of the current update cycle.
      * @param identifiers The identifiers the expression depends on.
      * @param trackedPaths The paths read during the expression's last evaluation, if recorded.
-     * @returns True if some change matches some identifier.
+     * @returns True if some change matches some identifier or recorded path.
      */
     isAffected(changes: string[], identifiers: string[], trackedPaths?: ReadonlySet<string>): boolean;
 }

package/dist/types/ichigo/VNode.d.ts

@@ -113,6 +113,15 @@ export declare class VNode {
      * This includes variable and function names used in expressions.
      */
     get dependentIdentifiers(): string[];
+    /**
+     * Whether a change of the current update cycle concerns this node, so that a node it
+     * depends on should update it: a change matches one of its identifiers, or touches a
+     * path one of its bindings read the last time it ran. The recorded reads cover what a
+     * called method read, such as `this[key]`, which the identifiers cannot name. Each
+     * binding decides again for itself when the node updates.
+     * @param changes The change paths of the current update cycle.
+     */
+    isAffectedBy(changes: string[]): boolean;
     get preparableIdentifiers(): string[];
     /**
      * Gets the user data storage for this virtual node.

package/dist/types/ichigo/VTextEvaluator.d.ts

@@ -22,9 +22,9 @@ export declare class VTextEvaluator {
      */
     get identifiers(): string[];
     /**
-     * The source paths read through reactive proxies during the last evaluation.
-     * Recorded only when an expression has a run-time index ("items[i].name");
-     * undefined before the first evaluation and for texts without such an index.
+     * The source paths read during the last evaluation. Recorded only when an
+     * expression has a run-time index ("items[i].name") or calls a method;
+     * undefined before the first evaluation and for other texts.
      */
     get trackedPaths(): ReadonlySet<string> | undefined;
     /**

package/dist/types/ichigo/util/ExpressionEvaluator.d.ts

@@ -54,13 +54,14 @@ export declare class ExpressionEvaluator {
      */
     private readonly additionalContext?;
     /**
-     * Whether any identifier has an index known only at run time ("items[*].name").
-     * Only then are the paths read during evaluation worth recording.
+     * Whether the paths read during evaluation are recorded: when an identifier has an
+     * index known only at run time ("items[*].name"), or when the expression calls a
+     * method, whose reads (`this[key]` among them) the source analysis may not see.
      */
-    private readonly hasDynamicIndex;
+    private readonly tracksReads;
     /**
-     * The source paths read through reactive proxies during the last evaluation,
-     * or undefined before the first evaluation and when nothing is recorded.
+     * The source paths read during the last evaluation, or undefined before the
+     * first evaluation and when nothing is recorded.
      */
     private trackedPathSet?;
     /**
@@ -93,11 +94,11 @@ export declare class ExpressionEvaluator {
      */
     evaluate(): any;
     /**
-     * The source paths read through reactive proxies during the last evaluation,
-     * recorded only for an expression with a run-time index ("items[i].name").
+     * The source paths read during the last evaluation, recorded only for an
+     * expression with a run-time index ("items[i].name") or a method call.
      * Each evaluation replaces the previous set, so a path read for a former
      * index value is dropped as soon as the expression runs with the new one.
-     * Undefined before the first evaluation and for expressions without such an index.
+     * Undefined before the first evaluation and for other expressions.
      */
     get trackedPaths(): ReadonlySet<string> | undefined;
     /**

package/dist/types/ichigo/util/ExpressionUtils.d.ts

@@ -15,6 +15,16 @@ export declare class ExpressionUtils {
     static extractIdentifiers(expression: string, functionDependencies: Record<string, string[]>, options?: {
         asScript?: boolean;
     }): string[];
+    /**
+     * Whether an expression refers to one of the application's methods, judged by the
+     * identifiers extractIdentifiers returned for it. A called method may read bindings
+     * the source analysis cannot name (e.g. `this[key]`), so such an expression records
+     * its reads when it runs.
+     * @param identifiers The identifiers extracted from the expression.
+     * @param functionDependencies The application's methods and their dependencies.
+     * @returns True if an identifier names a method.
+     */
+    static callsFunction(identifiers: string[], functionDependencies: Record<string, string[]>): boolean;
     /**
      * Returns the binding name an identifier chain starts with
      * (e.g. "items" for "items[0].name" or "user.name").

package/dist/types/ichigo/util/ReactiveProxy.d.ts

@@ -84,11 +84,53 @@ export declare class ReactiveProxy {
      * through a reactive proxy. Nested calls record into the innermost set only;
      * the previous set is restored when fn returns or throws.
      *
+     * The set is kept closed under ancestors: whenever a path is recorded, every
+     * path above it ("items" and "items[2]" for "items[2].name") is in the set as
+     * well. A read reached through a proxy records them on its way down; a read
+     * that starts partway (a proxy a computed returned, a v-for item) has them
+     * added when it is recorded. changeAffectsRead relies on this to answer with
+     * one lookup.
+     *
      * @param paths The set that receives the paths read.
      * @param fn The function to run.
      * @returns The value fn returns.
      */
     static track<T>(paths: Set<string>, fn: () => T): T;
+    /**
+     * Records a read made outside any proxy while track() runs: a binding read by
+     * name (`this.flag`, `this[key]`), which the bindings report here. Reads below
+     * a binding are recorded by the proxy itself.
+     *
+     * @param path The binding name read.
+     */
+    static recordRead(path: string): void;
+    /**
+     * Records a read made through a proxy while track() runs: the member `key` of
+     * the object at `containerPath`. The container's own path and its ancestors are
+     * added first when they are missing, which happens when the proxy was not
+     * reached from a root binding during this run (see track()). A container that
+     * is already recorded has its ancestors recorded too, so the common case is one
+     * lookup.
+     *
+     * @param containerPath The source path of the object read from ("" for a root).
+     * @param key The property key read.
+     */
+    private static recordProxyRead;
+    /**
+     * Checks whether a change touches something read during a tracked run (see
+     * track()): the path read was written, or an object or array holding it was
+     * replaced. A change below a path read does not count, since a read of the
+     * changed member itself would have been recorded too; this keeps a read of a
+     * whole collection ("items") from matching a write to one element.
+     *
+     * The set holds the ancestors of every path read, so a replaced container is
+     * found by the same lookup as the path itself.
+     *
+     * @param changePath The path that was changed (e.g., "items[2].name")
+     * @param readPaths The paths read during the tracked run
+     * @returns True if the change touches a path read
+     */
+    static changeAffectsRead(changePath: string, readPaths: ReadonlySet<string>): boolean;
     /**
      * The `Object.prototype.toString` tags of the *only* value types we deeply
      * proxy. Everything else is returned untouched (raw).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mintjamsinc/ichigojs",
-  "version": "0.1.89",
+  "version": "0.1.90",
   "description": "ichigo.js - Simple and intuitive reactive framework. Lightweight, fast, and user-friendly virtual DOM library",
   "main": "./dist/ichigo.cjs",
   "module": "./dist/ichigo.esm.js",