@farm.js/core 0.1.17 → 0.1.19

package/dist/chunk-VB6UCX3V.cjs

@@ -0,0 +1,421 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client/plugin.ts
+function defineClient(definition) {
+  return definition;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, defineClient, "defineClient");
+var PERFORMANCE_ENTRY_TYPES = [
+  "navigation",
+  "paint",
+  "largest-contentful-paint",
+  "layout-shift",
+  "event"
+];
+var _FarmClientPluginManager = class _FarmClientPluginManager {
+  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 = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+      const error = _nullishCoalesce(event.error, () => ( new Error(event.message || "Unknown browser error")));
+      void this.reportError(error, "window", void 0, this.getLocation(), event);
+    }, "handleWindowError");
+    this.handleUnhandledRejection = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+      void this.reportError(
+        event.reason,
+        "unhandled-rejection",
+        void 0,
+        this.getLocation(),
+        event
+      );
+    }, "handleUnhandledRejection");
+    this.handlePageHide = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (event) => {
+      if (event.persisted) return;
+      void this.close("pagehide");
+    }, "handlePageHide");
+    this.registrations = sortRegistrations(registrations);
+    this.options = {
+      ...options,
+      isDev: _nullishCoalesce(options.isDev, () => ( false)),
+      isProd: _nullishCoalesce(options.isProd, () => ( !options.isDev)),
+      window: _nullishCoalesce(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) => _optionalChain([instance, 'access', _ => _.plugin, 'access', _2 => _2.hydration, 'optionalAccess', _3 => _3.before, 'optionalCall', _4 => _4({
+        ...this.createStateEvent(instance),
+        ...session
+      })])
+    );
+    return session;
+  }
+  async completeHydration(session, options = {}) {
+    await this.runHook(
+      "hydration.after",
+      (instance) => _optionalChain([instance, 'access', _5 => _5.plugin, 'access', _6 => _6.hydration, 'optionalAccess', _7 => _7.after, 'optionalCall', _8 => _8({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt,
+        recovered: _nullishCoalesce(options.recovered, () => ( false))
+      })])
+    );
+  }
+  async failHydration(session, error) {
+    await this.reportError(error, "hydration", void 0, session.location);
+  }
+  async beginNavigation(input) {
+    await this.start();
+    _optionalChain([this, 'access', _9 => _9.currentNavigation, 'optionalAccess', _10 => _10.controller, 'access', _11 => _11.abort, 'call', _12 => _12("superseded")]);
+    const controller = new AbortController();
+    const session = {
+      id: `navigation:${++this.navigationSequence}`,
+      from: input.from === null ? null : toClientLocation(_nullishCoalesce(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) => _optionalChain([instance, 'access', _13 => _13.plugin, 'access', _14 => _14.navigation, 'optionalAccess', _15 => _15.before, 'optionalCall', _16 => _16({
+        ...this.createStateEvent(instance),
+        ...session
+      })])
+    );
+    return session;
+  }
+  async markNavigationLoaded(session, data) {
+    if (session.signal.aborted) return;
+    await this.runHook(
+      "navigation.loaded",
+      (instance) => _optionalChain([instance, 'access', _17 => _17.plugin, 'access', _18 => _18.navigation, 'optionalAccess', _19 => _19.loaded, 'optionalCall', _20 => _20({
+        ...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) => _optionalChain([instance, 'access', _21 => _21.plugin, 'access', _22 => _22.navigation, 'optionalAccess', _23 => _23.resolved, 'optionalCall', _24 => _24({
+        ...this.createStateEvent(instance),
+        ...session,
+        durationMs: now() - session.startedAt
+      })])
+    );
+  }
+  scheduleNavigationRendered(session) {
+    if (session.signal.aborted) return Promise.resolve();
+    const clientWindow = this.options.window;
+    const schedule = _optionalChain([clientWindow, 'optionalAccess', _25 => _25.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) => _optionalChain([instance, 'access', _26 => _26.plugin, 'access', _27 => _27.navigation, 'optionalAccess', _28 => _28.rendered, 'optionalCall', _29 => _29({
+            ...this.createStateEvent(instance),
+            ...session,
+            durationMs: now() - session.startedAt
+          })])
+        ).finally(() => {
+          if (_optionalChain([this, 'access', _30 => _30.currentNavigation, 'optionalAccess', _31 => _31.session]) === session) {
+            this.currentNavigation = void 0;
+          }
+          resolve();
+        });
+      });
+    });
+  }
+  async failNavigation(session, error) {
+    if (!session.signal.aborted) {
+      await this.runHook(
+        "navigation.error",
+        (instance) => _optionalChain([instance, 'access', _32 => _32.plugin, 'access', _33 => _33.navigation, 'optionalAccess', _34 => _34.error, 'optionalCall', _35 => _35({
+          ...this.createStateEvent(instance),
+          ...session,
+          durationMs: now() - session.startedAt,
+          error
+        })])
+      );
+      await this.reportError(error, "navigation", session, session.to);
+    }
+    if (_optionalChain([this, 'access', _36 => _36.currentNavigation, 'optionalAccess', _37 => _37.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 _optionalChain([definition, 'access', _38 => _38.setup, 'optionalCall', _39 => _39(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) => _optionalChain([instance, 'access', _40 => _40.plugin, 'access', _41 => _41.performance, 'optionalCall', _42 => _42({
+                ...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;
+    _optionalChain([this, 'access', _43 => _43.currentNavigation, 'optionalAccess', _44 => _44.controller, 'access', _45 => _45.abort, 'call', _46 => _46(reason)]);
+    this.currentNavigation = void 0;
+    const clientWindow = this.options.window;
+    _optionalChain([clientWindow, 'optionalAccess', _47 => _47.removeEventListener, 'call', _48 => _48("error", this.handleWindowError)]);
+    _optionalChain([clientWindow, 'optionalAccess', _49 => _49.removeEventListener, 'call', _50 => _50("unhandledrejection", this.handleUnhandledRejection)]);
+    _optionalChain([clientWindow, 'optionalAccess', _51 => _51.removeEventListener, 'call', _52 => _52("pagehide", this.handlePageHide)]);
+    for (const observer of this.performanceObservers) observer.disconnect();
+    this.performanceObservers.length = 0;
+    _optionalChain([this, 'access', _53 => _53.runtimeErrorOverlay, 'optionalAccess', _54 => _54.destroy, 'call', _55 => _55()]);
+    for (const instance of [...this.instances].reverse()) {
+      try {
+        await _optionalChain([instance, 'access', _56 => _56.plugin, 'access', _57 => _57.close, 'optionalCall', _58 => _58({
+          ...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) {
+    _optionalChain([this, 'access', _59 => _59.runtimeErrorOverlay, 'optionalAccess', _60 => _60.show, 'call', _61 => _61(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 = _nullishCoalesce(_optionalChain([this, 'access', _62 => _62.options, 'access', _63 => _63.window, 'optionalAccess', _64 => _64.location, 'access', _65 => _65.href]), () => ( "http://localhost/"));
+    return toClientLocation(href, href);
+  }
+  getBaseUrl() {
+    return _nullishCoalesce(_optionalChain([this, 'access', _66 => _66.options, 'access', _67 => _67.window, 'optionalAccess', _68 => _68.location, 'access', _69 => _69.href]), () => ( "http://localhost/"));
+  }
+  logHookError(name, hook, error) {
+    console.error(`[Farm.js] Client plugin "${name}" failed in ${hook}:`, error);
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmClientPluginManager, "FarmClientPluginManager");
+var FarmClientPluginManager = _FarmClientPluginManager;
+function createClientPluginManager(registrations, options) {
+  return new FarmClientPluginManager(registrations, options);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, createClientPluginManager, "createClientPluginManager");
+function sortRegistrations(registrations) {
+  const rank = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (enforce) => enforce === "pre" ? 0 : enforce === "post" ? 2 : 1, "rank");
+  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);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, sortRegistrations, "sortRegistrations");
+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
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, toClientLocation, "toClientLocation");
+function readonlyPublicData(value) {
+  if (value && typeof value === "object") {
+    return Object.freeze(value);
+  }
+  return value;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, readonlyPublicData, "readonlyPublicData");
+function now() {
+  return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, now, "now");
+function isObject(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, isObject, "isObject");
+
+
+
+
+
+exports.defineClient = defineClient; exports.FarmClientPluginManager = FarmClientPluginManager; exports.createClientPluginManager = createClientPluginManager;