@farm.js/core 0.1.61 → 0.1.63

package/dist/chunk-IAPTECEB.mjs

@@ -0,0 +1,48 @@
+// src/client-observers.ts
+function notifyClientObserver(observer, args, label = "Client lifecycle") {
+  if (!observer) return;
+  const report = (error) => {
+    const reportError = globalThis.reportError;
+    if (typeof reportError === "function") {
+      try {
+        reportError.call(globalThis, error);
+        return;
+      } catch {
+      }
+    }
+    try {
+      console.error(`[Farm.js] ${label} callback failed:`, error);
+    } catch {
+    }
+  };
+  try {
+    const result = observer(...args);
+    if (result && typeof result.then === "function")
+      void Promise.resolve(result).catch(report);
+  } catch (error) {
+    report(error);
+  }
+}
+
+// src/client-retry.ts
+var MAX_TIMER_DELAY = 2147483647;
+function resolveClientRetryCount(value) {
+  const count = value ?? 0;
+  if (!Number.isSafeInteger(count) || count < 0) {
+    throw new RangeError("retry.count must be a non-negative safe integer");
+  }
+  return count;
+}
+function resolveClientRetryDelay(value) {
+  const delay = value ?? 0;
+  if (!Number.isFinite(delay) || delay < 0 || delay > MAX_TIMER_DELAY) {
+    throw new RangeError(`retry.delay must be between 0 and ${MAX_TIMER_DELAY} milliseconds`);
+  }
+  return delay;
+}
+
+export {
+  notifyClientObserver,
+  resolveClientRetryCount,
+  resolveClientRetryDelay
+};

package/dist/chunk-IFTGERT3.mjs

@@ -0,0 +1,408 @@
+// src/client/plugin.ts
+function defineClient(definition) {
+  return definition;
+}
+var PERFORMANCE_ENTRY_TYPES = [
+  "navigation",
+  "paint",
+  "largest-contentful-paint",
+  "layout-shift",
+  "event"
+];
+var FarmClientPluginManager = class {
+  constructor(registrations, options) {
+    this.instances = [];
+    this.performanceObservers = [];
+    this.navigationSequence = 0;
+    this.starting = false;
+    this.started = false;
+    this.closed = false;
+    this.reportedErrors = /* @__PURE__ */ new WeakSet();
+    this.handleWindowError = (event) => {
+      const error = event.error ?? new Error(event.message || "Unknown browser error");
+      void this.reportError(error, "window", void 0, this.getLocation(), event);
+    };
+    this.handleUnhandledRejection = (event) => {
+      void this.reportError(
+        event.reason,
+        "unhandled-rejection",
+        void 0,
+        this.getLocation(),
+        event
+      );
+    };
+    this.handlePageHide = (event) => {
+      if (event.persisted) return;
+      void this.close("pagehide");
+    };
+    this.registrations = sortRegistrations(registrations);
+    this.options = {
+      ...options,
+      isDev: options.isDev ?? false,
+      isProd: options.isProd ?? !options.isDev,
+      window: options.window ?? (typeof window !== "undefined" ? window : void 0)
+    };
+  }
+  start() {
+    if (this.startPromise) return this.startPromise;
+    this.startPromise = Promise.resolve().then(() => this.startInternal());
+    return this.startPromise;
+  }
+  async beginHydration(input) {
+    await this.start();
+    const session = {
+      ...input,
+      location: this.getLocation(),
+      startedAt: now()
+    };
+    await this.runHook(
+      "hydration.before",
+      (instance) => instance.plugin.hydration?.before?.({
+        ...this.createStateEvent(instance),
+        ...session
+      })
+    );
+    return session;
+  }
+  async completeHydration(session, options = {}) {
+    await this.runHook(
+      "hydration.after",
+      (instance) => instance.plugin.hydration?.after?.({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt,
+        recovered: options.recovered ?? false
+      })
+    );
+  }
+  async failHydration(session, error) {
+    await this.reportError(error, "hydration", void 0, session.location);
+  }
+  async beginNavigation(input) {
+    await this.start();
+    this.currentNavigation?.controller.abort("superseded");
+    const controller = new AbortController();
+    const session = {
+      id: `navigation:${++this.navigationSequence}`,
+      from: input.from === null ? null : toClientLocation(input.from ?? this.getLocation().href, this.getBaseUrl()),
+      to: toClientLocation(input.to, this.getBaseUrl()),
+      action: input.action,
+      signal: controller.signal,
+      startedAt: now(),
+      route: input.route
+    };
+    this.currentNavigation = { controller, session };
+    await this.runHook(
+      "navigation.before",
+      (instance) => instance.plugin.navigation?.before?.({
+        ...this.createStateEvent(instance),
+        ...session
+      })
+    );
+    return session;
+  }
+  async markNavigationLoaded(session, data) {
+    if (session.signal.aborted) return;
+    await this.runHook(
+      "navigation.loaded",
+      (instance) => instance.plugin.navigation?.loaded?.({
+        ...this.createStateEvent(instance),
+        ...session,
+        data,
+        durationMs: now() - session.startedAt
+      })
+    );
+  }
+  cancelNavigation(session, reason = "canceled") {
+    const current = this.currentNavigation;
+    if (!current || session && current.session !== session) return;
+    current.controller.abort(reason);
+    this.currentNavigation = void 0;
+  }
+  async resolveNavigation(session) {
+    if (session.signal.aborted) return;
+    await this.runHook(
+      "navigation.resolved",
+      (instance) => instance.plugin.navigation?.resolved?.({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt
+      })
+    );
+  }
+  scheduleNavigationRendered(session) {
+    if (session.signal.aborted) return Promise.resolve();
+    const clientWindow = this.options.window;
+    const schedule = clientWindow?.requestAnimationFrame ? (callback) => clientWindow.requestAnimationFrame(() => clientWindow.requestAnimationFrame(callback)) : (callback) => setTimeout(callback, 0);
+    return new Promise((resolve) => {
+      schedule(() => {
+        if (session.signal.aborted || this.closed) {
+          resolve();
+          return;
+        }
+        void this.runHook(
+          "navigation.rendered",
+          (instance) => instance.plugin.navigation?.rendered?.({
+            ...this.createStateEvent(instance),
+            ...session,
+            durationMs: now() - session.startedAt
+          })
+        ).finally(() => {
+          if (this.currentNavigation?.session === session) {
+            this.currentNavigation = void 0;
+          }
+          resolve();
+        });
+      });
+    });
+  }
+  async failNavigation(session, error) {
+    if (!session.signal.aborted) {
+      await this.runHook(
+        "navigation.error",
+        (instance) => instance.plugin.navigation?.error?.({
+          ...this.createStateEvent(instance),
+          ...session,
+          durationMs: now() - session.startedAt,
+          error
+        })
+      );
+      await this.reportError(error, "navigation", session, session.to);
+    }
+    if (this.currentNavigation?.session === session) {
+      this.currentNavigation = void 0;
+    }
+  }
+  async reportError(error, phase, navigation, location = this.getLocation(), sourceEvent) {
+    if (this.closed) return;
+    if (isObject(error)) {
+      if (this.reportedErrors.has(error)) return;
+      this.reportedErrors.add(error);
+    }
+    if (!this.started && !this.starting) await this.start();
+    if (this.closed) return;
+    await this.runErrorHooks({ error, phase, navigation, location }, void 0, sourceEvent);
+  }
+  close(reason = "manual") {
+    if (this.closePromise) return this.closePromise;
+    this.closePromise = this.closeInternal(reason);
+    return this.closePromise;
+  }
+  getPlugins() {
+    return this.instances.map(({ registration }) => ({
+      name: registration.name,
+      version: registration.version
+    }));
+  }
+  async startInternal() {
+    if (this.started || this.closed) return;
+    if (process.env.NODE_ENV !== "production" && this.options.isDev && this.options.window) {
+      try {
+        const { createFarmRuntimeErrorOverlay } = await import("@farm.js/core/internal/client-error-overlay");
+        this.runtimeErrorOverlay = createFarmRuntimeErrorOverlay({ window: this.options.window });
+      } catch (error) {
+        this.logHookError("farm:runtime-error-overlay", "load", error);
+      }
+    }
+    this.starting = true;
+    try {
+      for (const registration of this.registrations) {
+        try {
+          const definition = registration.definition;
+          if (!definition || typeof definition !== "object") {
+            throw new TypeError(
+              `Client plugin "${registration.name}" does not define a lifecycle object`
+            );
+          }
+          const instance = {
+            registration,
+            plugin: definition,
+            state: void 0
+          };
+          instance.state = await definition.setup?.(this.createSetupEvent(instance));
+          this.instances.push(instance);
+        } catch (error) {
+          this.logHookError(registration.name, "setup", error);
+          await this.runErrorHooks({
+            error,
+            phase: "setup",
+            location: this.getLocation()
+          });
+        }
+      }
+      this.started = true;
+      this.installBrowserListeners();
+      this.installPerformanceObservers();
+    } finally {
+      this.starting = false;
+    }
+  }
+  installBrowserListeners() {
+    const clientWindow = this.options.window;
+    if (!clientWindow) return;
+    if (this.runtimeErrorOverlay || this.instances.some(({ plugin }) => plugin.error)) {
+      clientWindow.addEventListener("error", this.handleWindowError);
+      clientWindow.addEventListener("unhandledrejection", this.handleUnhandledRejection);
+    }
+    clientWindow.addEventListener("pagehide", this.handlePageHide);
+  }
+  installPerformanceObservers() {
+    if (!this.instances.some(({ plugin }) => plugin.performance)) return;
+    const Observer = typeof PerformanceObserver !== "undefined" ? PerformanceObserver : void 0;
+    if (!Observer) return;
+    const supported = new Set(Observer.supportedEntryTypes || []);
+    for (const type of PERFORMANCE_ENTRY_TYPES) {
+      if (!supported.has(type)) continue;
+      try {
+        const observer = new Observer((list) => {
+          for (const entry of list.getEntries()) {
+            void this.runHook(
+              "performance",
+              (instance) => instance.plugin.performance?.({
+                ...this.createStateEvent(instance),
+                entry,
+                location: this.getLocation()
+              })
+            );
+          }
+        });
+        observer.observe({ type, buffered: true });
+        this.performanceObservers.push(observer);
+      } catch (error) {
+        void this.reportError(error, "performance");
+      }
+    }
+  }
+  async closeInternal(reason) {
+    if (this.closed) return;
+    if (this.startPromise) await this.startPromise;
+    this.closed = true;
+    this.currentNavigation?.controller.abort(reason);
+    this.currentNavigation = void 0;
+    const clientWindow = this.options.window;
+    clientWindow?.removeEventListener("error", this.handleWindowError);
+    clientWindow?.removeEventListener("unhandledrejection", this.handleUnhandledRejection);
+    clientWindow?.removeEventListener("pagehide", this.handlePageHide);
+    for (const observer of this.performanceObservers) observer.disconnect();
+    this.performanceObservers.length = 0;
+    this.runtimeErrorOverlay?.destroy();
+    for (const instance of [...this.instances].reverse()) {
+      try {
+        await instance.plugin.close?.({
+          ...this.createStateEvent(instance),
+          reason
+        });
+      } catch (error) {
+        this.logHookError(instance.registration.name, "close", error);
+      }
+    }
+  }
+  async runHook(hook, invoke) {
+    for (const instance of this.instances) {
+      try {
+        await invoke(instance);
+      } catch (error) {
+        this.logHookError(instance.registration.name, hook, error);
+        await this.runErrorHooks(
+          {
+            error,
+            phase: `plugin:${hook}`,
+            location: this.getLocation()
+          },
+          instance
+        );
+      }
+    }
+  }
+  async runErrorHooks(event, excluded, sourceEvent) {
+    this.runtimeErrorOverlay?.show(event.error, {
+      phase: event.phase,
+      location: event.location,
+      sourceEvent
+    });
+    for (const instance of this.instances) {
+      if (instance === excluded || !instance.plugin.error) continue;
+      try {
+        await instance.plugin.error({
+          ...this.createStateEvent(instance),
+          ...event
+        });
+      } catch (error) {
+        this.logHookError(instance.registration.name, "error", error);
+      }
+    }
+  }
+  createSetupEvent(instance) {
+    return {
+      plugin: {
+        name: instance.registration.name,
+        version: instance.registration.version
+      },
+      public: readonlyPublicData(instance.registration.public),
+      router: this.options.router,
+      isDev: Boolean(this.options.isDev),
+      isProd: Boolean(this.options.isProd),
+      deploymentId: this.options.deploymentId
+    };
+  }
+  createStateEvent(instance) {
+    return {
+      ...this.createSetupEvent(instance),
+      state: instance.state
+    };
+  }
+  getLocation() {
+    const href = this.options.window?.location.href ?? "http://localhost/";
+    return toClientLocation(href, href);
+  }
+  getBaseUrl() {
+    return this.options.window?.location.href ?? "http://localhost/";
+  }
+  logHookError(name, hook, error) {
+    console.error(`[Farm.js] Client plugin "${name}" failed in ${hook}:`, error);
+  }
+};
+function createClientPluginManager(registrations, options) {
+  return new FarmClientPluginManager(registrations, options);
+}
+function sortRegistrations(registrations) {
+  const rank = (enforce) => enforce === "pre" ? 0 : enforce === "post" ? 2 : 1;
+  return registrations.map((registration, index) => ({ registration, index })).sort(
+    (left, right) => rank(left.registration.enforce) - rank(right.registration.enforce) || left.index - right.index
+  ).map(({ registration }) => registration);
+}
+function toClientLocation(input, base) {
+  if (typeof input === "object" && "href" in input && "pathname" in input) {
+    return {
+      href: input.href,
+      pathname: input.pathname,
+      search: input.search,
+      hash: input.hash
+    };
+  }
+  const url = new URL(input, base);
+  return {
+    href: url.href,
+    pathname: url.pathname,
+    search: url.search,
+    hash: url.hash
+  };
+}
+function readonlyPublicData(value) {
+  if (value && typeof value === "object") {
+    return Object.freeze(value);
+  }
+  return value;
+}
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+
+export {
+  defineClient,
+  FarmClientPluginManager,
+  createClientPluginManager
+};

package/dist/chunk-IGL6CO6M.mjs

@@ -0,0 +1,9 @@
+// src/cli-colors.ts
+import picocolors from "picocolors";
+function createCliColors(interactive = process.stdout.isTTY === true) {
+  return picocolors.createColors(interactive);
+}
+
+export {
+  createCliColors
+};