@bluelibs/runner 5.0.0 → 5.1.0

package/dist/browser/index.cjs

@@ -166,6 +166,9 @@ var symbolPhantomTask = Symbol.for(
   "runner.task.phantom"
 );
 var symbolResource = Symbol.for("runner.resource");
+var symbolResourceForkedFrom = Symbol.for(
+  "runner.resourceForkedFrom"
+);
 var symbolResourceWithConfig = Symbol.for(
   "runner.resourceWithConfig"
 );
@@ -898,6 +901,7 @@ __export(defs_exports, {
   symbolOptionalDependency: () => symbolOptionalDependency,
   symbolPhantomTask: () => symbolPhantomTask,
   symbolResource: () => symbolResource,
+  symbolResourceForkedFrom: () => symbolResourceForkedFrom,
   symbolResourceMiddleware: () => symbolResourceMiddleware,
   symbolResourceWithConfig: () => symbolResourceWithConfig,
   symbolTag: () => symbolTag,
@@ -1064,6 +1068,188 @@ function defineHook(hookDef) {
 }
 __name(defineHook, "defineHook");
 
+// src/definers/resourceFork.ts
+function resolveReId(forkId, options) {
+  const fallback = /* @__PURE__ */ __name((id2) => `${forkId}.${id2}`, "fallback");
+  const reId = options?.reId ?? fallback;
+  return (id2) => {
+    const next = reId(id2);
+    if (typeof next !== "string" || next.length === 0) {
+      throw new Error(`fork(reId) must return a non-empty string for "${id2}"`);
+    }
+    return next;
+  };
+}
+__name(resolveReId, "resolveReId");
+function remapResourceDependenciesInObject(deps, options) {
+  const remapObject = /* @__PURE__ */ __name((deps2) => {
+    const out = { ...deps2 };
+    for (const [key, value] of Object.entries(deps2)) {
+      if (isOptional(value)) {
+        const inner = value.inner;
+        if (isResource(inner)) {
+          const forked = options.getForkedResourceByBaseId(inner.id);
+          if (forked) {
+            out[key] = { ...value, inner: forked };
+          }
+        }
+        continue;
+      }
+      if (isResource(value)) {
+        const forked = options.getForkedResourceByBaseId(value.id);
+        if (forked) {
+          out[key] = forked;
+        }
+      }
+    }
+    return out;
+  }, "remapObject");
+  return remapObject(deps);
+}
+__name(remapResourceDependenciesInObject, "remapResourceDependenciesInObject");
+function toResourceOnlyRegisterItems(items) {
+  const out = [];
+  for (const item of items) {
+    if (isResourceWithConfig(item)) {
+      out.push({
+        kind: "withConfig",
+        resource: item.resource,
+        config: item.config
+      });
+      continue;
+    }
+    if (isResource(item)) {
+      out.push({ kind: "resource", resource: item });
+      continue;
+    }
+  }
+  return out;
+}
+__name(toResourceOnlyRegisterItems, "toResourceOnlyRegisterItems");
+function createDeepForkContext(forkId, options) {
+  const reId = resolveReId(forkId, options);
+  const forkedResourceByBaseId = /* @__PURE__ */ new Map();
+  const ensureForked = /* @__PURE__ */ __name((base) => {
+    const cached = forkedResourceByBaseId.get(base.id);
+    if (cached) return cached;
+    const forked = base.fork(reId(base.id), { register: "drop" });
+    forkedResourceByBaseId.set(base.id, forked);
+    const baseRegister = base.register;
+    const ensureForkedForRegisterConfig = /* @__PURE__ */ __name((config) => {
+      const items = typeof baseRegister === "function" ? baseRegister(config) : baseRegister;
+      for (const candidate of toResourceOnlyRegisterItems(items)) {
+        ensureForked(candidate.resource);
+      }
+      return items;
+    }, "ensureForkedForRegisterConfig");
+    const mapRegisterItems2 = /* @__PURE__ */ __name((items) => {
+      const resourceItems = toResourceOnlyRegisterItems(items);
+      const out = [];
+      for (const candidate of resourceItems) {
+        if (candidate.kind === "resource") {
+          out.push(ensureForked(candidate.resource));
+          continue;
+        }
+        out.push(ensureForked(candidate.resource).with(candidate.config));
+      }
+      return out;
+    }, "mapRegisterItems");
+    forked.register = typeof baseRegister === "function" ? (config) => {
+      const items = ensureForkedForRegisterConfig(config);
+      return mapRegisterItems2(items);
+    } : (() => {
+      ensureForkedForRegisterConfig(void 0);
+      return mapRegisterItems2(baseRegister);
+    })();
+    const baseDependencies = base.dependencies;
+    const remapDepsObject = /* @__PURE__ */ __name((deps) => remapResourceDependenciesInObject(deps, {
+      getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
+    }), "remapDepsObject");
+    if (!baseDependencies) {
+      forked.dependencies = baseDependencies;
+    } else {
+      forked.dependencies = (config) => {
+        ensureForkedForRegisterConfig(config);
+        const deps = typeof baseDependencies === "function" ? baseDependencies(config) : baseDependencies;
+        return remapDepsObject(deps);
+      };
+    }
+    return forked;
+  }, "ensureForked");
+  const ensureForkedForRegisterItems = /* @__PURE__ */ __name((items) => {
+    for (const candidate of toResourceOnlyRegisterItems(items)) {
+      ensureForked(candidate.resource);
+    }
+  }, "ensureForkedForRegisterItems");
+  const mapRegisterItems = /* @__PURE__ */ __name((items) => {
+    ensureForkedForRegisterItems(items);
+    const resourceItems = toResourceOnlyRegisterItems(items);
+    const out = [];
+    for (const candidate of resourceItems) {
+      if (candidate.kind === "resource") {
+        out.push(ensureForked(candidate.resource));
+        continue;
+      }
+      out.push(ensureForked(candidate.resource).with(candidate.config));
+    }
+    return out;
+  }, "mapRegisterItems");
+  const remapDependencies = /* @__PURE__ */ __name((dependencies) => {
+    if (!dependencies) return dependencies;
+    const remapObj = /* @__PURE__ */ __name((deps) => remapResourceDependenciesInObject(deps, {
+      getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
+    }), "remapObj");
+    if (typeof dependencies === "function") {
+      return (config) => remapObj(dependencies(config));
+    }
+    return remapObj(dependencies);
+  }, "remapDependencies");
+  return {
+    reId,
+    ensureForkedForRegisterItems,
+    mapRegisterItems,
+    remapDependencies,
+    getForkedResourceByBaseId: /* @__PURE__ */ __name((id2) => forkedResourceByBaseId.get(id2), "getForkedResourceByBaseId")
+  };
+}
+__name(createDeepForkContext, "createDeepForkContext");
+function resolveForkedRegisterAndDependencies(params) {
+  const { register, dependencies, forkId, options } = params;
+  const mode = options?.register ?? "keep";
+  if (mode === "drop") {
+    return { register: [], dependencies };
+  }
+  if (mode !== "deep") {
+    return { register, dependencies };
+  }
+  if (!register) {
+    return { register, dependencies };
+  }
+  const ctx = createDeepForkContext(forkId, options);
+  if (typeof register === "function") {
+    return {
+      register: /* @__PURE__ */ __name((config) => {
+        const baseItems = register(config);
+        return ctx.mapRegisterItems(baseItems);
+      }, "register"),
+      dependencies: dependencies ? (config) => {
+        const baseItems = register(config);
+        ctx.ensureForkedForRegisterItems(baseItems);
+        const baseDeps = typeof dependencies === "function" ? dependencies(config) : dependencies;
+        return remapResourceDependenciesInObject(baseDeps, {
+          getForkedResourceByBaseId: ctx.getForkedResourceByBaseId
+        });
+      } : dependencies
+    };
+  }
+  ctx.ensureForkedForRegisterItems(register);
+  return {
+    register: ctx.mapRegisterItems(register),
+    dependencies: ctx.remapDependencies(dependencies)
+  };
+}
+__name(resolveForkedRegisterAndDependencies, "resolveForkedRegisterAndDependencies");
+
 // src/definers/defineResource.ts
 function defineResource(constConfig) {
   const filePath = constConfig[symbolFilePath] || getCallerFile();
@@ -1109,12 +1295,25 @@ function defineResource(constConfig) {
         [symbolOptionalDependency]: true
       };
     },
-    fork(newId) {
-      return defineResource({
+    fork(newId, options) {
+      const forkedParts = resolveForkedRegisterAndDependencies({
+        register: constConfig.register,
+        dependencies: constConfig.dependencies,
+        forkId: newId,
+        options
+      });
+      const forked = defineResource({
         ...constConfig,
         id: newId,
+        register: forkedParts.register,
+        dependencies: forkedParts.dependencies,
         [symbolFilePath]: filePath
       });
+      forked[symbolResourceForkedFrom] = {
+        fromId: id2,
+        forkedAtFilePath: getCallerFile()
+      };
+      return forked;
     }
   };
 }