nuxt-content-assets 0.6.1 → 0.7.0

package/README.md

@@ -97,7 +97,7 @@ Relative paths are defined by anything not starting with a slash or `http`, for
 
 ```
 image.jpg
-images/featured.png
+assets/featured.png
 ../assets/cv.pdf
 ```
 
@@ -119,16 +119,16 @@ However, you can use relative paths in frontmatter:
 ---
 title: Portfolio Item 1
 images:
-  - images/image-1.jpg
-  - images/image-2.jpg
-  - images/image-3.jpg
+  - assets/image-1.jpg
+  - assets/image-2.jpg
+  - assets/image-3.jpg
 ---
 ```
 
 Then pass these to components like so:
 
 ```markdown
-::gallery{:images="images"}
+::gallery{:data="images"}
 ::
 ```
 
@@ -196,7 +196,7 @@ export default defineNuxtConfig({
     // where to generate and serve the assets from
     output: 'assets/content/[path]/[file]',
     
-    // add additional extensions
+    // include additional extensions
     additionalExtensions: 'html',
     
     // completely replace supported extensions
@@ -216,38 +216,43 @@ export default defineNuxtConfig({
 The output path can be customised using a template string:
 
 ```
-assets/content/[name]-[hash].[ext]
+assets/[name]-[hash].[ext]
 ```
 
 The first part of the path is where you want content assets to be served from:
 
 ```
-assets/content/
+assets/
 ```
 
-The optional second part of the path indicates the relative location of each image: 
+The optional second part of the path indicates the relative location of each asset.
 
-| Token       | Description                                | Example            |
-|-------------|--------------------------------------------|--------------------|
-| `[folder]`  | The relative folder of the file            | `posts/2023-01-01` |
-| `[file]`    | The full filename of the file              | `featured.jpg`     |
-| `[name]`    | The name of the file without the extension | `featured`         |
-| `[hash]`    | A hash of the absolute source path         | `9M00N4l9A0`       |
-| `[extname]` | The full extension with the dot            | `.jpg`             |
-| `[ext]`     | The extension without the dot              | `jpg`              |
+The table below shows replacements for the asset `content/posts/2023-01-01/featured.jpg`:
+
+| Token       | Description                                                                                        | Example                    |
+|-------------|----------------------------------------------------------------------------------------------------|----------------------------|
+| `[key]`     | The config key of the source (see [sources](https://content.nuxtjs.org/api/configuration#sources)) | `content`                  |
+| `[path]`    | The relative path of the source                                                                    | `content/posts/2023-01-01` |
+| `[folder]`  | The relative path of the file's folder                                                             | `posts/2023-01-01`         |
+| `[file]`    | The full filename of the file                                                                      | `featured.jpg`             |
+| `[name]`    | The name of the file without the extension                                                         | `featured`                 |
+| `[hash]`    | A hash of the absolute source path                                                                 | `9M00N4l9A0`               |
+| `[extname]` | The full extension with the dot                                                                    | `.jpg`                     |
+| `[ext]`     | The extension without the dot                                                                      | `jpg`                      |
 
 For example:
 
-| Template                             | Output                                             |
-|--------------------------------------|----------------------------------------------------|
-| `assets/img/content/[folder]/[file]` | `assets/img/content/posts/2023-01-01/featured.jpg` |
-| `assets/img/[name]-[hash].[ext]`     | `assets/img/featured-9M00N4l9A0.jpg`               |
-| `content/[hash].[ext]`               | `content/9M00N4l9A0.jpg`                           |
+| Template                     | Output                                         |
+|------------------------------|------------------------------------------------|
+| `assets/[path]/[file]`       | `assets/content/posts/2023-01-01/featured.jpg` |
+| `assets/[folder]/[file]`     | `assets/posts/2023-01-01/featured.jpg`         |
+| `assets/[name]-[hash].[ext]` | `assets/featured-9M00N4l9A0.jpg`               |
+| `assets/[hash].[ext]`        | `assets/9M00N4l9A0.jpg`                        |
 
 Note that the module defaults to:
 
 ```
-/assets/content/[folder]/[file]
+/assets/[path]/[file]
 ```
 
 ### Extensions

package/dist/module.json

@@ -4,5 +4,5 @@
   "compatibility": {
     "nuxt": "^3.0.0"
   },
-  "version": "0.6.1"
+  "version": "0.7.0"
 }

package/dist/module.mjs

@@ -1,18 +1,20 @@
-import { createResolver, defineNuxtModule, addTemplate } from '@nuxt/kit';
-import getImageSize from 'image-size';
-import glob from 'glob';
 import * as Fs from 'fs';
 import * as Path from 'path';
 import Path__default from 'path';
+import { createResolver, defineNuxtModule, addTemplate } from '@nuxt/kit';
+import getImageSize from 'image-size';
 import { hash } from 'ohash';
+import glob from 'glob';
+import { createStorage } from 'unstorage';
+import githubDriver from 'unstorage/drivers/github';
 
 function matchWords(value) {
   return typeof value === "string" ? value.match(/\w+/g) || [] : [];
 }
 
 const defaults = {
-  assetsDir: "assets/content",
-  assetsPattern: "[folder]/[file]"
+  assetsDir: "/assets/",
+  assetsPattern: "[path]/[file]"
 };
 const imageExtensions = matchWords("png jpg jpeg gif svg webp ico");
 const mediaExtensions = matchWords("mp3 m4a wav mp4 mov webm ogg avi flv avchd");
@@ -28,40 +30,57 @@ function isImage(path) {
   return imageExtensions.includes(ext);
 }
 
-function getSources(sources) {
-  return Object.keys(sources).reduce((output, key) => {
-    const source = sources[key];
-    if (source) {
-      const { driver, base } = source;
-      if (driver === "fs") {
-        output[key] = base;
-      }
-    }
-    return output;
-  }, {});
-}
-
 const moduleName = "nuxt-content-assets";
 const moduleKey = "content-assets";
 
 function log(...data) {
   console.info(`[${moduleKey}]`, ...data);
 }
+function warn(...data) {
+  console.warn(`[${moduleKey}]`, ...data);
+}
+function list(message, items) {
+  log(`${message}:
+
+${items.map((item) => `   - ${item}`).join("\n")}
+`);
+}
+
+function writeFile(path, data) {
+  const text = typeof data === "object" ? JSON.stringify(data, null, "  ") : String(data);
+  createFolder(Path.dirname(path));
+  Fs.writeFileSync(path, text, { encoding: "utf8" });
+}
+function copyFile(src, trg) {
+  createFolder(Path.dirname(trg));
+  Fs.copyFileSync(src, trg);
+}
+function createFolder(path) {
+  Fs.mkdirSync(path, { recursive: true });
+}
+function removeFolder(path) {
+  const isDownstream = path.startsWith(Path.resolve());
+  if (isDownstream) {
+    Fs.rmSync(path, { recursive: true, force: true });
+  }
+}
 
 const replacers = {
-  folder: (src, dir) => Path__default.dirname(src.replace(dir, "")),
+  key: (src) => Path__default.dirname(src).split("/").filter((e) => e).shift() || "",
+  path: (src) => Path__default.dirname(src),
+  folder: (src) => Path__default.dirname(src).replace(/[^/]+\//, ""),
   file: (src) => Path__default.basename(src),
   name: (src) => Path__default.basename(src, Path__default.extname(src)),
   extname: (src) => Path__default.extname(src),
   ext: (src) => Path__default.extname(src).substring(1),
   hash: (src) => hash({ src })
 };
-function interpolatePattern(pattern, src, dir, warn = false) {
+function interpolatePattern(pattern, src, warn = false) {
   return Path__default.join(pattern.replace(/\[\w+]/g, (match) => {
     const name = match.substring(1, match.length - 1);
     const fn = replacers[name];
     if (fn) {
-      return fn(src, dir);
+      return fn(src);
     }
     if (warn) {
       log(`Unknown output token ${match}`, true);
@@ -70,6 +89,69 @@ function interpolatePattern(pattern, src, dir, warn = false) {
   }));
 }
 
+function getAssetConfig(srcDir, srcAbs, pattern, hints) {
+  let width = void 0;
+  let height = void 0;
+  let ratio = void 0;
+  let query = void 0;
+  if (hints.length && isImage(srcAbs)) {
+    try {
+      const size = getImageSize(srcAbs);
+      if (hints.includes("style")) {
+        ratio = `${size.width}/${size.height}`;
+      }
+      if (hints.includes("attrs")) {
+        width = size.width;
+        height = size.height;
+      }
+      if (hints.includes("url")) {
+        query = `?width=${width}&height=${height}`;
+      }
+    } catch (err) {
+      warn(`could not read image "${srcAbs}`);
+    }
+  }
+  const srcRel = Path.basename(srcDir) + srcAbs.substring(srcDir.length);
+  const srcAttr = interpolatePattern(pattern, srcRel);
+  const id = srcRel.replaceAll("/", ":");
+  return { id, srcRel, srcAttr, width, height, ratio, query };
+}
+
+async function getGithubAssets(key, source, tempPath, extensions) {
+  const storage = createStorage();
+  storage.mount(key, githubDriver({
+    repo: source.repo,
+    branch: source.branch || "main",
+    dir: source.dir || "/",
+    ttl: source.ttl || 600
+  }));
+  const rx = new RegExp(`.${extensions.join("|")}$`);
+  const keys = await storage.getKeys();
+  const assetKeys = keys.filter((key2) => rx.test(key2));
+  const assetItems = await Promise.all(assetKeys.map(async (id) => {
+    const data = await storage.getItem(id);
+    return { id, data };
+  }));
+  const prefix = source.prefix || "";
+  const paths = [];
+  for (const { id, data } of assetItems) {
+    if (data) {
+      const path = id.replaceAll(":", "/");
+      const absPath = Path.join(tempPath, path.replace(key, `${key}/${prefix}`));
+      const absFolder = Path.dirname(absPath);
+      const buffer = data.constructor.name === "Blob" ? Buffer.from(await data.arrayBuffer()) : typeof data === "object" ? JSON.stringify(data, null, "  ") : String(data);
+      Fs.mkdirSync(absFolder, { recursive: true });
+      Fs.writeFileSync(absPath, buffer);
+      paths.push(absPath);
+    }
+  }
+  return paths;
+}
+function getFsAssets(path, extensions) {
+  const pattern = `${path}/**/*.{${extensions.join(",")}}`;
+  return glob.globSync(pattern) || [];
+}
+
 const resolve = createResolver(import.meta.url).resolve;
 const module = defineNuxtModule({
   meta: {
@@ -86,98 +168,134 @@ const module = defineNuxtModule({
     imageSize: "",
     debug: false
   },
-  setup(options, nuxt) {
+  async setup(options, nuxt) {
     var _a, _b;
     const pluginPath = resolve("./runtime/plugin");
     const buildPath = nuxt.options.buildDir;
-    const cachePath = Path.resolve(buildPath, "content-assets");
+    const cachePath = Path.join(buildPath, "content-assets");
+    const publicPath = Path.join(cachePath, "public");
+    const tempPath = Path.resolve("node_modules/.nuxt-content-assets");
+    const dump = (name, data) => {
+      const path = `${cachePath}/debug/${name}.json`;
+      log(`Dumping "${Path.relative("", path)}"`);
+      writeFile(path, data);
+    };
     if (options.debug) {
       log("Removing cache folders...");
     }
-    Fs.rmSync(Path.join(buildPath, "content-cache"), { recursive: true, force: true });
-    Fs.rmSync(cachePath, { recursive: true, force: true });
-    const sources = nuxt.options._layers.map((layer) => layer.config?.content?.sources).reduce((output2, sources2) => {
-      if (sources2) {
-        Object.assign(output2, getSources(sources2));
-      }
-      return output2;
-    }, {});
-    if (Object.keys(sources).length === 0 || !sources.content) {
-      const content = nuxt.options.srcDir + "/content";
-      if (Fs.existsSync(content)) {
-        sources.content = content;
-      }
+    removeFolder(Path.join(buildPath, "content-cache"));
+    removeFolder(cachePath);
+    removeFolder(tempPath);
+    (_a = nuxt.options).content || (_a.content = {});
+    if (nuxt.options.content) {
+      (_b = nuxt.options.content).ignores || (_b.ignores = []);
     }
     const output = options.output || defaults.assetsDir;
     const matches = output.match(/([^[]+)(.*)?/);
-    const assetsDir = matches ? matches[1] : defaults.assetsDir;
+    const assetsDir = matches ? matches[1].replace(/^\/*/, "/").replace(/\/*$/, "") : defaults.assetsDir;
     const assetsPattern = (matches ? matches[2] : "") || defaults.assetsPattern;
-    interpolatePattern(assetsPattern, "", "", true);
+    interpolatePattern(assetsPattern, "", true);
     const imageFlags = matchWords(options.imageSize);
     if (options.extensions?.trim()) {
       extensions.splice(0, extensions.length, ...matchWords(options.extensions));
     } else if (options.additionalExtensions) {
       extensions.push(...matchWords(options.additionalExtensions));
     }
-    function getAssetConfig(pattern, src, dir) {
-      let width = void 0;
-      let height = void 0;
-      let ratio = void 0;
-      let query = void 0;
-      if (imageFlags.length && isImage(src)) {
-        const size = getImageSize(src);
-        if (imageFlags.includes("style")) {
-          ratio = `${size.width}/${size.height}`;
-        }
-        if (imageFlags.includes("attrs")) {
-          width = size.width;
-          height = size.height;
-        }
-        if (imageFlags.includes("url")) {
-          query = `?width=${width}&height=${height}`;
-        }
-      }
-      const id = Path.join(Path.basename(dir), Path.relative(dir, src)).replaceAll("/", ":");
-      const file = interpolatePattern(pattern, src, dir);
-      const trg = Path.join(cachePath, assetsDir, file);
-      const rel = Path.join("/", assetsDir, file);
-      return { id, file, trg, rel, width, height, ratio, query };
+    if (options.debug) {
+      log("Preparing sources...");
     }
-    const publicFolder = Path.join(cachePath, assetsDir);
-    const sourceFolders = Object.values(sources);
     const assets = {};
-    (_a = nuxt.options).content || (_a.content = {});
-    if (nuxt.options.content) {
-      (_b = nuxt.options.content).ignores || (_b.ignores = []);
+    const sources = nuxt.options._layers.map((layer) => layer.config?.content?.sources).reduce((output2, sources2) => {
+      if (sources2) {
+        Object.assign(output2, sources2);
+      }
+      return output2;
+    }, {});
+    if (Object.keys(sources).length === 0 || !sources.content) {
+      const content = nuxt.options.srcDir + "/content";
+      if (Fs.existsSync(content)) {
+        sources.content = {
+          driver: "fs",
+          base: content
+        };
+      }
+    }
+    for (const [key, source] of Object.entries(sources)) {
+      const { driver } = source;
+      let srcDir = "";
+      let paths = [];
+      switch (driver) {
+        case "fs":
+          paths = getFsAssets(source.base, extensions);
+          srcDir = source.base;
+          break;
+        case "github":
+          paths = await getGithubAssets(key, source, tempPath, extensions);
+          srcDir = Path.join(tempPath, key);
+          break;
+      }
+      if (options.debug) {
+        log(`Prepared ${paths.length} paths for source "${key}"`);
+      }
+      if (paths.length) {
+        paths.forEach((src) => {
+          const {
+            id,
+            srcRel,
+            srcAttr,
+            width,
+            height,
+            ratio,
+            query
+          } = getAssetConfig(srcDir, src, assetsPattern, imageFlags);
+          nuxt.options.content.ignores.push(id);
+          const trg = Path.join(publicPath, assetsDir, srcAttr);
+          assets[srcRel] = {
+            src,
+            trg,
+            config: {
+              srcAttr: Path.join(assetsDir, srcAttr),
+              width,
+              height,
+              ratio,
+              query
+            }
+          };
+        });
+      }
     }
-    sourceFolders.forEach((folder) => {
-      const pattern = `${folder}/**/*.{${extensions.join(",")}}`;
-      const paths = glob.globSync(pattern);
-      paths.forEach((src) => {
-        const config = getAssetConfig(assetsPattern, src, folder);
-        nuxt.options.content.ignores.push(config.id);
-        assets[src] = config;
-      });
-    });
     nuxt.hook("build:before", function() {
-      Fs.mkdirSync(publicFolder, { recursive: true });
       if (options.debug) {
-        const paths = Object.keys(assets).map((key) => "   - " + assets[key].id.replaceAll(":", "/"));
-        log(`Copying ${Object.keys(assets).length} assets:
-
-${paths.join("\n")}
-`);
+        dump("assets", assets);
+      }
+      if (options.debug) {
+        log(`Copying ${Object.keys(assets).length} assets...`);
+      }
+      const copied = [];
+      const failed = [];
+      for (const [key, { src, trg }] of Object.entries(assets)) {
+        if (Fs.existsSync(src)) {
+          copyFile(src, trg);
+          copied.push(key);
+        } else {
+          failed.push(key);
+        }
+      }
+      if (options.debug) {
+        if (copied.length) {
+          list("Copied", copied);
+        }
+        if (failed.length) {
+          list("Failed to copy", failed);
+        }
       }
-      Object.keys(assets).forEach((src) => {
-        const { trg } = assets[src];
-        const trgFolder = Path.dirname(trg);
-        Fs.mkdirSync(trgFolder, { recursive: true });
-        Fs.copyFileSync(src, trg);
-      });
     });
+    const nitroAssets = Object.entries(assets).reduce((output2, [key, value]) => {
+      output2[key] = value.config;
+      return output2;
+    }, {});
     const virtualConfig = [
-      `export const assets = ${JSON.stringify(assets)}`,
-      `export const sources = ${JSON.stringify(sources)}`
+      `export const assets = ${JSON.stringify(nitroAssets, null, "  ")}`
     ].join("\n");
     nuxt.options.alias[`#${moduleName}`] = addTemplate({
       filename: `${moduleName}.mjs`,
@@ -190,7 +308,7 @@ ${paths.join("\n")}
       config.virtual[`#${moduleName}`] = virtualConfig;
       config.publicAssets || (config.publicAssets = []);
       config.publicAssets.push({
-        dir: cachePath
+        dir: publicPath
         // maxAge: 60 * 60 * 24 * 365 // 1 year
       });
     });

package/dist/runtime/options.mjs

@@ -1,7 +1,7 @@
-import { matchWords } from "./utils/config.mjs";
+import { matchWords } from "./utils/string.mjs";
 export const defaults = {
-  assetsDir: "assets/content",
-  assetsPattern: "[folder]/[file]"
+  assetsDir: "/assets/",
+  assetsPattern: "[path]/[file]"
 };
 export const imageExtensions = matchWords("png jpg jpeg gif svg webp ico");
 export const mediaExtensions = matchWords("mp3 m4a wav mp4 mov webm ogg avi flv avchd");

package/dist/runtime/plugin.mjs

@@ -2,49 +2,42 @@ import Path from "path";
 import { visit } from "unist-util-visit";
 import { isValidAsset, walk } from "./utils/index.mjs";
 import { tags } from "./options.mjs";
-import { assets, sources } from "#nuxt-content-assets";
-function getDocPath(id) {
-  const parts = id.split(":");
-  const key = parts.shift();
-  const relPath = parts.join("/");
-  const absBase = sources[key];
-  return Path.join(absBase, relPath);
-}
-function getAsset(absDoc, relAsset) {
-  const absAsset = Path.join(Path.dirname(absDoc), relAsset);
-  return assets[absAsset] || {};
+import { assets } from "#nuxt-content-assets";
+function getAsset(srcDoc, relAsset) {
+  const srcAsset = Path.join(Path.dirname(srcDoc), relAsset);
+  return assets[srcAsset] || {};
 }
 const plugin = async (nitro) => {
   nitro.hooks.hook("content:file:afterParse", async (file) => {
     if (file._id.endsWith(".md")) {
-      const absDoc = getDocPath(file._id);
+      const srcDoc = file._id.split(":").join("/");
       const filter = (value, key) => !(String(key).startsWith("_") || key === "body");
       walk(file, (value, parent, key) => {
         if (isValidAsset(value)) {
-          const { rel, query } = getAsset(absDoc, value);
-          if (rel) {
-            parent[key] = rel + (query || "");
+          const { srcAttr, query } = getAsset(srcDoc, value);
+          if (srcAttr) {
+            parent[key] = srcAttr + (query || "");
           }
         }
       }, filter);
       visit(file.body, (n) => tags.includes(n.tag), (node) => {
         if (node.props.src) {
-          const { rel, width, height, ratio } = getAsset(absDoc, node.props.src);
-          if (rel) {
-            node.props.src = rel;
-          }
-          if (width && height) {
-            node.props.width = width;
-            node.props.height = height;
-          }
-          if (ratio) {
-            node.props.style = `aspect-ratio:${ratio}`;
+          const { srcAttr, width, height, ratio } = getAsset(srcDoc, node.props.src);
+          if (srcAttr) {
+            node.props.src = srcAttr;
+            if (width && height) {
+              node.props.width = width;
+              node.props.height = height;
+            }
+            if (ratio) {
+              node.props.style = `aspect-ratio:${ratio}`;
+            }
           }
         } else if (node.tag === "a") {
           if (node.props.href) {
-            const { rel } = getAsset(absDoc, node.props.href);
-            if (rel) {
-              node.props.href = rel;
+            const { srcAttr } = getAsset(srcDoc, node.props.href);
+            if (srcAttr) {
+              node.props.href = srcAttr;
               node.props.target = "_blank";
             }
           }

package/dist/runtime/services/assets.d.ts

@@ -0,0 +1,18 @@
+export type AssetConfig = {
+    id: string;
+    srcRel: string;
+    srcAttr: string;
+    width?: number;
+    height?: number;
+    ratio?: string;
+    query?: string;
+};
+/**
+ * Get config for asset
+ *
+ * @param srcDir    The absolute path to the asset's source folder
+ * @param srcAbs    The absolute path to the asset itself
+ * @param pattern   The user-defined pattern to create the public src attribute
+ * @param hints     A list of named image size hints, i.e. 'style', 'attrs', etc
+ */
+export declare function getAssetConfig(srcDir: string, srcAbs: string, pattern: string, hints: string[]): AssetConfig;

package/dist/runtime/services/assets.mjs

@@ -0,0 +1,31 @@
+import * as Path from "path";
+import getImageSize from "image-size";
+import { isImage, warn } from "../utils/index.mjs";
+import { interpolatePattern } from "./paths.mjs";
+export function getAssetConfig(srcDir, srcAbs, pattern, hints) {
+  let width = void 0;
+  let height = void 0;
+  let ratio = void 0;
+  let query = void 0;
+  if (hints.length && isImage(srcAbs)) {
+    try {
+      const size = getImageSize(srcAbs);
+      if (hints.includes("style")) {
+        ratio = `${size.width}/${size.height}`;
+      }
+      if (hints.includes("attrs")) {
+        width = size.width;
+        height = size.height;
+      }
+      if (hints.includes("url")) {
+        query = `?width=${width}&height=${height}`;
+      }
+    } catch (err) {
+      warn(`could not read image "${srcAbs}`);
+    }
+  }
+  const srcRel = Path.basename(srcDir) + srcAbs.substring(srcDir.length);
+  const srcAttr = interpolatePattern(pattern, srcRel);
+  const id = srcRel.replaceAll("/", ":");
+  return { id, srcRel, srcAttr, width, height, ratio, query };
+}

package/dist/runtime/services/index.d.ts

@@ -0,0 +1,3 @@
+export * from './assets';
+export * from './sources';
+export * from './paths';

package/dist/runtime/services/index.mjs

@@ -0,0 +1,3 @@
+export * from "./assets.mjs";
+export * from "./sources.mjs";
+export * from "./paths.mjs";

package/dist/runtime/{utils → services}/paths.d.ts

@@ -2,8 +2,7 @@
  * Interpolate assets path pattern
  *
  * @param pattern   A path pattern with tokens
- * @param src       The absolute path to a src asset
- * @param dir       The absolute path to its containing folder
+ * @param src       The relative path to a src asset
  * @param warn      An optional flag to warn for unknown tokens
  */
-export declare function interpolatePattern(pattern: string, src: string, dir: string, warn?: boolean): string;
+export declare function interpolatePattern(pattern: string, src: string, warn?: boolean): string;

package/dist/runtime/{utils → services}/paths.mjs

@@ -1,20 +1,22 @@
 import Path from "path";
 import { hash } from "ohash";
-import { log } from "./debug.mjs";
+import { log } from "../utils/index.mjs";
 const replacers = {
-  folder: (src, dir) => Path.dirname(src.replace(dir, "")),
+  key: (src) => Path.dirname(src).split("/").filter((e) => e).shift() || "",
+  path: (src) => Path.dirname(src),
+  folder: (src) => Path.dirname(src).replace(/[^/]+\//, ""),
   file: (src) => Path.basename(src),
   name: (src) => Path.basename(src, Path.extname(src)),
   extname: (src) => Path.extname(src),
   ext: (src) => Path.extname(src).substring(1),
   hash: (src) => hash({ src })
 };
-export function interpolatePattern(pattern, src, dir, warn = false) {
+export function interpolatePattern(pattern, src, warn = false) {
   return Path.join(pattern.replace(/\[\w+]/g, (match) => {
     const name = match.substring(1, match.length - 1);
     const fn = replacers[name];
     if (fn) {
-      return fn(src, dir);
+      return fn(src);
     }
     if (warn) {
       log(`Unknown output token ${match}`, true);

package/dist/runtime/services/sources.d.ts

@@ -0,0 +1,10 @@
+type GithubOptions = {
+    repo: string;
+    branch?: string;
+    dir?: string;
+    prefix?: string;
+    ttl?: number;
+};
+export declare function getGithubAssets(key: string, source: GithubOptions, tempPath: string, extensions: string[]): Promise<string[]>;
+export declare function getFsAssets(path: string, extensions: string[]): string[];
+export {};

package/dist/runtime/services/sources.mjs

@@ -0,0 +1,39 @@
+import * as Fs from "fs";
+import * as Path from "path";
+import glob from "glob";
+import { createStorage } from "unstorage";
+import githubDriver from "unstorage/drivers/github";
+export async function getGithubAssets(key, source, tempPath, extensions) {
+  const storage = createStorage();
+  storage.mount(key, githubDriver({
+    repo: source.repo,
+    branch: source.branch || "main",
+    dir: source.dir || "/",
+    ttl: source.ttl || 600
+  }));
+  const rx = new RegExp(`.${extensions.join("|")}$`);
+  const keys = await storage.getKeys();
+  const assetKeys = keys.filter((key2) => rx.test(key2));
+  const assetItems = await Promise.all(assetKeys.map(async (id) => {
+    const data = await storage.getItem(id);
+    return { id, data };
+  }));
+  const prefix = source.prefix || "";
+  const paths = [];
+  for (const { id, data } of assetItems) {
+    if (data) {
+      const path = id.replaceAll(":", "/");
+      const absPath = Path.join(tempPath, path.replace(key, `${key}/${prefix}`));
+      const absFolder = Path.dirname(absPath);
+      const buffer = data.constructor.name === "Blob" ? Buffer.from(await data.arrayBuffer()) : typeof data === "object" ? JSON.stringify(data, null, "  ") : String(data);
+      Fs.mkdirSync(absFolder, { recursive: true });
+      Fs.writeFileSync(absPath, buffer);
+      paths.push(absPath);
+    }
+  }
+  return paths;
+}
+export function getFsAssets(path, extensions) {
+  const pattern = `${path}/**/*.{${extensions.join(",")}}`;
+  return glob.globSync(pattern) || [];
+}

package/dist/runtime/utils/debug.d.ts

@@ -1,3 +1,3 @@
 export declare function log(...data: any[]): void;
 export declare function warn(...data: any[]): void;
-export declare function dump(name: string, data: any): void;
+export declare function list(message: string, items: string[]): void;

package/dist/runtime/utils/debug.mjs

@@ -1,5 +1,3 @@
-import Path from "path";
-import Fs from "fs";
 import { moduleKey } from "../config.mjs";
 export function log(...data) {
   console.info(`[${moduleKey}]`, ...data);
@@ -7,10 +5,9 @@ export function log(...data) {
 export function warn(...data) {
   console.warn(`[${moduleKey}]`, ...data);
 }
-export function dump(name, data) {
-  const path = `debug/${name}.json`;
-  const folder = Path.dirname(path);
-  log(`Dumping "${path}"`);
-  Fs.mkdirSync(folder, { recursive: true });
-  Fs.writeFileSync(path, JSON.stringify(data, null, "  "), { encoding: "utf8" });
+export function list(message, items) {
+  log(`${message}:
+
+${items.map((item) => `   - ${item}`).join("\n")}
+`);
 }

package/dist/runtime/utils/fs.d.ts

@@ -0,0 +1,4 @@
+export declare function writeFile(path: string, data: null | string | number | boolean | object): void;
+export declare function copyFile(src: string, trg: string): void;
+export declare function createFolder(path: string): void;
+export declare function removeFolder(path: string): void;

package/dist/runtime/utils/fs.mjs

@@ -0,0 +1,20 @@
+import * as Path from "path";
+import * as Fs from "fs";
+export function writeFile(path, data) {
+  const text = typeof data === "object" ? JSON.stringify(data, null, "  ") : String(data);
+  createFolder(Path.dirname(path));
+  Fs.writeFileSync(path, text, { encoding: "utf8" });
+}
+export function copyFile(src, trg) {
+  createFolder(Path.dirname(trg));
+  Fs.copyFileSync(src, trg);
+}
+export function createFolder(path) {
+  Fs.mkdirSync(path, { recursive: true });
+}
+export function removeFolder(path) {
+  const isDownstream = path.startsWith(Path.resolve());
+  if (isDownstream) {
+    Fs.rmSync(path, { recursive: true, force: true });
+  }
+}

package/dist/runtime/utils/index.d.ts

@@ -1,6 +1,5 @@
-export * from './assets';
-export * from './config';
-export * from './content';
+export * from './assert';
 export * from './debug';
+export * from './fs';
+export * from './string';
 export * from './object';
-export * from './paths';

package/dist/runtime/utils/index.mjs

@@ -1,6 +1,5 @@
-export * from "./assets.mjs";
-export * from "./config.mjs";
-export * from "./content.mjs";
+export * from "./assert.mjs";
 export * from "./debug.mjs";
+export * from "./fs.mjs";
+export * from "./string.mjs";
 export * from "./object.mjs";
-export * from "./paths.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-content-assets",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Enable locally-located assets in Nuxt Content",
   "repository": "davestewart/nuxt-content-assets",
   "license": "MIT",
@@ -35,7 +35,8 @@
     "glob": "^9.3.2",
     "image-size": "^1.0.2",
     "ohash": "^1.0.0",
-    "unist-util-visit": "^4.1.2"
+    "unist-util-visit": "^4.1.2",
+    "unstorage": "^1.4.1"
   },
   "peerDependencies": {
     "@nuxt/content": "latest"
@@ -50,5 +51,8 @@
     "eslint": "^8.36.0",
     "nuxt": "^3.3.2",
     "vitest": "^0.29.7"
+  },
+  "engines": {
+    "node": ">=14.0.0"
   }
 }

package/dist/runtime/utils/content.d.ts

@@ -1,7 +0,0 @@
-import type { MountOptions } from '@nuxt/content';
-/**
- * Get content source folders
- *
- * @param sources
- */
-export declare function getSources(sources: Record<string, MountOptions>): Record<string, string>;

package/dist/runtime/utils/content.mjs

@@ -1,12 +0,0 @@
-export function getSources(sources) {
-  return Object.keys(sources).reduce((output, key) => {
-    const source = sources[key];
-    if (source) {
-      const { driver, base } = source;
-      if (driver === "fs") {
-        output[key] = base;
-      }
-    }
-    return output;
-  }, {});
-}