grafast 0.1.1-beta.2 → 0.1.1-beta.21

package/dist/engine/StepTracker.d.ts

@@ -1,96 +1,2 @@
-import type { OperationPlan } from "../index.js";
-import type { ExecutableStep } from "../step";
-import type { LayerPlan, LayerPlanReasonsWithParentStep } from "./LayerPlan";
-import type { OutputPlan } from "./OutputPlan";
-/**
- * This class keeps track of all of our steps, and the dependencies between
- * steps and other steps, layer plans and steps, and output plans and steps.
- *
- * When a step is replaced by another step, all the dependencies are updated
- * such that the replaced step simply evaporates.
- *
- * @internal
- */
-export declare class StepTracker {
-    private readonly operationPlan;
-    /** @internal */
-    stepCount: number;
-    /** @internal */
-    activeSteps: Set<ExecutableStep<any>>;
-    /** @internal */
-    stepById: {
-        [stepId: number]: ExecutableStep | null;
-    };
-    /** @internal */
-    private aliasesById;
-    /** @internal */
-    stepsWithNoDependencies: Set<ExecutableStep<any>>;
-    /** @internal */
-    outputPlansByRootStep: Map<ExecutableStep<any>, Set<OutputPlan<import("./OutputPlan").OutputPlanType>>>;
-    /** @internal */
-    layerPlansByRootStep: Map<ExecutableStep<any>, Set<LayerPlan<import("./LayerPlan").LayerPlanReason>>>;
-    /** @internal */
-    layerPlansByParentStep: Map<ExecutableStep<any>, Set<LayerPlan<LayerPlanReasonsWithParentStep>>>;
-    /** @internal */
-    layerPlans: Array<LayerPlan | null>;
-    /**
-     * All the OutputPlans that were created to allow a more efficient
-     * walkOutputPlans implementation.
-     *
-     * @internal
-     */
-    allOutputPlans: OutputPlan[];
-    nextStepIdToDeduplicate: number;
-    constructor(operationPlan: OperationPlan);
-    newStepsSince(oldStepCount: number): ExecutableStep<any>[];
-    private forbid;
-    /** Called when OperationPlan enters finalize phase. */
-    finalizeSteps(): void;
-    /** Called when OperationPlan is about to finalize the output plans. */
-    finalizeOutputPlans(): void;
-    addStep($step: ExecutableStep): number;
-    /**
-     * @internal
-     */
-    addLayerPlan(layerPlan: LayerPlan): number;
-    /**
-     * @internal
-     */
-    addOutputPlan(outputPlan: OutputPlan): void;
-    /**
-     * HIGHLY EXPERIMENTAL!
-     *
-     * @internal
-     */
-    deleteLayerPlan(layerPlan: LayerPlan): void;
-    getStepById(id: number): ExecutableStep;
-    getStepById(id: number, allowUnset: true): ExecutableStep | null;
-    addStepDependency($dependent: ExecutableStep, $dependency: ExecutableStep): number;
-    setOutputPlanRootStep(outputPlan: OutputPlan, $dependency: ExecutableStep): void;
-    setLayerPlanRootStep(layerPlan: LayerPlan, $dependency: ExecutableStep): void;
-    /** @internal */
-    replaceStep($original: ExecutableStep, $replacement: ExecutableStep): void;
-    treeShakeSteps(): void;
-    /**
-     * Return true if this step can be tree-shaken.
-     */
-    private isNotNeeded;
-    /**
-     * Only for use during planField.
-     */
-    purgeBackTo(count: number): void;
-    /**
-     * ONLY CALL THIS IF NOTHING DEPENDS ON $original! It's intended to be called
-     * from `replaceStep` or from itself.
-     *
-     * This method removes $original from the various maps/sets/lists, and also
-     * removes the fact that it was dependent on other steps. If these other
-     * steps no longer have any dependents (steps, layer plans or output plans)
-     * then they can also be eradicated _except_ during the 'plan' phase.
-     */
-    private eradicate;
-    moveStepToLayerPlan(step: ExecutableStep, targetLayerPlan: LayerPlan): void;
-    addStepToItsLayerPlan(step: ExecutableStep): void;
-    removeStepFromItsLayerPlan(step: ExecutableStep): void;
-}
+export {};
 //# sourceMappingURL=StepTracker.d.ts.map

package/dist/engine/StepTracker.js

@@ -2,17 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StepTracker = void 0;
 const dev_js_1 = require("../dev.js");
+const inspect_js_1 = require("../inspect.js");
 const interfaces_js_1 = require("../interfaces.js");
-/**
- * We want everything else to treat things like `dependencies` as read only,
- * however we ourselves want to be able to write to them, so we can use
- * writeable for this.
- *
- * @internal
- */
-function writeableArray(a) {
-    return a;
-}
+const step_js_1 = require("../step.js");
+const utils_js_1 = require("../utils.js");
+const lock_js_1 = require("./lock.js");
 /**
  * This class keeps track of all of our steps, and the dependencies between
  * steps and other steps, layer plans and steps, and output plans and steps.
@@ -28,13 +22,17 @@ class StepTracker {
         /** @internal */
         this.stepCount = 0;
         /** @internal */
+        this.lockedStepCount = 0;
+        /** @internal */
         this.activeSteps = new Set();
         /** @internal */
         this.stepById = [];
         /** @internal */
         this.aliasesById = [];
         /** @internal */
-        this.stepsWithNoDependencies = new Set();
+        this.stepsWithNoDependenciesByConstructor = new Map();
+        /** @internal */
+        this.internalDependencies = new Set();
         /** @internal */
         this.outputPlansByRootStep = new Map();
         /** @internal */
@@ -77,7 +75,13 @@ class StepTracker {
     addStep($step) {
         const stepId = this.stepCount++;
         this.activeSteps.add($step);
-        this.stepsWithNoDependencies.add($step);
+        const ctor = $step.constructor;
+        let stepsWithNoDependencies = this.stepsWithNoDependenciesByConstructor.get(ctor);
+        if (!stepsWithNoDependencies) {
+            stepsWithNoDependencies ??= new Set();
+            this.stepsWithNoDependenciesByConstructor.set(ctor, stepsWithNoDependencies);
+        }
+        stepsWithNoDependencies.add($step);
         this.stepById[stepId] = $step;
         this.aliasesById[stepId] = undefined;
         this.addStepToItsLayerPlan($step);
@@ -212,21 +216,72 @@ class StepTracker {
         }
         return step;
     }
-    addStepDependency($dependent, $dependency) {
+    addStepDependency(raw$dependent, options) {
+        const $dependent = (0, utils_js_1.sudo)(raw$dependent);
+        const $dependency = (0, utils_js_1.sudo)(options.step);
         if (!this.activeSteps.has($dependent)) {
             throw new Error(`Cannot add ${$dependency} as a dependency of ${$dependent}; the latter is deleted!`);
         }
         if (!this.activeSteps.has($dependency)) {
             throw new Error(`Cannot add ${$dependency} as a dependency of ${$dependent}; the former is deleted!`);
         }
-        this.stepsWithNoDependencies.delete($dependent);
-        const dependencyIndex = writeableArray($dependent.dependencies).push($dependency) - 1;
-        writeableArray($dependency.dependents).push({
+        if ($dependent.isFinalized) {
+            throw new Error("You cannot add a dependency after the step is finalized.");
+        }
+        if (!($dependency instanceof step_js_1.Step)) {
+            throw new Error(`Error occurred when adding dependency for '${$dependent}', value passed was not a step, it was '${(0, inspect_js_1.inspect)($dependency)}'`);
+        }
+        if (dev_js_1.isDev) {
+            // Check that we can actually add this as a dependency
+            if (!$dependent.layerPlan.ancestry.includes($dependency.layerPlan)) {
+                throw new Error(
+                //console.error(
+                // This is not a GrafastInternalError
+                `Attempted to add '${$dependency}' (${$dependency.layerPlan}) as a dependency of '${$dependent}' (${$dependent.layerPlan}), but we cannot because that LayerPlan isn't an ancestor`);
+            }
+        }
+        const dependentDependencies = (0, utils_js_1.writeableArray)($dependent.dependencies);
+        const dependentDependencyForbiddenFlags = (0, utils_js_1.writeableArray)($dependent.dependencyForbiddenFlags);
+        const dependentDependencyOnReject = (0, utils_js_1.writeableArray)($dependent.dependencyOnReject);
+        const { skipDeduplication, acceptFlags = interfaces_js_1.ALL_FLAGS & ~$dependent.defaultForbiddenFlags, onReject, } = options;
+        // When copying dependencies between classes, we might not want to
+        // deduplicate because we might refer to the dependency by its index. As
+        // such, we should only dedupe by default but allow opting out.
+        // TODO: change this to `!skipDeduplication`
+        if (skipDeduplication === false) {
+            const existingIndex = dependentDependencies.indexOf($dependency);
+            if (existingIndex >= 0) {
+                return existingIndex;
+            }
+        }
+        if (!$dependency._isUnary && $dependent._isUnary) {
+            if ($dependent._isUnaryLocked) {
+                throw new Error(`Attempted to add non-unary step ${$dependency} as a dependency of ${$dependent}; but the latter is unary, so it cannot depend on batch steps`);
+            }
+            $dependent._isUnary = false;
+        }
+        const forbiddenFlags = interfaces_js_1.ALL_FLAGS & ~(acceptFlags & interfaces_js_1.TRAPPABLE_FLAGS);
+        this.stepsWithNoDependenciesByConstructor
+            .get($dependent.constructor)
+            ?.delete($dependent);
+        const dependencyIndex = dependentDependencies.push($dependency) - 1;
+        dependentDependencyForbiddenFlags[dependencyIndex] = forbiddenFlags;
+        dependentDependencyOnReject[dependencyIndex] = onReject;
+        (0, utils_js_1.writeableArray)($dependency.dependents).push({
             step: $dependent,
             dependencyIndex,
         });
         return dependencyIndex;
     }
+    addStepUnaryDependency($dependent, options) {
+        const $dependency = options.step;
+        if (!$dependency._isUnary) {
+            const { nonUnaryMessage = defaultNonUnaryMessage } = options;
+            throw new Error(nonUnaryMessage($dependent, $dependency));
+        }
+        $dependency._isUnaryLocked = true;
+        return this.addStepDependency($dependent, options);
+    }
     setOutputPlanRootStep(outputPlan, $dependency) {
         if (!this.activeSteps.has($dependency)) {
             throw new Error(`Cannot add ${$dependency} to ${outputPlan} because it's deleted`);
@@ -307,9 +362,9 @@ class StepTracker {
             // Transfer step dependents of $original to $replacement
             const dependents = $original.dependents;
             if (dependents.length > 0) {
-                const replacementDependents = writeableArray($replacement.dependents);
+                const replacementDependents = (0, utils_js_1.writeableArray)($replacement.dependents);
                 for (const dependent of dependents) {
-                    writeableArray(dependent.step.dependencies)[dependent.dependencyIndex] = $replacement;
+                    (0, utils_js_1.writeableArray)((0, utils_js_1.sudo)(dependent.step).dependencies)[dependent.dependencyIndex] = $replacement;
                     replacementDependents.push(dependent);
                 }
                 $original.dependents = [];
@@ -389,6 +444,9 @@ class StepTracker {
             return false;
         if ($step.hasSideEffects)
             return false;
+        if (this.internalDependencies.has($step)) {
+            return false;
+        }
         const s1 = this.outputPlansByRootStep.get($step);
         if (s1 && s1.size !== 0)
             return false;
@@ -456,7 +514,7 @@ class StepTracker {
             this.stepById[$original.id] = null;
         }
         // Since this step is being removed, it doesn't need its dependencies any more
-        const oldDependencies = $original.dependencies;
+        const oldDependencies = (0, utils_js_1.sudo)($original).dependencies;
         for (const $dependency of oldDependencies) {
             // $dependency is no longer a dependent of $original, since we're getting
             // rid of $original
@@ -494,7 +552,9 @@ class StepTracker {
                 ]}`);
             }
         }
-        this.stepsWithNoDependencies.delete($original);
+        this.stepsWithNoDependenciesByConstructor
+            .get($original.constructor)
+            ?.delete($original);
         this.outputPlansByRootStep.delete($original);
         this.layerPlansByRootStep.delete($original);
         this.layerPlansByParentStep.delete($original);
@@ -519,6 +579,20 @@ class StepTracker {
     removeStepFromItsLayerPlan(step) {
         step.layerPlan.stepsByConstructor.get(step.constructor).delete(step);
     }
+    lockNewSteps() {
+        if (!dev_js_1.isDev)
+            return;
+        for (let i = this.lockedStepCount; i < this.stepCount; i++) {
+            const step = this.getStepById(i, true);
+            if (step && step.id === i) {
+                (0, lock_js_1.lock)(step);
+            }
+        }
+        this.lockedStepCount = this.stepCount;
+    }
 }
 exports.StepTracker = StepTracker;
+function defaultNonUnaryMessage($dependent, $dependency) {
+    return `${$dependent} attempted to create a unary step dependency on ${$dependency}, but that step is not unary. See https://err.red/gud`;
+}
 //# sourceMappingURL=StepTracker.js.map

package/dist/engine/executeBucket.d.ts

@@ -1,8 +1,6 @@
-import type { Bucket, RequestTools } from "../bucket.js";
-import type { PromiseOrDirect } from "../interfaces.js";
-import type { MetaByMetaKey } from "./OperationPlan.js";
-/** @internal */
-export declare function executeBucket(bucket: Bucket, requestContext: RequestTools): PromiseOrDirect<void>;
-/** @internal */
-export declare function newBucket(spec: Pick<Bucket, "layerPlan" | "store" | "size" | "hasErrors" | "polymorphicPathList" | "iterators">, parentMetaByMetaKey: MetaByMetaKey | null): Bucket;
+import type { Bucket } from "../bucket.js";
+import type { BatchExecutionValue, ExecutionEntryFlags, UnaryExecutionValue } from "../interfaces.js";
+export declare function bucketToString(this: Bucket): string;
+export declare function batchExecutionValue<TData>(entries: TData[], _flags?: ExecutionEntryFlags[]): BatchExecutionValue<TData>;
+export declare function unaryExecutionValue<TData>(value: TData, _entryFlags?: ExecutionEntryFlags): UnaryExecutionValue<TData>;
 //# sourceMappingURL=executeBucket.d.ts.map