@natilon/cms-server 0.1.0

package/src/adapters/github-content.mjs

@@ -0,0 +1,272 @@
+/**
+ * GitHub Contents API adapter — serverless content backend.
+ *
+ * Every writePage/createPage/deletePage is an immediate commit to GitHub.
+ * No git binary required. Safe to run on Vercel, Cloudflare Workers, etc.
+ *
+ * Config (cms.config.mjs):
+ *   content: {
+ *     provider: "github",
+ *     githubTokenEnv: "GITHUB_TOKEN",   // PAT with repo scope
+ *     owner: "your-org",
+ *     repo:  "your-site",
+ *     branch: "main",
+ *     pagesDir: "src/pages-data",
+ *     commitMessage: (ts) => `Content updated ${ts}`,
+ *   }
+ *
+ * History is backed by GitHub's commit history for each file.
+ * restoreHistory treats the `ts` field as a commit SHA.
+ *
+ * @param {Object} opts
+ * @param {string} opts.token
+ * @param {string} opts.owner
+ * @param {string} opts.repo
+ * @param {string} opts.branch
+ * @param {string} opts.pagesDir
+ * @param {(ts: string) => string} opts.commitMessage
+ * @returns {import('./types.mjs').ContentAdapter}
+ */
+export function createGitHubContent({ token, owner, repo, branch, pagesDir, commitMessage }) {
+  const BASE = `https://api.github.com/repos/${owner}/${repo}`;
+  // SHA cache: avoid extra GET before every PUT. Invalidated on write.
+  const shaCache = new Map();
+
+  const headers = () => ({
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github+json",
+    "X-GitHub-Api-Version": "2022-11-28",
+    "User-Agent": "natilon-cms",
+    "Content-Type": "application/json",
+  });
+
+  async function apiGet(path) {
+    const r = await fetch(`${BASE}${path}`, { headers: headers() });
+    if (r.status === 404) return null;
+    if (!r.ok) throw new Error(`GitHub API ${r.status} GET ${path}`);
+    return r.json();
+  }
+
+  async function apiPut(path, body) {
+    const r = await fetch(`${BASE}${path}`, {
+      method: "PUT",
+      headers: headers(),
+      body: JSON.stringify(body),
+    });
+    if (!r.ok) {
+      const err = await r.json().catch(() => ({}));
+      throw new Error(`GitHub API ${r.status} PUT ${path}: ${err.message || ""}`);
+    }
+    return r.json();
+  }
+
+  async function apiDelete(path, body) {
+    const r = await fetch(`${BASE}${path}`, {
+      method: "DELETE",
+      headers: headers(),
+      body: JSON.stringify(body),
+    });
+    if (!r.ok) throw new Error(`GitHub API ${r.status} DELETE ${path}`);
+    return r.json();
+  }
+
+  function contentPath(collection, file) {
+    return `${pagesDir}/${collection}/${file}`;
+  }
+
+  async function getFileSha(path) {
+    if (shaCache.has(path)) return shaCache.get(path);
+    const data = await apiGet(`/contents/${path}?ref=${branch}`);
+    if (!data || Array.isArray(data)) return null;
+    shaCache.set(path, data.sha);
+    return data.sha;
+  }
+
+  function decodeContent(data) {
+    const raw = Buffer.from(data.content, "base64").toString("utf-8");
+    return JSON.parse(raw);
+  }
+
+  function encodeContent(obj) {
+    return Buffer.from(JSON.stringify(obj, null, 2), "utf-8").toString("base64");
+  }
+
+  function commitMsg() {
+    const ts = new Date().toISOString().replace("T", " ").slice(0, 19);
+    return commitMessage ? commitMessage(ts) : `Content updated ${ts}`;
+  }
+
+  function sanitize(p) {
+    return String(p).replace(/[^a-zA-Z0-9._-]/g, "");
+  }
+
+  return {
+    async listCollections() {
+      const items = await apiGet(`/contents/${pagesDir}?ref=${branch}`);
+      if (!items || !Array.isArray(items)) return [];
+      const dirs = items.filter((i) => i.type === "dir");
+      return Promise.all(
+        dirs.map(async (d) => {
+          const files = await apiGet(`/contents/${pagesDir}/${d.name}?ref=${branch}`);
+          const count = Array.isArray(files) ? files.filter((f) => f.name.endsWith(".json")).length : 0;
+          return { name: d.name, count };
+        }),
+      );
+    },
+
+    async listPages(collection, sortConfig = null) {
+      const items = await apiGet(`/contents/${pagesDir}/${collection}?ref=${branch}`);
+      if (!Array.isArray(items)) return null;
+      const jsonFiles = items.filter((i) => i.type === "file" && i.name.endsWith(".json"));
+
+      const pages = await Promise.all(
+        jsonFiles.map(async (item) => {
+          const fileData = await apiGet(`/contents/${item.path}?ref=${branch}`);
+          if (!fileData) return null;
+          shaCache.set(item.path, fileData.sha);
+          const data = decodeContent(fileData);
+          return {
+            id: data.id,
+            slug: data.slug,
+            lang: data.lang,
+            collection: data.collection,
+            title: data.meta?.title || data.meta?.name || item.name,
+            file: item.name,
+            meta: data.meta || {},
+          };
+        }),
+      );
+
+      const valid = pages.filter(Boolean);
+      if (sortConfig) {
+        const dir = sortConfig.direction === "desc" ? -1 : 1;
+        valid.sort((a, b) => {
+          const av = a.meta?.[sortConfig.field] ?? "";
+          const bv = b.meta?.[sortConfig.field] ?? "";
+          if (av < bv) return -1 * dir;
+          if (av > bv) return 1 * dir;
+          return 0;
+        });
+      } else {
+        valid.sort((a, b) => a.title.localeCompare(b.title));
+      }
+      return valid;
+    },
+
+    async readPage(collection, file) {
+      const path = contentPath(collection, sanitize(file));
+      const data = await apiGet(`/contents/${path}?ref=${branch}`);
+      if (!data || Array.isArray(data)) return null;
+      shaCache.set(path, data.sha);
+      return decodeContent(data);
+    },
+
+    async writePage(collection, file, data) {
+      const path = contentPath(collection, sanitize(file));
+      const sha = await getFileSha(path);
+      const result = await apiPut(`/contents/${path}`, {
+        message: commitMsg(),
+        content: encodeContent(data),
+        branch,
+        ...(sha ? { sha } : {}),
+      });
+      shaCache.set(path, result.content?.sha);
+    },
+
+    async createPage(collection, data) {
+      const slug = data.slug || data.id || `new-${Date.now()}`;
+      const fileName = `${sanitize(data.lang || "en")}-${sanitize(slug)}.json`;
+      const path = contentPath(collection, fileName);
+      const result = await apiPut(`/contents/${path}`, {
+        message: commitMsg(),
+        content: encodeContent(data),
+        branch,
+      });
+      shaCache.set(path, result.content?.sha);
+      return { file: fileName };
+    },
+
+    async deletePage(collection, file) {
+      const path = contentPath(collection, sanitize(file));
+      const sha = await getFileSha(path);
+      if (!sha) return false;
+      await apiDelete(`/contents/${path}`, { message: commitMsg(), sha, branch });
+      shaCache.delete(path);
+      return true;
+    },
+
+    async duplicatePage(collection, file) {
+      const src = await this.readPage(collection, file);
+      if (!src) return null;
+      const lang = src.lang || "en";
+      const baseSlug = (src.slug || "page").replace(/-copy(-\d+)?$/, "");
+      const newSlug = `${baseSlug}-copy-${Math.floor(Date.now() / 1000)}`;
+
+      function reid(blocks) {
+        if (!Array.isArray(blocks)) return blocks;
+        return blocks.map((b) => {
+          const next = { ...b, id: "b-" + Math.random().toString(36).slice(2, 9) };
+          if (Array.isArray(b.children)) next.children = b.children.map((col) => reid(col));
+          return next;
+        });
+      }
+
+      const data = {
+        ...src,
+        id: `${lang}/${newSlug}`,
+        slug: newSlug,
+        meta: { ...(src.meta || {}), title: `${src.meta?.title || newSlug} (Copy)` },
+        blocks: reid(src.blocks || []),
+      };
+      return this.createPage(collection, data);
+    },
+
+    async pendingChanges() {
+      // Every write is already committed — nothing is ever "pending"
+      return { hasChanges: false, changedFiles: 0 };
+    },
+
+    async publish() {
+      // Writes are committed instantly; trigger is external (Netlify webhook on push)
+      return { ok: true, message: "All changes are already committed to GitHub" };
+    },
+
+    async listHistory(collection, file) {
+      const path = contentPath(collection, sanitize(file));
+      const commits = await apiGet(`/commits?path=${encodeURIComponent(path)}&per_page=20&sha=${branch}`);
+      if (!Array.isArray(commits)) return [];
+      return commits.map((c) => ({
+        ts: c.sha,
+        label: c.commit.message,
+        date: c.commit.author?.date,
+        author: c.commit.author?.name || c.commit.author?.email || "",
+        size: null,
+      }));
+    },
+
+    async restoreHistory(collection, file, commitSha) {
+      const path = contentPath(collection, sanitize(file));
+      const fileData = await apiGet(`/contents/${path}?ref=${commitSha}`);
+      if (!fileData || Array.isArray(fileData)) return false;
+      const data = decodeContent(fileData);
+      await this.writePage(collection, file, data);
+      return true;
+    },
+
+    async listScheduled() {
+      const collections = await this.listCollections();
+      const now = new Date();
+      const due = [];
+      for (const { name } of collections) {
+        const pages = await this.listPages(name);
+        for (const page of pages || []) {
+          if (page.meta?.publishAt && new Date(page.meta.publishAt) <= now) {
+            const data = await this.readPage(name, page.file);
+            if (data?.meta?.publishAt) due.push({ collection: name, file: page.file, data });
+          }
+        }
+      }
+      return due;
+    },
+  };
+}

package/src/adapters/github-oauth.mjs

@@ -0,0 +1,174 @@
+import crypto from "crypto";
+
+const GITHUB_AUTH_URL = "https://github.com/login/oauth/authorize";
+const GITHUB_TOKEN_URL = "https://github.com/login/oauth/access_token";
+const GITHUB_USER_URL = "https://api.github.com/user";
+
+/**
+ * GitHub OAuth adapter — drop-in replacement for createBasicAuth.
+ *
+ * Config (cms.config.mjs):
+ *   auth: {
+ *     provider: "github-oauth",
+ *     githubClientIdEnv:     "GITHUB_CLIENT_ID",
+ *     githubClientSecretEnv: "GITHUB_CLIENT_SECRET",
+ *     allowedLogins: ["your-github-username"],  // whitelist
+ *     jwtSecretEnv: "JWT_SECRET",
+ *     jwtTtl: 8 * 60 * 60,
+ *   }
+ *
+ * Add to your .env:
+ *   GITHUB_CLIENT_ID=Ov23li...
+ *   GITHUB_CLIENT_SECRET=...
+ *
+ * Register callback URL in your GitHub OAuth App:
+ *   http://localhost:4001/admin/oauth/callback   (dev)
+ *   https://admin.yoursite.com/admin/oauth/callback  (prod)
+ *
+ * @param {Object} opts
+ * @param {string}   opts.clientId
+ * @param {string}   opts.clientSecret
+ * @param {string[]} opts.allowedLogins   GitHub usernames allowed in
+ * @param {string}   opts.jwtSecret
+ * @param {number}   opts.jwtTtl          Session lifetime in seconds
+ * @param {string}   [opts.realm]
+ * @returns {import('./types.mjs').AuthAdapter & { oauthRoutes: { login, callback } }}
+ */
+export function createGitHubOAuth({
+  clientId,
+  clientSecret,
+  allowedLogins = [],
+  roles = {},
+  jwtSecret,
+  jwtTtl = 8 * 60 * 60,
+  realm = "Admin",
+}) {
+  function getRole(login) {
+    if (roles[login]) return roles[login];
+    if (roles["*"]) return roles["*"];
+    return "admin";
+  }
+  const configured = Boolean(clientId && clientSecret);
+
+  function sign(header, payload) {
+    return crypto
+      .createHmac("sha256", jwtSecret)
+      .update(`${header}.${payload}`)
+      .digest("base64url");
+  }
+
+  function issueToken(claims) {
+    if (!jwtSecret) throw new Error("JWT_SECRET not set");
+    const header = Buffer.from(JSON.stringify({ alg: "HS256", typ: "JWT" })).toString("base64url");
+    const payload = Buffer.from(JSON.stringify({
+      iat: Math.floor(Date.now() / 1000),
+      exp: Math.floor(Date.now() / 1000) + jwtTtl,
+      ...claims,
+    })).toString("base64url");
+    return `${header}.${payload}.${sign(header, payload)}`;
+  }
+
+  function verifyToken(tokenStr) {
+    if (!jwtSecret) return null;
+    const parts = (tokenStr || "").split(".");
+    if (parts.length !== 3) return null;
+    const [header, payload, sig] = parts;
+    if (sign(header, payload) !== sig) return null;
+    try {
+      const data = JSON.parse(Buffer.from(payload, "base64url").toString());
+      if (data.exp < Math.floor(Date.now() / 1000)) return null;
+      return data;
+    } catch {
+      return null;
+    }
+  }
+
+  function middlewareWith(allowlist) {
+    return (req, res, next) => {
+      if (allowlist && allowlist(req)) return next();
+      const authHeader = req.headers.authorization || "";
+      if (authHeader.startsWith("Bearer ")) {
+        const claims = verifyToken(authHeader.slice(7));
+        if (claims?.type === "session") {
+          req.cmsUser = { login: claims.sub, role: getRole(claims.sub), name: claims.name };
+          return next();
+        }
+      }
+      res.status(401).json({ error: "Authentication required", loginUrl: "/admin/oauth/login" });
+    };
+  }
+
+  // OAuth route handlers — mounted by server.mjs
+  const oauthRoutes = {
+    login(req, res) {
+      const state = crypto.randomBytes(16).toString("hex");
+      const callbackUrl = `${req.protocol}://${req.get("host")}/admin/oauth/callback`;
+      const params = new URLSearchParams({
+        client_id: clientId,
+        redirect_uri: callbackUrl,
+        scope: "read:user",
+        state,
+      });
+      // state is stateless here — for production add a cookie/session store
+      res.redirect(`${GITHUB_AUTH_URL}?${params.toString()}`);
+    },
+
+    async callback(req, res) {
+      const { code } = req.query;
+      if (!code) return res.status(400).send("Missing code");
+
+      try {
+        const callbackUrl = `${req.protocol}://${req.get("host")}/admin/oauth/callback`;
+
+        // Exchange code for GitHub access token
+        const tokenRes = await fetch(GITHUB_TOKEN_URL, {
+          method: "POST",
+          headers: { Accept: "application/json", "Content-Type": "application/json" },
+          body: JSON.stringify({ client_id: clientId, client_secret: clientSecret, code, redirect_uri: callbackUrl }),
+        });
+        const tokenData = await tokenRes.json();
+        if (!tokenData.access_token) {
+          return res.status(401).send("GitHub OAuth failed: " + (tokenData.error_description || tokenData.error || "unknown"));
+        }
+
+        // Get GitHub user identity
+        const userRes = await fetch(GITHUB_USER_URL, {
+          headers: { Authorization: `Bearer ${tokenData.access_token}`, "User-Agent": "natilon-cms" },
+        });
+        const user = await userRes.json();
+
+        if (allowedLogins.length > 0 && !allowedLogins.includes(user.login)) {
+          return res.status(403).send(`GitHub user "${user.login}" is not authorised for this CMS.`);
+        }
+
+        const sessionToken = issueToken({ sub: user.login, type: "session", name: user.name || user.login });
+        res.redirect(`/admin/?token=${encodeURIComponent(sessionToken)}`);
+      } catch (err) {
+        res.status(500).send("OAuth error: " + err.message);
+      }
+    },
+  };
+
+  function verify(authHeader) {
+    if (!authHeader?.startsWith("Bearer ")) return null;
+    const claims = verifyToken(authHeader.slice(7));
+    if (!claims || claims.type !== "session") return null;
+    return { login: claims.sub, role: getRole(claims.sub), name: claims.name };
+  }
+
+  function issueSessionToken(login, name) {
+    return issueToken({ sub: login, type: "session", name });
+  }
+
+  return {
+    configured,
+    middleware: middlewareWith(null),
+    middlewareWith,
+    issueMediaToken(tenantId) {
+      return issueToken({ sub: "media", tenant_id: tenantId, type: "media" });
+    },
+    verify,
+    issueSessionToken,
+    oauthRoutes,
+  };
+}

package/src/adapters/index.mjs

@@ -0,0 +1,8 @@
+export { createFsJsonContent } from "./fs-json-content.mjs";
+export { createGitHubContent } from "./github-content.mjs";
+export { createLocalAssetsMedia } from "./local-assets-media.mjs";
+export { createCdnProxyMedia } from "./cdn-proxy-media.mjs";
+export { createBasicAuth } from "./basic-auth.mjs";
+export { createGitHubOAuth } from "./github-oauth.mjs";
+export { createNetlifyBuild } from "./build-netlify.mjs";
+export { createMediaUrl } from "./media-url.mjs";

package/src/adapters/local-assets-media.mjs

@@ -0,0 +1,69 @@
+import fs from "fs";
+import path from "path";
+
+const IMAGE_RE = /\.(png|jpg|jpeg|svg|webp|gif)$/i;
+
+/**
+ * Local-filesystem media adapter for the legacy file picker.
+ * Lists images grouped by top-level folder under `<rootDir>/<assetsDir>`.
+ *
+ * @param {Object} opts
+ * @param {string} opts.rootDir
+ * @param {string} opts.assetsDir   Relative to rootDir, e.g. "src/assets".
+ * @returns {import('./types.mjs').MediaAdapter & {urlPrefix: string}}
+ */
+export function createLocalAssetsMedia({ rootDir, assetsDir }) {
+  const ROOT = path.join(rootDir, assetsDir);
+  const URL_PREFIX = `/${assetsDir.replace(/^\/+/, "")}`;
+
+  function sanitize(p) {
+    return String(p).replace(/[^a-zA-Z0-9._-]/g, "");
+  }
+
+  function listImages(dir, prefix) {
+    const out = [];
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        out.push(...listImages(full, `${prefix}/${entry.name}`));
+      } else if (IMAGE_RE.test(entry.name)) {
+        out.push(`${prefix}/${entry.name}`);
+      }
+    }
+    return out;
+  }
+
+  return {
+    async listGrouped() {
+      if (!fs.existsSync(ROOT)) return {};
+      const folders = fs
+        .readdirSync(ROOT)
+        .filter((d) => fs.statSync(path.join(ROOT, d)).isDirectory());
+      const out = {};
+      for (const folder of folders) {
+        const files = listImages(
+          path.join(ROOT, folder),
+          `${URL_PREFIX}/${folder}`,
+        );
+        if (files.length > 0) out[folder] = files;
+      }
+      return out;
+    },
+
+    async listFolder(folder) {
+      const dir = path.join(ROOT, sanitize(folder));
+      if (!fs.existsSync(dir)) return [];
+      return listImages(dir, `${URL_PREFIX}/${sanitize(folder)}`);
+    },
+
+    resolveLocalPath(relPath) {
+      const sub = String(relPath).replace(/^\/+/, "");
+      const full = path.join(ROOT, sub);
+      if (!full.startsWith(ROOT) || !fs.existsSync(full)) return null;
+      return full;
+    },
+
+    urlPrefix: URL_PREFIX,
+  };
+}

package/src/adapters/media-url.mjs

@@ -0,0 +1,133 @@
+/**
+ * Build CDN URLs and responsive <img> props for media stored behind a
+ * CloudFront/S3 (or compatible) origin with a path-based resize behavior.
+ *
+ * Pure factory — no environment, no fs. Configure once with the consumer's
+ * `cms.config.media` settings; everything else is derived.
+ *
+ * @typedef {Object} MediaUrlConfig
+ * @property {string} cdnBase                 e.g. "https://media.natilon.com"
+ * @property {string} [resizePrefix="/_r/"]   path prefix for the resize behavior
+ * @property {number[]} [defaultWidths]       fallback srcset widths
+ * @property {string} [tenantId]              multi-tenant prefix, e.g. "natilon"
+ *
+ * @typedef {Object} ResizeParams
+ * @property {number} [w]
+ * @property {number} [h]
+ * @property {number} [q]
+ * @property {"cover"|"contain"|"fill"|"inside"|"outside"} [fit]
+ * @property {"webp"|"avif"|"jpg"|"png"} [f]
+ */
+
+/**
+ * @param {MediaUrlConfig} config
+ */
+export function createMediaUrl(config) {
+  const cdnBase = String(config.cdnBase || "").replace(/\/+$/, "");
+  const resizePrefix = (config.resizePrefix || "/_r/").replace(/\/+$/, "/");
+  const defaultWidths = config.defaultWidths || [400, 800, 1200, 1600, 2400];
+  const tenantId = config.tenantId ? `/p/${config.tenantId}` : "";
+  let cdnHost = "";
+  try {
+    cdnHost = new URL(cdnBase).hostname;
+  } catch {
+    /* empty cdnBase or invalid URL — url() will still work for absolute inputs */
+  }
+
+  function buildQuery(params) {
+    const qs = new URLSearchParams();
+    if (params?.w) qs.set("w", String(params.w));
+    if (params?.h) qs.set("h", String(params.h));
+    if (params?.q) qs.set("q", String(params.q));
+    if (params?.fit) qs.set("fit", params.fit);
+    if (params?.f) qs.set("f", params.f);
+    return qs.toString();
+  }
+
+  /** Build a CDN URL from a key or a full URL, optionally with resize params. */
+  function url(keyOrUrl, params) {
+    if (!keyOrUrl) return "";
+    const query = buildQuery(params);
+
+    if (keyOrUrl.startsWith("http://") || keyOrUrl.startsWith("https://")) {
+      if (!query) return keyOrUrl;
+      try {
+        const u = new URL(keyOrUrl);
+        if (cdnHost && u.hostname === cdnHost) {
+          const r = resizePrefix.replace(/\/$/, "");
+          if (tenantId && u.pathname.startsWith(tenantId + "/")) {
+            const rest = u.pathname.slice(tenantId.length);
+            if (!rest.startsWith(resizePrefix)) {
+              u.pathname = tenantId + r + rest;
+            }
+          } else if (!u.pathname.startsWith(resizePrefix)) {
+            u.pathname = r + u.pathname;
+          }
+        }
+        const existing = u.search.replace(/^\?/, "");
+        u.search = existing ? `${existing}&${query}` : query;
+        return u.toString();
+      } catch {
+        return `${keyOrUrl}${keyOrUrl.includes("?") ? "&" : "?"}${query}`;
+      }
+    }
+
+    const key = keyOrUrl.replace(/^\/+/, "");
+    if (!query) return `${cdnBase}${tenantId}/${key}`;
+    return `${cdnBase}${tenantId}${resizePrefix}${key}?${query}`;
+  }
+
+  /** Resolve a stored value (key, full URL, or bare name + folder hint) to a CDN URL. */
+  function resolve(value, folder, params) {
+    if (!value) return "";
+    if (value.startsWith("http://") || value.startsWith("https://")) {
+      return params ? url(value, params) : value;
+    }
+    let key = value.replace(/^\/+/, "").replace(/^src\/assets\//, "");
+    if (folder && !key.includes("/")) {
+      key = `${folder}/${key}`;
+    }
+    return url(key, params);
+  }
+
+  function pickWidths(targetW, widths) {
+    if (widths && widths.length) return [...widths].sort((a, b) => a - b);
+    if (!targetW) return defaultWidths;
+    const set = new Set();
+    for (const m of [0.5, 1, 1.5, 2]) {
+      const w = Math.round(targetW * m);
+      if (w >= 200 && w <= 2400) set.add(w);
+    }
+    return [...set].sort((a, b) => a - b);
+  }
+
+  /** Build a srcset string sized at the given widths. */
+  function srcset(value, widths, folder, params) {
+    if (!value) return "";
+    return widths.map((w) => `${resolve(value, folder, { ...params, w })} ${w}w`).join(", ");
+  }
+
+  /** Build the {src, srcset, sizes, width, height} props for a responsive <img>. */
+  function imageProps(value, opts = {}) {
+    if (!value) return { src: "" };
+    const { folder, width, height, widths, sizes = "100vw", f = "webp", q = 80, fit } = opts;
+    const widthList = pickWidths(width, widths);
+    const fallbackW =
+      width ?? widthList[Math.min(widthList.length - 1, Math.floor(widthList.length / 2))];
+    const baseParams = { f, q, ...(fit ? { fit } : {}) };
+    const src = resolve(value, folder, {
+      ...baseParams,
+      w: fallbackW,
+      ...(height ? { h: height } : {}),
+    });
+    return {
+      src,
+      srcset: srcset(value, widthList, folder, baseParams),
+      sizes,
+      width,
+      height,
+    };
+  }
+
+  return { url, resolve, srcset, imageProps, defaultWidths };
+}