@farm.js/core 0.1.51-beta.3 → 0.1.61

package/dist/chunk-JMYXO572.cjs

@@ -1,531 +0,0 @@
-"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 _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } 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; }// src/storage/index.ts
-var _unstorage = require('unstorage');
-var _memory = require('unstorage/drivers/memory'); var _memory2 = _interopRequireDefault(_memory);
-var STORAGE_MODULES_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.modules");
-function getRegisteredStorageModules() {
-  return globalThis[STORAGE_MODULES_KEY];
-}
-var loadModule = (specifier) => {
-  const registered = _optionalChain([getRegisteredStorageModules, 'call', _ => _(), 'optionalAccess', _2 => _2[specifier]]);
-  return registered ? registered() : import(
-    /* @vite-ignore */
-    specifier
-  );
-};
-function _registerFarmStorageModules(loaders) {
-  globalThis[STORAGE_MODULES_KEY] = {
-    ...getRegisteredStorageModules(),
-    ...loaders
-  };
-}
-var DATABASE_CONNECTORS = {
-  sqlite: {
-    connector: "node-sqlite",
-    module: "db0/connectors/node-sqlite"
-  },
-  "node-sqlite": {
-    connector: "node-sqlite",
-    module: "db0/connectors/node-sqlite"
-  },
-  sqlite3: {
-    connector: "sqlite3",
-    module: "db0/connectors/sqlite3"
-  },
-  "better-sqlite3": {
-    connector: "better-sqlite3",
-    module: "db0/connectors/better-sqlite3"
-  },
-  postgres: {
-    connector: "postgresql",
-    module: "db0/connectors/postgresql"
-  },
-  postgresql: {
-    connector: "postgresql",
-    module: "db0/connectors/postgresql"
-  },
-  pg: {
-    connector: "postgresql",
-    module: "db0/connectors/postgresql"
-  },
-  mysql: {
-    connector: "mysql2",
-    module: "db0/connectors/mysql2"
-  },
-  mysql2: {
-    connector: "mysql2",
-    module: "db0/connectors/mysql2"
-  },
-  pglite: {
-    connector: "pglite",
-    module: "db0/connectors/pglite"
-  },
-  planetscale: {
-    connector: "planetscale",
-    module: "db0/connectors/planetscale"
-  },
-  libsql: {
-    connector: "libsql",
-    module: "db0/connectors/libsql/node"
-  },
-  "libsql-node": {
-    connector: "libsql-node",
-    module: "db0/connectors/libsql/node"
-  },
-  "libsql-http": {
-    connector: "libsql-http",
-    module: "db0/connectors/libsql/http"
-  }
-};
-function createMemoryStorage() {
-  return _unstorage.createStorage.call(void 0, {
-    driver: _memory2.default.call(void 0, )
-  });
-}
-var GLOBAL_STORAGE_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.global");
-function readGlobalStorage() {
-  return globalThis[GLOBAL_STORAGE_KEY];
-}
-function writeGlobalStorage(storage) {
-  globalThis[GLOBAL_STORAGE_KEY] = storage;
-  return storage;
-}
-function getActiveGlobalStorage() {
-  const existing = readGlobalStorage();
-  if (existing) {
-    return existing;
-  }
-  return writeGlobalStorage(createMemoryStorage());
-}
-var globalStorage = getActiveGlobalStorage();
-function normalizeMountKey(base) {
-  return (base || "").trim().replace(/^[:/\\]+|[:/\\]+$/g, "").replace(/[\\/]+/g, ":");
-}
-function isDriverInstance(value) {
-  return !!value && typeof value === "object" && typeof value.getItem === "function" && typeof value.getKeys === "function";
-}
-function isStorageInstance(value) {
-  return !!value && typeof value === "object" && typeof value.mount === "function" && typeof value.getMount === "function";
-}
-function isStorageClient(value) {
-  return !!value && typeof value === "object" && value.kind === "farm-storage-client" && typeof value.resolveDriver === "function" && typeof value.createStorage === "function";
-}
-function isDatabaseDriverName(name) {
-  return name in DATABASE_CONNECTORS;
-}
-function extractDriverOptions(config) {
-  const source = config;
-  const {
-    client: _client,
-    driver: _driver,
-    mounts: _mounts,
-    options,
-    tableName: _tableName,
-    ...inlineOptions
-  } = source;
-  const hasInlineOptions = Object.keys(inlineOptions).length > 0;
-  if (options && typeof options === "object" && !Array.isArray(options)) {
-    return hasInlineOptions ? { ...inlineOptions, ...options } : options;
-  }
-  if (hasInlineOptions) {
-    return inlineOptions;
-  }
-  return options;
-}
-async function loadBuiltinDriver(name, options) {
-  if (name === "memory") return _memory2.default.call(void 0, );
-  const modulePath = _unstorage.builtinDrivers[name];
-  if (!modulePath) {
-    throw new Error(`Unsupported storage driver "${name}".`);
-  }
-  const module = await loadModule(modulePath);
-  return module.default(options);
-}
-async function loadDatabaseDriver(config) {
-  const connectorEntry = DATABASE_CONNECTORS[config.driver];
-  const [{ createDatabase }, connectorModule, db0DriverModule] = await Promise.all([
-    loadModule("db0"),
-    loadModule(connectorEntry.module),
-    loadModule("unstorage/drivers/db0")
-  ]);
-  const database = createDatabase(connectorModule.default(extractDriverOptions(config) || {}));
-  const driver = db0DriverModule.default({
-    database,
-    tableName: config.tableName
-  });
-  return {
-    ...driver,
-    async dispose() {
-      await database.dispose();
-    }
-  };
-}
-async function resolveDriver(config) {
-  if (config && isStorageClient(config)) {
-    return config.resolveDriver();
-  }
-  const driverInput = _nullishCoalesce(_optionalChain([config, 'optionalAccess', _3 => _3.driver]), () => ( "memory"));
-  if (typeof driverInput === "function") {
-    return await driverInput();
-  }
-  if (isDriverInstance(driverInput)) {
-    return driverInput;
-  }
-  if (isDatabaseDriverName(driverInput)) {
-    return loadDatabaseDriver(config);
-  }
-  if (driverInput === "local") {
-    return loadBuiltinDriver("fs-lite", extractDriverOptions(config));
-  }
-  return loadBuiltinDriver(
-    driverInput,
-    extractDriverOptions(config)
-  );
-}
-var STORAGE_CLIENT_MODULES_KEY = /* @__PURE__ */ Symbol.for("farmjs.storage.clientModules");
-function createStorageClientFromResolver(resolveDriver2, modules = []) {
-  let driverPromise;
-  let storagePromise;
-  const ensureDriver = () => {
-    if (driverPromise) return driverPromise;
-    const pending = Promise.resolve().then(resolveDriver2);
-    driverPromise = pending;
-    void pending.catch(() => {
-      if (driverPromise === pending) {
-        driverPromise = void 0;
-        storagePromise = void 0;
-      }
-    });
-    return pending;
-  };
-  const ensureStorage = () => {
-    if (storagePromise) return storagePromise;
-    const pending = ensureDriver().then(
-      (driver) => _unstorage.createStorage.call(void 0, {
-        driver
-      })
-    );
-    storagePromise = pending;
-    void pending.catch(() => {
-      if (storagePromise === pending) storagePromise = void 0;
-    });
-    return pending;
-  };
-  const target = {
-    kind: "farm-storage-client",
-    ready: ensureStorage,
-    createStorage: ensureStorage,
-    resolveDriver: ensureDriver,
-    [STORAGE_CLIENT_MODULES_KEY]: modules
-  };
-  return new Proxy(target, {
-    get(currentTarget, prop, receiver) {
-      if (prop === "then") {
-        return void 0;
-      }
-      if (Reflect.has(currentTarget, prop)) {
-        return Reflect.get(currentTarget, prop, receiver);
-      }
-      return (...args) => ensureStorage().then(async (storage) => {
-        const member = Reflect.get(storage, prop);
-        if (typeof member !== "function") {
-          return member;
-        }
-        const result = Reflect.apply(member, storage, args);
-        if (prop === "dispose") {
-          return Promise.resolve(result).finally(() => {
-            storagePromise = void 0;
-            driverPromise = void 0;
-          });
-        }
-        return result;
-      });
-    }
-  });
-}
-function defineStorageClient(resolveDriver2) {
-  return createStorageClientFromResolver(resolveDriver2);
-}
-function createStorageClient(config) {
-  return createStorageClientFromResolver(
-    () => resolveDriver(config),
-    _collectFarmStorageModules(config)
-  );
-}
-function driverStorage(driver) {
-  return defineStorageClient(() => typeof driver === "function" ? driver() : driver);
-}
-function databaseStorage(database, options = {}) {
-  return createStorageClientFromResolver(async () => {
-    const db0DriverModule = await loadModule("unstorage/drivers/db0");
-    const { dispose: _dispose, ...driver } = db0DriverModule.default({
-      database,
-      tableName: options.tableName
-    });
-    return driver;
-  }, ["unstorage/drivers/db0"]);
-}
-function memoryStorage() {
-  return createStorageClient({ driver: "memory" });
-}
-function localStorage(options = {}) {
-  return createStorageClient({
-    driver: "local",
-    ...options
-  });
-}
-function sqliteStorage(options) {
-  return createStorageClient({
-    driver: "sqlite",
-    ...options
-  });
-}
-function mysqlStorage(options) {
-  return createStorageClient({
-    driver: "mysql",
-    ...options
-  });
-}
-function mysql2Storage(options) {
-  return mysqlStorage(options);
-}
-function postgresStorage(options) {
-  return createStorageClient({
-    driver: "postgres",
-    ...options
-  });
-}
-function pgStorage(options) {
-  return postgresStorage(options);
-}
-function pgliteStorage(options) {
-  return createStorageClient({
-    driver: "pglite",
-    ...options
-  });
-}
-function planetscaleStorage(options) {
-  return createStorageClient({
-    driver: "planetscale",
-    ...options
-  });
-}
-function libsqlStorage(options) {
-  return createStorageClient({
-    driver: "libsql",
-    ...options
-  });
-}
-function redisStorage(options) {
-  return createStorageClient({
-    driver: "redis",
-    ...options
-  });
-}
-function s3Storage(options) {
-  return createStorageClient({
-    driver: "s3",
-    ...options
-  });
-}
-function mongodbStorage(options) {
-  return createStorageClient({
-    driver: "mongodb",
-    ...options
-  });
-}
-function upstashStorage(options) {
-  return createStorageClient({
-    driver: "upstash",
-    ...options
-  });
-}
-function netlifyBlobsStorage(options) {
-  return createStorageClient({
-    driver: "netlify-blobs",
-    ...options
-  });
-}
-function vercelKVStorage(options) {
-  return createStorageClient({
-    driver: "vercel-kv",
-    ...options
-  });
-}
-function vercelBlobStorage(options) {
-  return createStorageClient({
-    driver: "vercel-blob",
-    ...options
-  });
-}
-function collectDriverModules(config, modules) {
-  if (!config || typeof config !== "object") return;
-  if (isStorageClient(config)) {
-    const clientModules = config[STORAGE_CLIENT_MODULES_KEY];
-    if (Array.isArray(clientModules)) for (const module of clientModules) modules.add(module);
-    return;
-  }
-  if (isStorageInstance(config)) return;
-  const source = config;
-  const driver = source.driver;
-  if (typeof driver === "string") {
-    if (isDatabaseDriverName(driver)) {
-      modules.add("db0");
-      modules.add(DATABASE_CONNECTORS[driver].module);
-      modules.add("unstorage/drivers/db0");
-    } else if (driver !== "memory") {
-      const module = _unstorage.builtinDrivers[driver === "local" ? "fs-lite" : driver];
-      if (module) modules.add(module);
-    }
-  }
-  collectDriverModules(source.client, modules);
-  if (source.mounts && typeof source.mounts === "object") {
-    for (const mount of Object.values(source.mounts)) collectDriverModules(mount, modules);
-  }
-}
-function _collectFarmStorageModules(config) {
-  const modules = /* @__PURE__ */ new Set();
-  collectDriverModules(config, modules);
-  return [...modules];
-}
-async function mountNamespaces(storage, mounts) {
-  if (!mounts) {
-    return;
-  }
-  for (const [base, config] of Object.entries(mounts)) {
-    storage.mount(normalizeMountKey(base), await resolveDriver(config));
-  }
-}
-async function createFarmStorage(config = {}) {
-  if (isStorageInstance(config)) {
-    return config;
-  }
-  if (isStorageClient(config)) {
-    return config.createStorage();
-  }
-  const rootConfig = isStorageClient(config.client) ? config.client : config;
-  const storage = _unstorage.createStorage.call(void 0, {
-    driver: await resolveDriver(rootConfig)
-  });
-  try {
-    await mountNamespaces(storage, config.mounts);
-  } catch (error) {
-    await storage.dispose().catch(() => {
-    });
-    throw error;
-  }
-  return storage;
-}
-async function resolveStorageRuntimeClient(config) {
-  if (!config || isStorageInstance(config) || isStorageClient(config)) {
-    return void 0;
-  }
-  const client = config.client;
-  if (!client || isStorageInstance(client) || isStorageClient(client)) {
-    return void 0;
-  }
-  return typeof client === "function" ? await client() : client;
-}
-async function initStorage(config = {}) {
-  globalStorage = getActiveGlobalStorage();
-  const nextStorage = await createFarmStorage(config);
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(nextStorage);
-  if (previousStorage !== nextStorage) {
-    await previousStorage.dispose().catch(() => {
-    });
-  }
-  return globalStorage;
-}
-function getStorage(namespace) {
-  globalStorage = getActiveGlobalStorage();
-  const base = normalizeMountKey(namespace);
-  if (!base) {
-    if (namespace) {
-      throw new TypeError(
-        `getStorage(${JSON.stringify(namespace)}) names no namespace. Pass a non-empty name, or call getStorage() for the root store.`
-      );
-    }
-    return globalStorage;
-  }
-  const namespaced = _unstorage.prefixStorage.call(void 0, globalStorage, base);
-  const store = globalStorage;
-  const prefix = `${base}:`;
-  const stripPrefix = (key) => key.startsWith(prefix) ? key.slice(prefix.length) : key;
-  const viewUnwatchers = /* @__PURE__ */ new Set();
-  const releaseViewWatchers = async () => {
-    const current = [...viewUnwatchers];
-    viewUnwatchers.clear();
-    await Promise.all(current.map((unwatch) => unwatch()));
-  };
-  return {
-    ...namespaced,
-    // Scope the wipe to the namespace instead of the whole storage, and keep
-    // the caller's base so `clear("sessions")` cannot take unrelated keys with
-    // it. Dropping the argument silently widens a targeted clear into a
-    // namespace-wide delete.
-    async clear(base2, opts) {
-      const keys = await namespaced.getKeys(base2);
-      await Promise.all(keys.map((key) => namespaced.removeItem(key, opts)));
-    },
-    async watch(callback) {
-      const unwatch = await store.watch((event, key) => {
-        if (key.startsWith(prefix)) callback(event, stripPrefix(key));
-      });
-      viewUnwatchers.add(unwatch);
-      return async () => {
-        viewUnwatchers.delete(unwatch);
-        await unwatch();
-      };
-    },
-    async unwatch() {
-      await releaseViewWatchers();
-    },
-    async dispose() {
-      await releaseViewWatchers();
-    },
-    getMount(key = "") {
-      return store.getMount(prefix + key);
-    },
-    getMounts(base2 = "", options) {
-      return store.getMounts(prefix + base2, options).map((mount) => ({ ...mount, base: stripPrefix(mount.base) }));
-    }
-  };
-}
-async function disposeStorage() {
-  globalStorage = getActiveGlobalStorage();
-  const previousStorage = globalStorage;
-  globalStorage = writeGlobalStorage(createMemoryStorage());
-  await previousStorage.dispose().catch(() => {
-  });
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports._registerFarmStorageModules = _registerFarmStorageModules; exports.defineStorageClient = defineStorageClient; exports.createStorageClient = createStorageClient; exports.driverStorage = driverStorage; exports.databaseStorage = databaseStorage; exports.memoryStorage = memoryStorage; exports.localStorage = localStorage; exports.sqliteStorage = sqliteStorage; exports.mysqlStorage = mysqlStorage; exports.mysql2Storage = mysql2Storage; exports.postgresStorage = postgresStorage; exports.pgStorage = pgStorage; exports.pgliteStorage = pgliteStorage; exports.planetscaleStorage = planetscaleStorage; exports.libsqlStorage = libsqlStorage; exports.redisStorage = redisStorage; exports.s3Storage = s3Storage; exports.mongodbStorage = mongodbStorage; exports.upstashStorage = upstashStorage; exports.netlifyBlobsStorage = netlifyBlobsStorage; exports.vercelKVStorage = vercelKVStorage; exports.vercelBlobStorage = vercelBlobStorage; exports._collectFarmStorageModules = _collectFarmStorageModules; exports.createFarmStorage = createFarmStorage; exports.resolveStorageRuntimeClient = resolveStorageRuntimeClient; exports.initStorage = initStorage; exports.getStorage = getStorage; exports.disposeStorage = disposeStorage;

package/dist/chunk-JNYFXL7X.mjs

@@ -1,62 +0,0 @@
-// src/navigation-errors.ts
-var REDIRECT_ERROR_CODE = "FARM_REDIRECT";
-var NOT_FOUND_ERROR_CODE = "FARM_NOT_FOUND";
-var REDIRECT_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("farm.navigation.redirect");
-var NOT_FOUND_ERROR_SYMBOL = /* @__PURE__ */ Symbol.for("farm.navigation.notFound");
-function redirect(url, status = 307) {
-  throw createRedirectError(url, status);
-}
-function permanentRedirect(url) {
-  redirect(url, 308);
-}
-function notFound() {
-  const error = new Error(NOT_FOUND_ERROR_CODE);
-  error.digest = NOT_FOUND_ERROR_CODE;
-  error[NOT_FOUND_ERROR_SYMBOL] = true;
-  throw error;
-}
-function isFarmRedirectError(error) {
-  return Boolean(getFarmRedirectError(error));
-}
-function getFarmRedirectError(error) {
-  if (!error || typeof error !== "object") return null;
-  const candidate = error;
-  if (candidate[REDIRECT_ERROR_SYMBOL]) {
-    return candidate[REDIRECT_ERROR_SYMBOL];
-  }
-  if (typeof candidate.digest === "string" && candidate.digest.startsWith(`${REDIRECT_ERROR_CODE};`)) {
-    const [, status, ...urlParts] = candidate.digest.split(";");
-    const parsedStatus = Number(status);
-    if (isFarmRedirectStatus(parsedStatus)) {
-      return {
-        status: parsedStatus,
-        url: urlParts.join(";")
-      };
-    }
-  }
-  return null;
-}
-function isFarmNotFoundError(error) {
-  if (!error || typeof error !== "object") return false;
-  const candidate = error;
-  return Boolean(candidate[NOT_FOUND_ERROR_SYMBOL] || candidate.digest === NOT_FOUND_ERROR_CODE);
-}
-function createRedirectError(url, status) {
-  const error = new Error(`${REDIRECT_ERROR_CODE};${status};${url}`);
-  error.digest = `${REDIRECT_ERROR_CODE};${status};${url}`;
-  error[REDIRECT_ERROR_SYMBOL] = { url, status };
-  return error;
-}
-function isFarmRedirectStatus(status) {
-  return status === 301 || status === 302 || status === 303 || status === 307 || status === 308;
-}
-
-export {
-  redirect,
-  permanentRedirect,
-  notFound,
-  isFarmRedirectError,
-  getFarmRedirectError,
-  isFarmNotFoundError,
-  isFarmRedirectStatus
-};

package/dist/chunk-JRHGJVJH.mjs

@@ -1,44 +0,0 @@
-import {
-  compiledFarmI18nMessages,
-  getFarmI18nClientState
-} from "./chunk-PTLXHRJZ.mjs";
-
-// src/i18n/client-runtime.ts
-import IntlMessageFormat from "intl-messageformat";
-var readOwnMessage = (messages, key) => Object.prototype.hasOwnProperty.call(messages, key) ? messages[key] : void 0;
-var translate = (key, values, rich = false) => {
-  const snapshot = requireSnapshot();
-  const message = readOwnMessage(snapshot.messages, key);
-  if (message === void 0) return key;
-  const cacheKey = `${snapshot.locale}\0${key}\0${message}`;
-  let formatter = compiledFarmI18nMessages.get(cacheKey);
-  if (!formatter) {
-    formatter = new IntlMessageFormat(message, snapshot.locale);
-    compiledFarmI18nMessages.set(cacheKey, formatter);
-  }
-  const result = formatter.format(values);
-  if (rich) return Array.isArray(result) && result.length === 1 ? result[0] : result;
-  if (Array.isArray(result) && result.some((part) => typeof part !== "string")) {
-    throw new Error(`Farm i18n message "${key}" contains rich content. Render it with t.rich().`);
-  }
-  return Array.isArray(result) ? result.join("") : String(result);
-};
-var t = ((key, values) => translate(key, values));
-t.rich = (key, values) => translate(key, values, true);
-t.raw = (key) => readOwnMessage(requireSnapshot().messages, key) ?? key;
-t.has = (key) => Object.prototype.hasOwnProperty.call(requireSnapshot().messages, key);
-function createFarmClientTranslator() {
-  return ((key, ...args) => t(key, ...args));
-}
-function requireSnapshot() {
-  const snapshot = getFarmI18nClientState();
-  if (!snapshot) {
-    throw new Error("Farm i18n is not configured or has not been hydrated.");
-  }
-  return snapshot;
-}
-
-export {
-  t,
-  createFarmClientTranslator
-};