@farm.js/core 0.1.17 → 0.1.18

package/dist/chunk-I57LW5VZ.cjs

@@ -0,0 +1,94 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/base-path.ts
+var FARM_BASE_PATH = /* @__PURE__ */ Symbol.for("farm.basePath");
+function getFarmGlobalState() {
+  return globalThis;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmGlobalState, "getFarmGlobalState");
+function setFarmBasePath(basePath) {
+  getFarmGlobalState()[FARM_BASE_PATH] = normalizeFarmBasePath(basePath);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, setFarmBasePath, "setFarmBasePath");
+function getFarmBasePath() {
+  return _nullishCoalesce(getFarmGlobalState()[FARM_BASE_PATH], () => ( ""));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmBasePath, "getFarmBasePath");
+function applyFarmBasePath(href, basePath = getFarmBasePath()) {
+  const normalizedBasePath = normalizeFarmBasePath(basePath);
+  if (!normalizedBasePath || !href.startsWith("/") || href.startsWith("//")) return href;
+  const canonicalHref = canonicalizeAppRelativeHref(href);
+  if (canonicalHref === normalizedBasePath || canonicalHref.startsWith(`${normalizedBasePath}/`) || canonicalHref.startsWith(`${normalizedBasePath}?`) || canonicalHref.startsWith(`${normalizedBasePath}#`)) {
+    return canonicalHref;
+  }
+  return `${normalizedBasePath}${canonicalHref}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, applyFarmBasePath, "applyFarmBasePath");
+function canonicalizeAppRelativeHref(href) {
+  const origin = "http://farm.local";
+  const resolved = new URL(href, origin);
+  if (resolved.origin !== origin) {
+    throw new Error("Farm app-relative href cannot change the URL origin.");
+  }
+  return `${resolved.pathname}${resolved.search}${resolved.hash}`;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, canonicalizeAppRelativeHref, "canonicalizeAppRelativeHref");
+function stripFarmBasePath(pathname, basePath = getFarmBasePath()) {
+  const normalizedBasePath = normalizeFarmBasePath(basePath);
+  if (!normalizedBasePath) return pathname || "/";
+  if (pathname === normalizedBasePath) return "/";
+  if (!pathname.startsWith(`${normalizedBasePath}/`)) return pathname || "/";
+  return pathname.slice(normalizedBasePath.length) || "/";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, stripFarmBasePath, "stripFarmBasePath");
+function normalizeFarmBasePath(basePath) {
+  if (!basePath || basePath === "/") return "";
+  const hasUnstableCharacters = /* @__PURE__ */ _chunkS3JO3N4Hcjs.__name.call(void 0, (candidate) => candidate.includes("\\") || Array.from(candidate).some((character) => {
+    const code = character.charCodeAt(0);
+    return code <= 31 || code >= 127 && code <= 159;
+  }), "hasUnstableCharacters");
+  if (hasUnstableCharacters(basePath)) {
+    throw new Error("Farm basePath cannot contain backslashes or control characters.");
+  }
+  const pathname = basePath.trim();
+  if (!pathname || pathname === "/") return "";
+  if (pathname.includes("?") || pathname.includes("#")) {
+    throw new Error("Farm basePath cannot contain a query string or hash.");
+  }
+  if (pathname.startsWith("//") || /^[a-z][a-z\d+.-]*:\/\//i.test(pathname)) {
+    throw new Error('Farm basePath must be a pathname such as "/docs", not a URL.');
+  }
+  for (const segment of pathname.split("/")) {
+    let decoded = segment;
+    try {
+      decoded = decodeURIComponent(segment);
+    } catch (e) {
+    }
+    if (hasUnstableCharacters(decoded)) {
+      throw new Error("Farm basePath cannot contain backslashes or control characters.");
+    }
+    if (decoded.includes("/")) {
+      throw new Error("Farm basePath cannot contain percent-encoded path separators.");
+    }
+    if (decoded === "." || decoded === "..") {
+      throw new Error('Farm basePath cannot contain "." or ".." path segments.');
+    }
+  }
+  return `/${pathname}`.replace(/\/{2,}/g, "/").replace(/\/+$/, "");
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmBasePath, "normalizeFarmBasePath");
+function normalizeFarmConfigBasePath(basePath) {
+  return normalizeFarmBasePath(basePath) || "/";
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmConfigBasePath, "normalizeFarmConfigBasePath");
+
+
+
+
+
+
+
+
+exports.setFarmBasePath = setFarmBasePath; exports.getFarmBasePath = getFarmBasePath; exports.applyFarmBasePath = applyFarmBasePath; exports.stripFarmBasePath = stripFarmBasePath; exports.normalizeFarmBasePath = normalizeFarmBasePath; exports.normalizeFarmConfigBasePath = normalizeFarmConfigBasePath;

package/dist/chunk-I7PUUDGY.cjs

@@ -0,0 +1,389 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkH6G5INWMcjs = require('./chunk-H6G5INWM.cjs');
+
+
+var _chunkZEG3OPIBcjs = require('./chunk-ZEG3OPIB.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/client-cache.ts
+var invalidationTrackers = /* @__PURE__ */ new WeakMap();
+function trackFarmClientCacheInvalidations(cache) {
+  let trackers = invalidationTrackers.get(cache);
+  if (!trackers) {
+    trackers = /* @__PURE__ */ new Set();
+    invalidationTrackers.set(cache, trackers);
+  }
+  const keys = /* @__PURE__ */ new Set();
+  trackers.add(keys);
+  return {
+    has(key) {
+      const resolved = cache.resolveKey(key);
+      for (const invalidated of keys) {
+        if (cache.resolveKey(invalidated) === resolved) return true;
+      }
+      return false;
+    },
+    dispose() {
+      if (!trackers.delete(keys)) return;
+      keys.clear();
+      if (trackers.size === 0) invalidationTrackers.delete(cache);
+    }
+  };
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, trackFarmClientCacheInvalidations, "trackFarmClientCacheInvalidations");
+var cacheFinalizer = typeof FinalizationRegistry === "function" ? new FinalizationRegistry((unsubscribe) => unsubscribe()) : void 0;
+var DEFAULT_GC_SWEEP_INTERVAL_MS = 3e4;
+var _FarmClientDataCache = class _FarmClientDataCache {
+  constructor(options = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.aliases = /* @__PURE__ */ new Map();
+    this.aliasesByTarget = /* @__PURE__ */ new Map();
+    this.invalidatedAt = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.inflight = /* @__PURE__ */ new Map();
+    this.pendingMetadataSweeps = /* @__PURE__ */ new Set();
+    this.gcSweepIntervalMs = _nullishCoalesce(options.gcSweepIntervalMs, () => ( DEFAULT_GC_SWEEP_INTERVAL_MS));
+    if (options.subscribeToInvalidation !== false) {
+      if (typeof WeakRef === "function") {
+        const reference = new WeakRef(this);
+        const unsubscribe = _FarmClientDataCache.subscribeWeakCache(reference);
+        _optionalChain([cacheFinalizer, 'optionalAccess', _ => _.register, 'call', _2 => _2(this, unsubscribe, reference)]);
+        this.unsubscribeInvalidation = unsubscribe;
+      } else {
+        this.unsubscribeInvalidation = _chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, 
+          (key) => this.applyInvalidation(key, Date.now(), false)
+        );
+      }
+    }
+  }
+  // This closure must only capture a weak reference, never the cache itself.
+  static subscribeWeakCache(reference) {
+    const unsubscribe = _chunkZEG3OPIBcjs.subscribeFarmCacheInvalidation.call(void 0, (key) => {
+      const cache = reference.deref();
+      if (cache) cache.applyInvalidation(key, Date.now(), false);
+      else dispose();
+    });
+    function dispose() {
+      unsubscribe();
+      _optionalChain([cacheFinalizer, 'optionalAccess', _3 => _3.unregister, 'call', _4 => _4(reference)]);
+    }
+    _chunkS3JO3N4Hcjs.__name.call(void 0, dispose, "dispose");
+    return dispose;
+  }
+  get size() {
+    return this.entries.size;
+  }
+  /** @internal Attach or detach the persistence engine's observation sink. */
+  attachPersistence(sink) {
+    this.persistence = sink;
+  }
+  resolveKey(key) {
+    let resolved = key;
+    const seen = /* @__PURE__ */ new Set();
+    while (this.aliases.has(resolved) && !seen.has(resolved)) {
+      seen.add(resolved);
+      resolved = this.aliases.get(resolved);
+    }
+    return resolved;
+  }
+  get(key, now = Date.now()) {
+    const resolved = this.resolveKey(key);
+    const entry = this.entries.get(resolved);
+    if (!entry) return void 0;
+    if (entry.gcAt !== void 0 && now >= entry.gcAt) {
+      if (entry.fetching) return void 0;
+      this.entries.delete(resolved);
+      _optionalChain([this, 'access', _5 => _5.persistence, 'optionalAccess', _6 => _6.onDelete, 'call', _7 => _7(resolved)]);
+      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+      this.emit(resolved);
+      return void 0;
+    }
+    return entry;
+  }
+  set(key, entry) {
+    const resolved = this.resolveKey(key);
+    const invalidatedAt = this.invalidatedAt.get(resolved);
+    const nextEntry = invalidatedAt !== void 0 && invalidatedAt > entry.updatedAt ? { ...entry, staleAt: 0, invalidatedAt } : { ...entry, invalidatedAt: void 0 };
+    if (invalidatedAt === void 0 || entry.updatedAt >= invalidatedAt) {
+      this.invalidatedAt.delete(resolved);
+    }
+    this.entries.set(resolved, nextEntry);
+    this.pendingMetadataSweeps.delete(resolved);
+    if (nextEntry.gcAt !== void 0) this.scheduleGcSweep();
+    _optionalChain([this, 'access', _8 => _8.persistence, 'optionalAccess', _9 => _9.onSet, 'call', _10 => _10(resolved, nextEntry)]);
+    this.emit(resolved);
+    return this;
+  }
+  delete(key) {
+    const resolved = this.resolveKey(key);
+    const deleted = this.entries.delete(resolved);
+    this.inflight.delete(resolved);
+    if (deleted) _optionalChain([this, 'access', _11 => _11.persistence, 'optionalAccess', _12 => _12.onDelete, 'call', _13 => _13(resolved)]);
+    if (deleted || this.pendingMetadataSweeps.has(resolved)) {
+      this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+    }
+    this.emit(resolved);
+    return deleted;
+  }
+  clear() {
+    const keys = /* @__PURE__ */ new Set([...this.entries.keys(), ...this.listeners.keys()]);
+    this.entries.clear();
+    this.aliases.clear();
+    this.aliasesByTarget.clear();
+    this.invalidatedAt.clear();
+    this.inflight.clear();
+    this.pendingMetadataSweeps.clear();
+    _optionalChain([this, 'access', _14 => _14.persistence, 'optionalAccess', _15 => _15.onClear, 'call', _16 => _16()]);
+    for (const key of keys) this.emit(key);
+  }
+  dispose() {
+    _optionalChain([this, 'access', _17 => _17.unsubscribeInvalidation, 'optionalCall', _18 => _18()]);
+    this.unsubscribeInvalidation = void 0;
+    if (this.gcTimer !== void 0) {
+      clearTimeout(this.gcTimer);
+      this.gcTimer = void 0;
+    }
+    this.clear();
+  }
+  isStale(key, now = Date.now()) {
+    const entry = this.get(key, now);
+    return !entry || entry.invalidatedAt !== void 0 || now >= entry.staleAt;
+  }
+  invalidate(key, now = Date.now()) {
+    this.applyInvalidation(key, now, true);
+  }
+  applyInvalidation(key, now, retainUnowned) {
+    const resolved = this.resolveKey(key);
+    for (const keys of _nullishCoalesce(invalidationTrackers.get(this), () => ( []))) keys.add(resolved);
+    const entry = this.entries.get(resolved);
+    const alreadyRetained = this.invalidatedAt.has(resolved);
+    if (retainUnowned || entry || alreadyRetained || this.hasMetadataOwner(resolved)) {
+      this.invalidatedAt.set(resolved, now);
+      if (!entry && !retainUnowned && !alreadyRetained) this.pendingMetadataSweeps.add(resolved);
+    }
+    if (entry) {
+      this.entries.set(resolved, {
+        ...entry,
+        staleAt: 0,
+        invalidatedAt: now
+      });
+    }
+    this.emit(resolved, "invalidate");
+  }
+  hasMetadataOwner(key) {
+    const related = /* @__PURE__ */ new Set([key]);
+    for (const target of related) {
+      if (this.listeners.has(target) || this.inflight.has(target)) return true;
+      for (const alias of _nullishCoalesce(this.aliasesByTarget.get(target), () => ( []))) related.add(alias);
+    }
+    return false;
+  }
+  alias(alias, key) {
+    const resolved = this.resolveKey(key);
+    if (alias === resolved) return;
+    const aliasEntry = this.entries.get(alias);
+    const aliasInvalidatedAt = _nullishCoalesce(this.invalidatedAt.get(alias), () => ( _optionalChain([aliasEntry, 'optionalAccess', _19 => _19.invalidatedAt])));
+    const resolvedInvalidatedAt = this.invalidatedAt.get(resolved);
+    if (aliasEntry && !this.entries.has(resolved)) {
+      this.entries.set(resolved, aliasEntry);
+      _optionalChain([this, 'access', _20 => _20.persistence, 'optionalAccess', _21 => _21.onSet, 'call', _22 => _22(resolved, aliasEntry)]);
+    }
+    if (this.entries.delete(alias)) _optionalChain([this, 'access', _23 => _23.persistence, 'optionalAccess', _24 => _24.onDelete, 'call', _25 => _25(alias)]);
+    this.invalidatedAt.delete(alias);
+    const invalidatedAt = [aliasInvalidatedAt, resolvedInvalidatedAt].reduce(
+      (latest, value) => value === void 0 ? latest : latest === void 0 ? value : Math.max(latest, value),
+      void 0
+    );
+    const resolvedEntry = this.entries.get(resolved);
+    if (invalidatedAt !== void 0 && (!resolvedEntry || invalidatedAt > resolvedEntry.updatedAt)) {
+      this.invalidatedAt.set(resolved, invalidatedAt);
+      if (resolvedEntry) {
+        this.entries.set(resolved, {
+          ...resolvedEntry,
+          staleAt: 0,
+          invalidatedAt
+        });
+      }
+    } else if (invalidatedAt !== void 0) {
+      this.invalidatedAt.delete(resolved);
+      if (_optionalChain([resolvedEntry, 'optionalAccess', _26 => _26.invalidatedAt]) !== void 0) {
+        this.entries.set(resolved, { ...resolvedEntry, invalidatedAt: void 0 });
+      }
+    }
+    const aliasInflight = this.inflight.get(alias);
+    if (aliasInflight && !this.inflight.has(resolved)) {
+      this.inflight.set(resolved, aliasInflight);
+    }
+    this.inflight.delete(alias);
+    if (this.pendingMetadataSweeps.delete(alias) && !this.entries.has(resolved)) {
+      this.pendingMetadataSweeps.add(resolved);
+    }
+    const previousTarget = this.aliases.get(alias);
+    if (previousTarget !== resolved) {
+      const previousResolved = previousTarget !== void 0 && this.pendingMetadataSweeps.size > 0 ? this.resolveKey(alias) : void 0;
+      this.removeAlias(alias);
+      this.aliases.set(alias, resolved);
+      let aliases = this.aliasesByTarget.get(resolved);
+      if (!aliases) this.aliasesByTarget.set(resolved, aliases = /* @__PURE__ */ new Set());
+      aliases.add(alias);
+      if (previousResolved !== void 0) this.sweepPendingEntryMetadata(previousResolved);
+    }
+    this.emit(alias);
+    this.emit(resolved, this.invalidatedAt.has(resolved) ? "invalidate" : void 0);
+  }
+  subscribe(key, listener) {
+    let listeners = this.listeners.get(key);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listeners.set(key, listeners);
+    }
+    listeners.add(listener);
+    return () => {
+      listeners.delete(listener);
+      if (listeners.size === 0 && this.listeners.get(key) === listeners) {
+        this.listeners.delete(key);
+        this.sweepPendingEntryMetadata(key);
+      }
+    };
+  }
+  getInflight(key) {
+    return this.inflight.get(this.resolveKey(key));
+  }
+  setInflight(key, promise) {
+    this.inflight.set(this.resolveKey(key), promise);
+  }
+  deleteInflight(key) {
+    const resolved = this.resolveKey(key);
+    if (this.inflight.delete(resolved)) this.sweepPendingEntryMetadata(resolved);
+  }
+  scheduleGcSweep() {
+    if (this.gcSweepIntervalMs === false || this.gcTimer !== void 0) return;
+    const timer = setTimeout(() => {
+      this.gcTimer = void 0;
+      this.sweepExpiredEntries();
+    }, this.gcSweepIntervalMs);
+    _optionalChain([timer, 'access', _27 => _27.unref, 'optionalCall', _28 => _28()]);
+    this.gcTimer = timer;
+  }
+  sweepExpiredEntries(now = Date.now()) {
+    const watched = /* @__PURE__ */ new Set();
+    for (const key of this.listeners.keys()) watched.add(this.resolveKey(key));
+    let remaining = false;
+    const swept = /* @__PURE__ */ new Set();
+    for (const [key, entry] of this.entries) {
+      if (entry.gcAt === void 0) continue;
+      if (now < entry.gcAt || entry.fetching || this.inflight.has(key) || watched.has(key)) {
+        remaining = true;
+        continue;
+      }
+      this.entries.delete(key);
+      _optionalChain([this, 'access', _29 => _29.persistence, 'optionalAccess', _30 => _30.onDelete, 'call', _31 => _31(key)]);
+      swept.add(key);
+    }
+    if (swept.size > 0) this.sweepEntryMetadata(swept);
+    if (remaining) this.scheduleGcSweep();
+  }
+  /**
+   * Entry eviction alone leaves the per-key metadata behind. `invalidatedAt`
+   * marks and provisional aliases are created per query invocation, so with
+   * dynamic keys they accumulate for the lifetime of the page even though the
+   * entries they describe are long gone.
+   */
+  sweepEntryMetadata(swept) {
+    const protectedKeys = /* @__PURE__ */ new Set();
+    for (const key of swept) if (this.hasMetadataOwner(key)) protectedKeys.add(key);
+    for (const key of swept) {
+      if (this.entries.has(key)) {
+        this.pendingMetadataSweeps.delete(key);
+      } else if (protectedKeys.has(key)) {
+        this.pendingMetadataSweeps.add(key);
+      } else {
+        this.pendingMetadataSweeps.delete(key);
+        this.invalidatedAt.delete(key);
+      }
+    }
+    const related = /* @__PURE__ */ new Set();
+    const targets = new Set(swept);
+    for (const target of targets) {
+      for (const alias of _nullishCoalesce(this.aliasesByTarget.get(target), () => ( []))) {
+        related.add(alias);
+        targets.add(alias);
+      }
+    }
+    const removable = [];
+    for (const alias of related) {
+      if (this.entries.has(alias) || this.listeners.has(alias) || this.inflight.has(alias))
+        continue;
+      const resolved = this.resolveKey(alias);
+      if (!swept.has(resolved)) continue;
+      if (this.entries.has(resolved) || protectedKeys.has(resolved)) continue;
+      removable.push(alias);
+    }
+    for (const alias of removable) {
+      this.removeAlias(alias);
+      this.invalidatedAt.delete(alias);
+    }
+  }
+  removeAlias(alias) {
+    const target = this.aliases.get(alias);
+    if (target === void 0) return;
+    this.aliases.delete(alias);
+    const aliases = this.aliasesByTarget.get(target);
+    _optionalChain([aliases, 'optionalAccess', _32 => _32.delete, 'call', _33 => _33(alias)]);
+    if (_optionalChain([aliases, 'optionalAccess', _34 => _34.size]) === 0) this.aliasesByTarget.delete(target);
+  }
+  sweepPendingEntryMetadata(key) {
+    if (this.pendingMetadataSweeps.size === 0) return;
+    if (key !== void 0) {
+      const resolved = this.resolveKey(key);
+      if (this.pendingMetadataSweeps.has(resolved)) {
+        this.sweepEntryMetadata(/* @__PURE__ */ new Set([resolved]));
+      }
+      return;
+    }
+    this.sweepEntryMetadata(new Set(this.pendingMetadataSweeps));
+  }
+  emit(key, event) {
+    this.notifyListeners(key, event);
+    if (this.listeners.size === 0) return;
+    for (const [alias, target] of this.aliases) {
+      if (!this.listeners.has(alias)) continue;
+      if (this.resolveKey(target) === key) {
+        this.notifyListeners(alias, event);
+      }
+    }
+  }
+  notifyListeners(key, event) {
+    for (const listener of _nullishCoalesce(this.listeners.get(key), () => ( []))) {
+      try {
+        listener(event);
+      } catch (error) {
+        const detail = error instanceof Error ? _nullishCoalesce(error.stack, () => ( error.message)) : String(error);
+        console.warn(`[farm:client-cache] cache listener failed: ${detail}`);
+      }
+    }
+  }
+};
+_chunkS3JO3N4Hcjs.__name.call(void 0, _FarmClientDataCache, "FarmClientDataCache");
+var FarmClientDataCache = _FarmClientDataCache;
+var FARM_CLIENT_DATA_CACHE = /* @__PURE__ */ Symbol.for("farm.clientDataCache");
+var clientCacheGlobal = globalThis;
+var sharedFarmClientDataCache = _nullishCoalesce(clientCacheGlobal[FARM_CLIENT_DATA_CACHE], () => ( (clientCacheGlobal[FARM_CLIENT_DATA_CACHE] = new FarmClientDataCache())));
+function getFarmClientDataCache() {
+  return sharedFarmClientDataCache;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, getFarmClientDataCache, "getFarmClientDataCache");
+function normalizeFarmClientCacheKey(key) {
+  return typeof key === "string" ? key : _chunkH6G5INWMcjs.createRouteDataCacheKey.call(void 0, key);
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, normalizeFarmClientCacheKey, "normalizeFarmClientCacheKey");
+
+
+
+
+
+
+exports.trackFarmClientCacheInvalidations = trackFarmClientCacheInvalidations; exports.FarmClientDataCache = FarmClientDataCache; exports.getFarmClientDataCache = getFarmClientDataCache; exports.normalizeFarmClientCacheKey = normalizeFarmClientCacheKey;

package/dist/chunk-IAMRBF3Z.cjs

@@ -0,0 +1,86 @@
+"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; } }
+
+
+var _chunk6V4TDWECcjs = require('./chunk-6V4TDWEC.cjs');
+
+
+var _chunkS3JO3N4Hcjs = require('./chunk-S3JO3N4H.cjs');
+
+// src/routes.server.ts
+var _fs = require('fs');
+var _path = require('path');
+async function loadProgrammaticRouteManifests(options) {
+  const manifests = [];
+  const routeFiles = findProgrammaticRouteFiles(options.root, options.srcDir);
+  if (routeFiles.length === 0) return manifests;
+  const { getProgrammaticRouteManifest } = await import("./routes.cjs");
+  for (const filePath of routeFiles) {
+    const mod = await options.loadModule(filePath);
+    const manifest = getProgrammaticRouteManifest(mod);
+    if (manifest) {
+      manifests.push({ filePath, manifest });
+    }
+  }
+  return manifests;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, loadProgrammaticRouteManifests, "loadProgrammaticRouteManifests");
+function findProgrammaticRouteFiles(root, srcDir = "src") {
+  return findProgrammaticRouteFilesInDir(_path.join.call(void 0, root, srcDir));
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findProgrammaticRouteFiles, "findProgrammaticRouteFiles");
+function findProgrammaticRouteFilesInDir(srcRoot) {
+  const files = [];
+  for (const fileName of _chunk6V4TDWECcjs.PROGRAMMATIC_ROUTE_FILE_NAMES) {
+    const filePath = _path.join.call(void 0, srcRoot, fileName);
+    if (_fs.existsSync.call(void 0, filePath)) {
+      files.push(filePath);
+    }
+  }
+  return files;
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findProgrammaticRouteFilesInDir, "findProgrammaticRouteFilesInDir");
+async function discoverProgrammaticRoutePaths(root, srcDir = "src") {
+  const paths = /* @__PURE__ */ new Set();
+  const files = /* @__PURE__ */ new Set([
+    ...findProgrammaticRouteFiles(root, srcDir),
+    ...await findProgrammaticRouteSourceFiles(_path.join.call(void 0, root, srcDir))
+  ]);
+  for (const filePath of files) {
+    const source = _fs.readFileSync.call(void 0, filePath, "utf8");
+    for (const routePath of _chunk6V4TDWECcjs.scanProgrammaticPagePaths.call(void 0, source)) {
+      paths.add(routePath);
+    }
+  }
+  return Array.from(paths).sort();
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, discoverProgrammaticRoutePaths, "discoverProgrammaticRoutePaths");
+async function findProgrammaticRouteSourceFiles(srcRoot) {
+  if (!_fs.existsSync.call(void 0, srcRoot)) {
+    return [];
+  }
+  try {
+    const glob = await import("fast-glob");
+    return await glob.default("**/*.{ts,tsx,js,jsx}", {
+      cwd: srcRoot,
+      absolute: true,
+      ignore: [
+        "**/*.d.ts",
+        "**/node_modules/**",
+        "**/.*/**",
+        "farm-routes.d.ts",
+        "farm-env.d.ts",
+        "lib/api.generated.ts"
+      ]
+    });
+  } catch (e) {
+    return [];
+  }
+}
+_chunkS3JO3N4Hcjs.__name.call(void 0, findProgrammaticRouteSourceFiles, "findProgrammaticRouteSourceFiles");
+
+
+
+
+
+
+exports.loadProgrammaticRouteManifests = loadProgrammaticRouteManifests; exports.findProgrammaticRouteFiles = findProgrammaticRouteFiles; exports.findProgrammaticRouteFilesInDir = findProgrammaticRouteFilesInDir; exports.discoverProgrammaticRoutePaths = discoverProgrammaticRoutePaths;