nuxt-studio 1.0.0-alpha.0 → 1.0.0-alpha.2

package/dist/module/runtime/types/content.js

@@ -0,0 +1,7 @@
+export var ContentFileExtension = /* @__PURE__ */ ((ContentFileExtension2) => {
+  ContentFileExtension2["Markdown"] = "md";
+  ContentFileExtension2["YAML"] = "yaml";
+  ContentFileExtension2["YML"] = "yml";
+  ContentFileExtension2["JSON"] = "json";
+  return ContentFileExtension2;
+})(ContentFileExtension || {});

package/dist/module/runtime/utils/activation.js

@@ -1,10 +1,19 @@
-import { getAppManifest, useState, useRuntimeConfig } from "#imports";
+import { getAppManifest, useState, useRuntimeConfig, useCookie } from "#imports";
 export async function defineStudioActivationPlugin(onStudioActivation) {
   const user = useState("studio-session", () => null);
   const config = useRuntimeConfig().public.studio;
-  await $fetch("/__nuxt_studio/auth/session").then((session) => {
-    user.value = session?.user ?? null;
-  });
+  const cookie = useCookie("studio-session-check");
+  if (config.dev) {
+    return await onStudioActivation({
+      provider: "github",
+      email: "dev@nuxt.com",
+      name: "Dev",
+      accessToken: "",
+      providerId: "",
+      avatar: ""
+    });
+  }
+  user.value = String(cookie.value) === "true" ? await $fetch("/__nuxt_studio/auth/session").then((session) => session?.user ?? null) : null;
   let mounted = false;
   if (user.value?.email) {
     const manifest = await getAppManifest();
@@ -16,7 +25,9 @@ export async function defineStudioActivationPlugin(onStudioActivation) {
   } else {
     document.addEventListener("keydown", (event) => {
       if (event.metaKey && event.key === ".") {
-        window.location.href = config.route;
+        setTimeout(() => {
+          window.location.href = config.route + "?redirect=" + encodeURIComponent(window.location.pathname);
+        });
       }
     });
   }

package/dist/module/runtime/utils/collection.d.ts

@@ -1,22 +1,15 @@
-import type { CollectionInfo, CollectionSource, Draft07, CollectionItemBase, ResolvedCollectionSource } from '@nuxt/content';
-import type { DatabaseItem } from 'nuxt-studio/app';
-export declare const getCollectionByFilePath: (path: string, collections: Record<string, CollectionInfo>) => CollectionInfo | undefined;
+import type { CollectionInfo, Draft07, ResolvedCollectionSource } from '@nuxt/content';
+/**
+ * Generation methods
+ */
 export declare function generateStemFromFsPath(path: string): string;
 export declare function generateIdFromFsPath(path: string, collectionInfo: CollectionInfo): string;
+export declare function generateFsPathFromId(id: string, source: ResolvedCollectionSource): string;
+/**
+ * Utils methods
+ */
 export declare function getOrderedSchemaKeys(schema: Draft07): string[];
-export declare function getCollection(collectionName: string, collections: Record<string, CollectionInfo>): CollectionInfo;
-export declare function getCollectionSource(id: string, collection: CollectionInfo): ResolvedCollectionSource | undefined;
-export declare function generateFsPathFromId(id: string, source: CollectionInfo['source'][0]): string;
-export declare function getCollectionInfo(id: string, collections: Record<string, CollectionInfo>): {
-    collection: CollectionInfo;
-    source: ResolvedCollectionSource | undefined;
-    fsPath: string;
-};
-export declare function parseSourceBase(source: CollectionSource): {
-    fixed: string;
-    dynamic: string;
-};
-export declare function createCollectionDocument(collection: CollectionInfo, id: string, document: CollectionItemBase): DatabaseItem;
-export declare function normalizeDocument(document: DatabaseItem): DatabaseItem;
+export declare function getCollectionByFilePath(path: string, collections: Record<string, CollectionInfo>): CollectionInfo | undefined;
+export declare function getCollectionById(id: string, collections: Record<string, CollectionInfo>): CollectionInfo;
 export declare function generateRecordInsert(collection: CollectionInfo, data: Record<string, unknown>): string;
 export declare function generateRecordDeletion(collection: CollectionInfo, id: string): string;

package/dist/module/runtime/utils/collection.js

@@ -1,26 +1,8 @@
 import { hash } from "ohash";
-import { pathMetaTransform } from "./path-meta.js";
 import { minimatch } from "minimatch";
 import { join, dirname, parse } from "pathe";
-import { withoutLeadingSlash } from "ufo";
-export const getCollectionByFilePath = (path, collections) => {
-  let matchedSource;
-  const collection = Object.values(collections).find((collection2) => {
-    if (!collection2.source || collection2.source.length === 0) {
-      return;
-    }
-    const paths = path === "/" ? ["index.yml", "index.yaml", "index.md", "index.json"] : [path];
-    return paths.some((p) => {
-      matchedSource = collection2.source.find((source) => {
-        const include = minimatch(p, source.include, { dot: true });
-        const exclude = source.exclude?.some((exclude2) => minimatch(p, exclude2));
-        return include && !exclude;
-      });
-      return matchedSource;
-    });
-  });
-  return collection;
-};
+import { withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+import { parseSourceBase } from "./source.js";
 export function generateStemFromFsPath(path) {
   return withoutLeadingSlash(join(dirname(path), parse(path).name));
 }
@@ -29,6 +11,16 @@ export function generateIdFromFsPath(path, collectionInfo) {
   const pathWithoutFixed = path.substring(fixed.length);
   return join(collectionInfo.name, collectionInfo.source[0]?.prefix || "", pathWithoutFixed);
 }
+export function generateFsPathFromId(id, source) {
+  const [_, ...rest] = id.split(/[/:]/);
+  const path = rest.join("/");
+  const { fixed } = parseSourceBase(source);
+  const normalizedFixed = withoutTrailingSlash(fixed);
+  if (normalizedFixed && path.startsWith(normalizedFixed)) {
+    return path;
+  }
+  return join(fixed, path);
+}
 export function getOrderedSchemaKeys(schema) {
   const shape = Object.values(schema.definitions)[0]?.properties || {};
   const keys = new Set([
@@ -38,84 +30,32 @@ export function getOrderedSchemaKeys(schema) {
   ].filter(Boolean));
   return Array.from(keys);
 }
-export function getCollection(collectionName, collections) {
+export function getCollectionByFilePath(path, collections) {
+  let matchedSource;
+  const collection = Object.values(collections).find((collection2) => {
+    if (!collection2.source || collection2.source.length === 0) {
+      return;
+    }
+    const paths = path === "/" ? ["index.yml", "index.yaml", "index.md", "index.json"] : [path];
+    return paths.some((p) => {
+      matchedSource = collection2.source.find((source) => {
+        const include = minimatch(p, source.include, { dot: true });
+        const exclude = source.exclude?.some((exclude2) => minimatch(p, exclude2));
+        return include && !exclude;
+      });
+      return matchedSource;
+    });
+  });
+  return collection;
+}
+export function getCollectionById(id, collections) {
+  const collectionName = id.split(/[/:]/)[0];
   const collection = collections[collectionName];
   if (!collection) {
     throw new Error(`Collection ${collectionName} not found`);
   }
   return collection;
 }
-export function getCollectionSource(id, collection) {
-  const [_, ...rest] = id.split(/[/:]/);
-  const path = rest.join("/");
-  const matchedSource = collection.source.find((source) => {
-    const include = minimatch(path, source.include, { dot: true });
-    const exclude = source.exclude?.some((exclude2) => minimatch(path, exclude2));
-    return include && !exclude;
-  });
-  return matchedSource;
-}
-export function generateFsPathFromId(id, source) {
-  const [_, ...rest] = id.split(/[/:]/);
-  const path = rest.join("/");
-  const { fixed } = parseSourceBase(source);
-  const pathWithoutFixed = path.substring(fixed.length);
-  return join(fixed, pathWithoutFixed);
-}
-export function getCollectionInfo(id, collections) {
-  const collection = getCollection(id.split(/[/:]/)[0], collections);
-  const source = getCollectionSource(id, collection);
-  const fsPath = generateFsPathFromId(id, source);
-  return {
-    collection,
-    source,
-    fsPath
-  };
-}
-export function parseSourceBase(source) {
-  const [fixPart, ...rest] = source.include.includes("*") ? source.include.split("*") : ["", source.include];
-  return {
-    fixed: fixPart || "",
-    dynamic: "*" + rest.join("*")
-  };
-}
-export function createCollectionDocument(collection, id, document) {
-  const parsedContent = [
-    pathMetaTransform
-  ].reduce((acc, fn) => collection.type === "page" ? fn(acc) : acc, { ...document, id });
-  const result = { id };
-  const meta = parsedContent.meta;
-  const collectionKeys = getOrderedSchemaKeys(collection.schema);
-  for (const key of Object.keys(parsedContent)) {
-    if (collectionKeys.includes(key)) {
-      result[key] = parsedContent[key];
-    } else {
-      meta[key] = parsedContent[key];
-    }
-  }
-  result.meta = meta;
-  if (collectionKeys.includes("seo")) {
-    const seo = result.seo = result.seo || {};
-    seo.title = seo.title || result.title;
-    seo.description = seo.description || result.description;
-  }
-  return result;
-}
-export function normalizeDocument(document) {
-  if (document?.seo) {
-    const seo = document.seo;
-    if (!seo.title || seo.title === document.title) {
-      Reflect.deleteProperty(document.seo, "title");
-    }
-    if (!seo.description || seo.description === document.description) {
-      Reflect.deleteProperty(document.seo, "description");
-    }
-    if (Object.keys(seo).length === 0) {
-      Reflect.deleteProperty(document, "seo");
-    }
-  }
-  return document;
-}
 function computeValuesBasedOnCollectionSchema(collection, data) {
   const fields = [];
   const values = [];

package/dist/module/runtime/utils/document.d.ts

@@ -0,0 +1,15 @@
+import type { CollectionInfo, CollectionItemBase } from '@nuxt/content';
+import type { DatabaseItem, DatabasePageItem } from 'nuxt-studio/app';
+export declare function normalizeDocument(id: string, collectionInfo: CollectionInfo, document: CollectionItemBase): DatabaseItem;
+export declare function pickReservedKeysFromDocument(document: DatabaseItem): DatabaseItem;
+export declare function removeReservedKeysFromDocument(document: DatabaseItem): DatabaseItem;
+export declare function isDocumentMatchingContent(content: string, document: DatabaseItem): Promise<boolean>;
+export declare function areDocumentsEqual(document1: Record<string, unknown>, document2: Record<string, unknown>): boolean;
+export declare function generateDocumentFromContent(id: string, content: string): Promise<DatabaseItem | null>;
+export declare function generateDocumentFromYAMLContent(id: string, content: string): Promise<DatabaseItem>;
+export declare function generateDocumentFromJSONContent(id: string, content: string): Promise<DatabaseItem>;
+export declare function generateDocumentFromMarkdownContent(id: string, content: string): Promise<DatabaseItem>;
+export declare function generateContentFromDocument(document: DatabaseItem): Promise<string | null>;
+export declare function generateContentFromYAMLDocument(document: DatabaseItem): Promise<string | null>;
+export declare function generateContentFromJSONDocument(document: DatabaseItem): Promise<string | null>;
+export declare function generateContentFromMarkdownDocument(document: DatabasePageItem): Promise<string | null>;

package/dist/module/runtime/utils/document.js

@@ -0,0 +1,288 @@
+import { getOrderedSchemaKeys } from "./collection.js";
+import { pathMetaTransform } from "./path-meta.js";
+import { doObjectsMatch, omit, pick } from "./object.js";
+import { ContentFileExtension } from "../types/content.js";
+import { parseMarkdown } from "@nuxtjs/mdc/runtime/parser/index";
+import { visit } from "unist-util-visit";
+import { compressTree, decompressTree } from "@nuxt/content/runtime";
+import destr from "destr";
+import { parseFrontMatter, stringifyFrontMatter } from "remark-mdc";
+import { stringify } from "minimark/stringify";
+import { stringifyMarkdown } from "@nuxtjs/mdc/runtime";
+const reservedKeys = ["id", "fsPath", "stem", "extension", "__hash__", "path", "body", "meta", "rawbody"];
+export function normalizeDocument(id, collectionInfo, document) {
+  const parsedContent = [
+    pathMetaTransform
+  ].reduce((acc, fn) => collectionInfo.type === "page" ? fn(acc) : acc, { ...document, id });
+  const result = { id };
+  const meta = parsedContent.meta;
+  const collectionKeys = getOrderedSchemaKeys(collectionInfo.schema);
+  for (const key of Object.keys(parsedContent)) {
+    if (collectionKeys.includes(key)) {
+      result[key] = parsedContent[key];
+    } else {
+      meta[key] = parsedContent[key];
+    }
+  }
+  if (meta.fsPath) {
+    Reflect.deleteProperty(meta, "fsPath");
+  }
+  result.meta = meta;
+  if (collectionKeys.includes("seo")) {
+    const seo = result.seo = result.seo || {};
+    seo.title = seo.title || result.title;
+    seo.description = seo.description || result.description;
+  }
+  return result;
+}
+export function pickReservedKeysFromDocument(document) {
+  return pick(document, reservedKeys);
+}
+export function removeReservedKeysFromDocument(document) {
+  const result = omit(document, reservedKeys);
+  if (result.navigation === true) {
+    Reflect.deleteProperty(result, "navigation");
+  }
+  if (document.seo) {
+    const seo = document.seo;
+    if ((!seo.title || seo.title === document.title) && (!seo.description || seo.description === document.description)) {
+      Reflect.deleteProperty(result, "seo");
+    }
+  }
+  if (!document.title) {
+    Reflect.deleteProperty(result, "title");
+  }
+  if (!document.description) {
+    Reflect.deleteProperty(result, "description");
+  }
+  for (const key in document.meta || {}) {
+    if (key !== "__hash__") {
+      result[key] = document.meta[key];
+    }
+  }
+  for (const key in result || {}) {
+    if (result[key] === null) {
+      Reflect.deleteProperty(result, key);
+    }
+  }
+  return result;
+}
+export async function isDocumentMatchingContent(content, document) {
+  const generatedDocument = await generateDocumentFromContent(document.id, content);
+  if (generatedDocument.extension === ContentFileExtension.Markdown) {
+    const { body: generatedBody, ...generatedDocumentData } = generatedDocument;
+    const { body: documentBody, ...documentData } = document;
+    if (stringify(withoutLastStyles(generatedBody)) !== stringify(withoutLastStyles(documentBody))) {
+      return false;
+    }
+    return doObjectsMatch(generatedDocumentData, documentData);
+  }
+  return doObjectsMatch(generatedDocument, document);
+}
+export function areDocumentsEqual(document1, document2) {
+  const { body: body1, meta: meta1, ...documentData1 } = document1;
+  const { body: body2, meta: meta2, ...documentData2 } = document2;
+  if (document1.extension === ContentFileExtension.Markdown) {
+    const minifiedBody1 = withoutLastStyles(
+      document1.body.type === "minimark" ? document1.body : compressTree(document1.body)
+    );
+    const minifiedBody2 = withoutLastStyles(
+      document2.body.type === "minimark" ? document2.body : compressTree(document2.body)
+    );
+    if (stringify(minifiedBody1) !== stringify(minifiedBody2)) {
+      return false;
+    }
+  } else if (typeof body1 === "object" && typeof body2 === "object") {
+    if (!doObjectsMatch(body1, body2)) {
+      return false;
+    }
+  } else {
+    if (JSON.stringify(body1) !== JSON.stringify(body2)) {
+      return false;
+    }
+  }
+  function refineDocumentData(doc) {
+    if (doc.seo) {
+      const seo = doc.seo;
+      doc.seo = {
+        ...seo,
+        title: seo.title || doc.title,
+        description: seo.description || doc.description
+      };
+    }
+    Reflect.deleteProperty(doc, "__hash__");
+    Reflect.deleteProperty(doc, "path");
+    if (typeof doc.navigation === "undefined") {
+      doc.navigation = true;
+    }
+    for (const key in doc) {
+      const value = doc[key];
+      if (typeof value === "string" && !Number.isNaN(Date.parse(value))) {
+        if (/^\d{4}-\d{2}-\d{2}/.test(value)) {
+          doc[key] = new Date(value).toISOString().split("T")[0];
+        }
+      }
+    }
+    function removeNullAndUndefined(obj) {
+      const result = {};
+      for (const key in obj) {
+        const value = obj[key];
+        if (value === null || value === void 0) {
+          continue;
+        }
+        if (typeof value === "object" && value !== null && !Array.isArray(value) && !(value instanceof Date)) {
+          result[key] = removeNullAndUndefined(value);
+        } else {
+          result[key] = value;
+        }
+      }
+      return result;
+    }
+    return removeNullAndUndefined(doc);
+  }
+  const data1 = refineDocumentData({ ...documentData1, ...meta1 || {} });
+  const data2 = refineDocumentData({ ...documentData2, ...meta2 || {} });
+  if (!doObjectsMatch(data1, data2)) {
+    return false;
+  }
+  return true;
+}
+export async function generateDocumentFromContent(id, content) {
+  const [_id, _hash] = id.split("#");
+  const extension = getFileExtension(id);
+  if (extension === ContentFileExtension.Markdown) {
+    return await generateDocumentFromMarkdownContent(id, content);
+  }
+  if (extension === ContentFileExtension.YAML || extension === ContentFileExtension.YML) {
+    return await generateDocumentFromYAMLContent(id, content);
+  }
+  if (extension === ContentFileExtension.JSON) {
+    return await generateDocumentFromJSONContent(id, content);
+  }
+  return null;
+}
+export async function generateDocumentFromYAMLContent(id, content) {
+  const { data } = parseFrontMatter(`---
+${content}
+---`);
+  let parsed = data;
+  if (Array.isArray(data)) {
+    console.warn(`YAML array is not supported in ${id}, moving the array into the \`body\` key`);
+    parsed = { body: data };
+  }
+  return {
+    id,
+    extension: getFileExtension(id),
+    stem: generateStemFromId(id),
+    meta: {},
+    ...parsed,
+    body: parsed.body || parsed
+  };
+}
+export async function generateDocumentFromJSONContent(id, content) {
+  let parsed = destr(content);
+  if (Array.isArray(parsed)) {
+    console.warn(`JSON array is not supported in ${id}, moving the array into the \`body\` key`);
+    parsed = {
+      body: parsed
+    };
+  }
+  return {
+    id,
+    extension: ContentFileExtension.JSON,
+    stem: generateStemFromId(id),
+    meta: {},
+    ...parsed,
+    body: parsed.body || parsed
+  };
+}
+export async function generateDocumentFromMarkdownContent(id, content) {
+  const document = await parseMarkdown(content, {
+    remark: {
+      plugins: {
+        "remark-mdc": {
+          options: {
+            autoUnwrap: true
+          }
+        }
+      }
+    }
+  });
+  visit(document.body, (node) => node.type === "element" && node.tag === "a", (node) => {
+    if (node.props?.rel?.join(" ") === "nofollow") {
+      Reflect.deleteProperty(node.props, "rel");
+    }
+  });
+  const body = document.body.type === "root" ? compressTree(document.body) : document.body;
+  const result = {
+    id,
+    meta: {},
+    extension: "md",
+    stem: id.split("/").slice(1).join("/").split(".").slice(0, -1).join("."),
+    body: {
+      ...body,
+      toc: document.toc
+    },
+    ...document.data
+  };
+  return pathMetaTransform(result);
+}
+export async function generateContentFromDocument(document) {
+  const [id, _hash] = document.id.split("#");
+  const extension = getFileExtension(id);
+  if (extension === ContentFileExtension.Markdown) {
+    return await generateContentFromMarkdownDocument(document);
+  }
+  if (extension === ContentFileExtension.YAML || extension === ContentFileExtension.YML) {
+    return await generateContentFromYAMLDocument(document);
+  }
+  if (extension === ContentFileExtension.JSON) {
+    return await generateContentFromJSONDocument(document);
+  }
+  return null;
+}
+export async function generateContentFromYAMLDocument(document) {
+  return await stringifyFrontMatter(removeReservedKeysFromDocument(document), "", {
+    prefix: "",
+    suffix: "",
+    lineWidth: 0
+  });
+}
+export async function generateContentFromJSONDocument(document) {
+  return JSON.stringify(removeReservedKeysFromDocument(document), null, 2);
+}
+export async function generateContentFromMarkdownDocument(document) {
+  const body = document.body.type === "minimark" ? decompressTree(document.body) : document.body;
+  visit(body, (node) => node.type === "element" && node.tag === "a", (node) => {
+    if (node.props?.rel?.join(" ") === "nofollow") {
+      Reflect.deleteProperty(node.props, "rel");
+    }
+  });
+  const markdown = await stringifyMarkdown(body, removeReservedKeysFromDocument(document), {
+    frontMatter: {
+      options: {
+        lineWidth: 0
+      }
+    },
+    plugins: {
+      remarkMDC: {
+        options: {
+          autoUnwrap: true
+        }
+      }
+    }
+  });
+  return typeof markdown === "string" ? markdown.replace(/*/g, "*") : markdown;
+}
+function generateStemFromId(id) {
+  return id.split("/").slice(1).join("/").split(".").slice(0, -1).join(".");
+}
+function getFileExtension(id) {
+  return id.split("#")[0]?.split(".").pop().toLowerCase();
+}
+function withoutLastStyles(body) {
+  if (body.value[body.value.length - 1]?.[0] === "style") {
+    return { ...body, value: body.value.slice(0, -1) };
+  }
+  return body;
+}

package/dist/module/runtime/utils/media.d.ts

@@ -0,0 +1 @@
+export declare function generateIdFromFsPath(fsPath: string): string;

package/dist/module/runtime/utils/media.js

@@ -0,0 +1,5 @@
+import { join } from "pathe";
+import { VirtualMediaCollectionName } from "nuxt-studio/app/utils";
+export function generateIdFromFsPath(fsPath) {
+  return join(VirtualMediaCollectionName, fsPath);
+}

package/dist/module/runtime/utils/object.d.ts

@@ -1,3 +1,7 @@
 export declare const omit: (obj: Record<string, unknown>, keys: string | string[]) => {
     [k: string]: unknown;
 };
+export declare const pick: (obj: Record<string, unknown>, keys: string | string[]) => {
+    [k: string]: unknown;
+};
+export declare function doObjectsMatch(base: Record<string, unknown>, target: Record<string, unknown>): boolean;

package/dist/module/runtime/utils/object.js

@@ -1,3 +1,30 @@
 export const omit = (obj, keys) => {
   return Object.fromEntries(Object.entries(obj).filter(([key]) => !keys.includes(key)));
 };
+export const pick = (obj, keys) => {
+  return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)));
+};
+export function doObjectsMatch(base, target) {
+  if (typeof base !== "object" || typeof target !== "object") {
+    return base === target;
+  }
+  if (Array.isArray(base) && Array.isArray(target)) {
+    if (base.length !== target.length) {
+      return false;
+    }
+    for (let index = 0; index < base.length; index++) {
+      const item = base[index];
+      const targetItem = target[index];
+      if (!doObjectsMatch(item, targetItem)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  for (const key in base) {
+    if (!doObjectsMatch(base[key], target[key])) {
+      return false;
+    }
+  }
+  return true;
+}

package/dist/module/runtime/utils/source.d.ts

@@ -0,0 +1,11 @@
+import type { CollectionSource, ResolvedCollectionSource } from '@nuxt/content';
+export declare function parseSourceBase(source: CollectionSource): {
+    fixed: string;
+    dynamic: string;
+};
+/**
+ * On Nuxt Content, Id is built like this: {collection.name}/{source.prefix}/{path}
+ * But 'source.prefix' can be different from the fixed part of 'source.include'
+ * We need to remove the 'source.prefix' from the path and add the fixed part of the 'source.include' to get the fsPath (used to match the source)
+ */
+export declare function getCollectionSourceById(id: string, sources: ResolvedCollectionSource[]): ResolvedCollectionSource | undefined;

package/dist/module/runtime/utils/source.js

@@ -0,0 +1,36 @@
+import { withLeadingSlash, withoutLeadingSlash, withoutTrailingSlash } from "ufo";
+import { join } from "pathe";
+import { minimatch } from "minimatch";
+export function parseSourceBase(source) {
+  const [fixPart, ...rest] = source.include.includes("*") ? source.include.split("*") : ["", source.include];
+  return {
+    fixed: fixPart || "",
+    dynamic: "*" + rest.join("*")
+  };
+}
+export function getCollectionSourceById(id, sources) {
+  const [_, ...rest] = id.split(/[/:]/);
+  const prefixAndPath = rest.join("/");
+  const matchedSource = sources.find((source) => {
+    const prefix = source.prefix;
+    if (!prefix) {
+      return false;
+    }
+    if (!withLeadingSlash(prefixAndPath).startsWith(prefix)) {
+      return false;
+    }
+    let fsPath;
+    const [fixPart] = source.include.includes("*") ? source.include.split("*") : ["", source.include];
+    const fixed = withoutTrailingSlash(fixPart || "/");
+    if (withoutLeadingSlash(fixed) === withoutLeadingSlash(prefix)) {
+      fsPath = prefixAndPath;
+    } else {
+      const path = prefixAndPath.replace(prefix, "");
+      fsPath = join(fixed, path);
+    }
+    const include = minimatch(fsPath, source.include, { dot: true });
+    const exclude = source.exclude?.some((exclude2) => minimatch(fsPath, exclude2));
+    return include && !exclude;
+  });
+  return matchedSource;
+}

package/license.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Vercel, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.