@joycostudio/iris 0.0.0-stage → 0.0.1

package/dist/node.cjs

@@ -0,0 +1,580 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/node/index.ts
+var node_exports = {};
+__export(node_exports, {
+  generateIris: () => generateIris,
+  prepareIrisAssets: () => prepareIrisAssets
+});
+module.exports = __toCommonJS(node_exports);
+
+// packages/node/generate.ts
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
+var import_sharp2 = __toESM(require("sharp"), 1);
+
+// packages/node/discover.ts
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+var import_parser = require("@babel/parser");
+var import_fast_glob = __toESM(require("fast-glob"), 1);
+var import_minimatch = require("minimatch");
+var ignored = [
+  "**/node_modules/**",
+  "**/.next/**",
+  "**/.git/**",
+  "**/dist/**",
+  "**/coverage/**",
+  "**/generated/**",
+  "**/*.generated.*"
+];
+var codeFile = /\.(?:[cm]?[jt]s|[jt]sx)$/i;
+var imageFile = /\.(?:png|jpe?g|webp|avif|gif)$/i;
+async function discoverIrisSources(options, rootDir) {
+  const publicDir = import_node_path.default.resolve(rootDir, options.publicDir ?? "public");
+  const exclude = options.exclude ?? [];
+  const outputDir = import_node_path.default.resolve(rootDir, options.output);
+  const explicit = [];
+  const patterns = [];
+  const found = /* @__PURE__ */ new Set();
+  for (const source of options.sources ?? []) {
+    if (typeof source === "string" && !/^(?:https?:\/\/|\/)/i.test(source) && import_fast_glob.default.isDynamicPattern(source))
+      patterns.push(source);
+    else explicit.push(source);
+  }
+  const globOptions = {
+    cwd: rootDir,
+    onlyFiles: true,
+    followSymbolicLinks: false,
+    ignore: [...ignored, ...exclude]
+  };
+  for (const file of await (0, import_fast_glob.default)(patterns, globOptions)) {
+    if (!imageFile.test(file)) continue;
+    const relative = import_node_path.default.relative(publicDir, import_node_path.default.resolve(rootDir, file));
+    if (relative === ".." || relative.startsWith(`..${import_node_path.default.sep}`) || import_node_path.default.isAbsolute(relative)) {
+      throw new Error(
+        `Iris source pattern matched ${file} outside publicDir. Image globs must stay inside ${publicDir}.`
+      );
+    }
+    found.add(`/${relative.split(import_node_path.default.sep).map(encodeURIComponent).join("/")}`);
+  }
+  for (const file of (await (0, import_fast_glob.default)(options.scan ?? [], globOptions)).sort()) {
+    if (!codeFile.test(file) || /\.d\.[cm]?ts$/i.test(file) || import_node_path.default.resolve(rootDir, file).startsWith(outputDir + import_node_path.default.sep))
+      continue;
+    const code = await (0, import_promises.readFile)(import_node_path.default.resolve(rootDir, file), "utf8");
+    try {
+      for (const source of scanImageLiterals(code, file)) found.add(source);
+    } catch (error) {
+      throw new Error(
+        `Iris could not scan ${file}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  const explicitUrls = new Set(
+    explicit.map((source) => typeof source === "string" ? source : source.src)
+  );
+  const excluded = (src) => exclude.some(
+    (pattern) => src === pattern || (0, import_minimatch.minimatch)(src, pattern, { dot: true, nonegate: true, nocomment: true })
+  );
+  return [
+    ...[...found].sort().filter((src) => !explicitUrls.has(src) && !excluded(src)),
+    ...explicit.filter(
+      (source) => !excluded(typeof source === "string" ? source : source.src)
+    )
+  ];
+}
+function scanImageLiterals(code, filename) {
+  const ast = (0, import_parser.parse)(code, {
+    sourceType: "unambiguous",
+    sourceFilename: filename,
+    attachComment: false,
+    plugins: [
+      .../\.[cm]?tsx?$/i.test(filename) ? ["typescript"] : [],
+      .../\.[jt]sx$|\.[cm]?js$/i.test(filename) ? ["jsx"] : []
+    ]
+  });
+  const literals = [];
+  function walk(value) {
+    if (!value || typeof value !== "object") return;
+    if (Array.isArray(value)) {
+      value.forEach(walk);
+      return;
+    }
+    const node = value;
+    if (typeof node.type !== "string") return;
+    if (node.type.startsWith("Comment") || node.type === "BinaryExpression" || node.type === "TaggedTemplateExpression" || node.type === "ImportDeclaration" || node.type === "ExportAllDeclaration" || node.type === "TSLiteralType")
+      return;
+    if (node.type === "StringLiteral") {
+      if (typeof node.value === "string") literals.push(node.value);
+      return;
+    }
+    if (node.type === "TemplateLiteral") {
+      const template = node;
+      if (template.expressions.length === 0 && template.quasis[0]?.value.cooked)
+        literals.push(template.quasis[0].value.cooked);
+      return;
+    }
+    for (const [key, child] of Object.entries(node)) {
+      if (![
+        "comments",
+        "leadingComments",
+        "trailingComments",
+        "innerComments",
+        "loc",
+        "extra"
+      ].includes(key))
+        walk(child);
+    }
+  }
+  walk(ast.program);
+  return [
+    ...new Set(
+      literals.filter(
+        (value) => /^(?:https?:\/\/|\/).+\.(?:png|jpe?g|webp|avif|gif)(?:[?#].*)?$/i.test(
+          value
+        )
+      )
+    )
+  ].sort();
+}
+
+// packages/node/prepare.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_fast_glob2 = __toESM(require("fast-glob"), 1);
+var import_sharp = __toESM(require("sharp"), 1);
+
+// packages/core/policy.ts
+var import_minimatch2 = require("minimatch");
+function irisFailure(code, message) {
+  return { ok: false, error: { code, message } };
+}
+function positive(value) {
+  return Number.isFinite(value) && value > 0;
+}
+function validVariant(value) {
+  return value && typeof value.url === "string" && !!value.url && positive(value.width) && positive(value.height) && Number.isFinite(value.bytes) && value.bytes >= 0;
+}
+
+// packages/node/prepare.ts
+async function prepareIrisAssets({
+  iris,
+  rootDir = process.cwd(),
+  publicDir = "public",
+  fetch: fetcher = fetch
+}) {
+  const publicRoot = import_node_path2.default.resolve(rootDir, publicDir);
+  try {
+    let inspect2 = function(src) {
+      let pending = inspected.get(src);
+      if (!pending) {
+        pending = (async () => {
+          let bytes;
+          if (/^https?:\/\//i.test(src)) {
+            const response = await fetcher(src, {
+              signal: AbortSignal.timeout(3e4)
+            });
+            if (!response.ok)
+              throw new Error(`Cannot inspect ${src}: HTTP ${response.status}`);
+            bytes = Buffer.from(await response.arrayBuffer());
+          } else {
+            const pathname = decodeURIComponent(
+              src.split(/[?#]/, 1)[0]
+            ).replace(/^\/+/, "");
+            const file = import_node_path2.default.resolve(publicRoot, pathname);
+            within(publicRoot, file);
+            within(await (0, import_promises2.realpath)(publicRoot), await (0, import_promises2.realpath)(file));
+            bytes = await (0, import_promises2.readFile)(file);
+          }
+          const meta = await (0, import_sharp.default)(bytes, { animated: true }).metadata();
+          const swapped = (meta.orientation ?? 1) >= 5;
+          const width = swapped ? meta.height : meta.width;
+          const height = swapped ? meta.width : meta.pageHeight ?? meta.height;
+          if (!width || !height)
+            throw new Error(`Cannot inspect dimensions of ${src}`);
+          return {
+            url: src,
+            width,
+            height,
+            bytes: bytes.length,
+            format: meta.format,
+            progressive: meta.isProgressive ?? false,
+            alpha: Boolean(
+              meta.hasAlpha && ((meta.pages ?? 1) > 1 || !(await (0, import_sharp.default)(bytes).stats()).isOpaque)
+            ),
+            animated: (meta.pages ?? 1) > 1
+          };
+        })();
+        inspected.set(src, pending);
+      }
+      return pending;
+    };
+    var inspect = inspect2;
+    const entries = /* @__PURE__ */ new Map();
+    const explicit = [];
+    for (const input of iris.assets) {
+      const src = typeof input === "string" ? input : input.src;
+      if (/^https?:\/\//i.test(src)) {
+        if (import_fast_glob2.default.isDynamicPattern(new URL(src).pathname))
+          return irisFailure(
+            "remote_pattern",
+            "Remote URLs must be explicit; a glob cannot enumerate a bucket"
+          );
+        explicit.push(input);
+      } else if (typeof input === "string" && import_fast_glob2.default.isDynamicPattern(src.startsWith("/") ? src.split(/[?#]/, 1)[0] : src)) {
+        const files = await (0, import_fast_glob2.default)(
+          src.startsWith("/") ? src.split(/[?#]/, 1)[0].slice(1) : src,
+          {
+            cwd: src.startsWith("/") ? publicRoot : rootDir,
+            onlyFiles: true,
+            followSymbolicLinks: false,
+            ignore: ["**/node_modules/**", "**/.git/**", "**/.next/**"]
+          }
+        );
+        for (const file of files.sort()) {
+          const full = import_node_path2.default.resolve(
+            src.startsWith("/") ? publicRoot : rootDir,
+            file
+          );
+          const relative = within(publicRoot, full);
+          const url = `/${relative.split(import_node_path2.default.sep).map(encodeURIComponent).join("/")}`;
+          entries.set(url, url);
+        }
+      } else explicit.push(input);
+    }
+    for (const input of explicit) {
+      const src = typeof input === "string" ? input : input.src;
+      entries.set(src, input);
+    }
+    const inspected = /* @__PURE__ */ new Map();
+    const catalog = [];
+    const identities = /* @__PURE__ */ new Set();
+    for (const input of entries.values()) {
+      const entry = typeof input === "string" ? { src: input } : input;
+      const metadata = "width" in entry ? entry : await inspect2(entry.src);
+      const { width, height, bytes, format, progressive, alpha, animated } = metadata;
+      const variants = await Promise.all(
+        (entry.variants ?? []).map(
+          (variant) => typeof variant === "string" ? inspect2(variant) : variant
+        )
+      );
+      if (!validVariant({ url: entry.src, width, height, bytes }) || !variants.every(validVariant))
+        return irisFailure("invalid_asset", `Invalid metadata for ${entry.src}`);
+      for (const identity of /* @__PURE__ */ new Set([entry.src, entry.id ?? entry.src])) {
+        if (identities.has(identity))
+          return irisFailure(
+            "duplicate_asset",
+            `Ambiguous asset identity: ${identity}`
+          );
+        identities.add(identity);
+      }
+      catalog.push({
+        src: entry.src,
+        id: entry.id,
+        width,
+        height,
+        bytes,
+        format,
+        progressive,
+        alpha,
+        animated,
+        variants,
+        placeholder: entry.placeholder,
+        placeholders: entry.placeholders
+      });
+    }
+    return { ok: true, data: catalog };
+  } catch (error) {
+    return irisFailure(
+      "prepare_failed",
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function within(root, file) {
+  const relative = import_node_path2.default.relative(root, file);
+  if (relative === ".." || relative.startsWith(`..${import_node_path2.default.sep}`) || import_node_path2.default.isAbsolute(relative)) {
+    throw new Error(`Image source escapes publicDir: ${file}`);
+  }
+  return relative;
+}
+
+// packages/node/generate.ts
+async function generateIris({
+  iris,
+  generation,
+  rootDir = process.cwd(),
+  configFile = "iris.config.ts",
+  allowStale = false,
+  fetch: fetcher = fetch
+}) {
+  if (!generation.output?.trim())
+    throw new Error("Iris requires an output directory");
+  const directory = import_node_path3.default.resolve(rootDir, generation.output);
+  const publicDir = import_node_path3.default.resolve(rootDir, generation.publicDir ?? "public");
+  const adapter = generation.adapter !== false;
+  try {
+    const sources = await discoverIrisSources(
+      {
+        ...generation,
+        sources: [...iris.assets, ...generation.sources ?? []]
+      },
+      rootDir
+    );
+    const entries = /* @__PURE__ */ new Map();
+    for (const value of sources) {
+      const source = typeof value === "string" ? { src: value } : value;
+      const previous = entries.get(source.src);
+      entries.set(source.src, {
+        ...previous,
+        ...source,
+        optional: Boolean(
+          previous ? "optional" in previous && previous.optional && "optional" in source && source.optional : "optional" in source && source.optional
+        )
+      });
+    }
+    const catalog = {};
+    const placeholders = {};
+    const queue = [...entries.values()];
+    let skipped = 0;
+    let cursor = 0;
+    async function worker() {
+      while (cursor < queue.length) {
+        const source = queue[cursor++];
+        if ("width" in source) {
+          const prepared = await prepareIrisAssets({
+            iris: { assets: [source] },
+            rootDir,
+            publicDir,
+            fetch: fetcher
+          });
+          if (!prepared.ok) throw new Error(prepared.error.message);
+          catalog[source.src] = prepared.data[0];
+          if (source.placeholder) placeholders[source.src] = source.placeholder;
+          continue;
+        }
+        let bytes;
+        if (/^https?:\/\//i.test(source.src)) {
+          const response = await fetcher(source.src, {
+            signal: AbortSignal.timeout(3e4)
+          });
+          if (source.optional && response.status === 404) {
+            skipped++;
+            continue;
+          }
+          if (!response.ok)
+            throw new Error(`${response.status} fetching ${source.src}`);
+          bytes = Buffer.from(await response.arrayBuffer());
+        } else {
+          const pathname = decodeURIComponent(
+            source.src.split(/[?#]/, 1)[0]
+          ).replace(/^\/+/, "");
+          const file = import_node_path3.default.resolve(publicDir, pathname);
+          for (const relative of [
+            import_node_path3.default.relative(publicDir, file),
+            import_node_path3.default.relative(await (0, import_promises3.realpath)(publicDir), await (0, import_promises3.realpath)(file))
+          ]) {
+            if (relative === ".." || relative.startsWith(`..${import_node_path3.default.sep}`) || import_node_path3.default.isAbsolute(relative))
+              throw new Error(
+                `Iris local source escapes publicDir: ${source.src}`
+              );
+          }
+          bytes = await (0, import_promises3.readFile)(file);
+        }
+        const meta = await (0, import_sharp2.default)(bytes, { animated: true }).metadata();
+        const swapped = (meta.orientation ?? 1) >= 5;
+        const width = swapped ? meta.height : meta.width;
+        const height = swapped ? meta.width : meta.pageHeight ?? meta.height;
+        if (!width || !height)
+          throw new Error(`Cannot inspect dimensions of ${source.src}`);
+        const placeholderOptions = source.placeholderOptions ?? {};
+        const format = placeholderOptions.format ?? "webp";
+        const size = placeholderOptions.width ?? 10;
+        const quality = placeholderOptions.quality ?? 40;
+        async function encodePlaceholder({
+          width: width2,
+          quality: quality2
+        }) {
+          const buffer = await (0, import_sharp2.default)(bytes, { page: 0, pages: 1 }).rotate().resize({
+            width: width2,
+            height: width2,
+            fit: "inside",
+            withoutEnlargement: true
+          }).toFormat(format, { quality: quality2 }).toBuffer();
+          return `data:image/${format};base64,${buffer.toString("base64")}`;
+        }
+        const placeholder = source.placeholder ?? await encodePlaceholder({ width: size, quality });
+        placeholders[source.src] = placeholder;
+        if (source.placeholderOnly) continue;
+        const preparedPlaceholders = [...source.placeholders ?? []];
+        for (const request of iris.placeholderRequests) {
+          if (preparedPlaceholders.some(
+            (item) => item.width === request.width && item.quality === request.quality
+          ))
+            continue;
+          const url = request.width === size && request.quality === quality ? placeholder : await encodePlaceholder(request);
+          preparedPlaceholders.push({ ...request, url });
+        }
+        const animated = (meta.pages ?? 1) > 1;
+        const alpha = Boolean(
+          meta.hasAlpha && (animated || !(await (0, import_sharp2.default)(bytes).stats()).isOpaque)
+        );
+        const metadata = {
+          src: source.src,
+          id: source.id,
+          width,
+          height,
+          bytes: bytes.length,
+          format: meta.format,
+          alpha,
+          animated,
+          progressive: meta.isProgressive ?? false,
+          placeholder,
+          placeholders: preparedPlaceholders,
+          variants: []
+        };
+        if (source.variants?.length) {
+          const prepared = await prepareIrisAssets({
+            iris: {
+              assets: [
+                { ...metadata, variants: [] },
+                ...source.variants.filter(
+                  (item) => typeof item === "string"
+                )
+              ]
+            },
+            rootDir,
+            publicDir,
+            fetch: fetcher
+          });
+          if (!prepared.ok) throw new Error(prepared.error.message);
+          metadata.variants = [
+            ...metadata.variants,
+            ...source.variants.map((variant) => {
+              if (typeof variant !== "string") return variant;
+              const asset = prepared.data.find((item) => item.src === variant);
+              return { ...asset, url: asset.src };
+            })
+          ];
+        }
+        catalog[source.src] = metadata;
+      }
+    }
+    const concurrency = generation.concurrency ?? 4;
+    if (!Number.isSafeInteger(concurrency) || concurrency < 1)
+      throw new Error("concurrency must be a positive integer");
+    await Promise.all(Array.from({ length: concurrency }, worker));
+    const sorted = (data) => Object.fromEntries(
+      Object.entries(data).sort(([a], [b]) => a.localeCompare(b))
+    );
+    const files = [
+      ["catalog.json", sorted(catalog)],
+      ["placeholders.json", sorted(placeholders)]
+    ];
+    if (generation.report)
+      files.push([
+        "report.json",
+        {
+          inspected: Object.keys(catalog).length,
+          skipped,
+          assets: Object.values(catalog).map((asset) => ({
+            src: asset.src,
+            result: iris.resolve({ asset })
+          }))
+        }
+      ]);
+    await (0, import_promises3.mkdir)(directory, { recursive: true });
+    for (const [name, data] of files)
+      await atomicWrite(
+        import_node_path3.default.join(directory, name),
+        JSON.stringify(data, null, 2) + "\n"
+      );
+    if (adapter) {
+      let configImport = import_node_path3.default.relative(directory, import_node_path3.default.resolve(rootDir, configFile)).split(import_node_path3.default.sep).join("/").replace(/\.[cm]?[jt]s$/, "");
+      if (!configImport.startsWith(".")) configImport = `./${configImport}`;
+      await atomicWrite(
+        import_node_path3.default.join(directory, "image.tsx"),
+        `"use client"
+
+// Generated by Iris. Do not edit.
+import { createIrisNextImage } from "@joycostudio/iris/next"
+import iris from ${JSON.stringify(configImport)}
+import catalog from "./catalog.json"
+
+export const IrisImage = createIrisNextImage({ iris, catalog })
+`
+      );
+    }
+    return {
+      stale: false,
+      placeholders: Object.keys(placeholders).length,
+      inspected: Object.keys(catalog).length,
+      skipped
+    };
+  } catch (error) {
+    if (allowStale && await usableOutput({ directory, adapter })) {
+      console.warn("Iris generation failed; keeping existing files:", error);
+      return { stale: true, placeholders: 0, inspected: 0, skipped: 0 };
+    }
+    throw error;
+  }
+}
+async function atomicWrite(file, content) {
+  await (0, import_promises3.writeFile)(`${file}.tmp`, content);
+  await (0, import_promises3.rename)(`${file}.tmp`, file);
+}
+async function usableOutput({
+  directory,
+  adapter
+}) {
+  try {
+    const catalog = JSON.parse(
+      await (0, import_promises3.readFile)(import_node_path3.default.join(directory, "catalog.json"), "utf8")
+    );
+    const placeholders = JSON.parse(
+      await (0, import_promises3.readFile)(import_node_path3.default.join(directory, "placeholders.json"), "utf8")
+    );
+    if (!catalog || Array.isArray(catalog) || !Object.keys(catalog).length || !placeholders || Array.isArray(placeholders))
+      return false;
+    if (adapter && !(await (0, import_promises3.readFile)(import_node_path3.default.join(directory, "image.tsx"), "utf8")).includes(
+      "createIrisNextImage"
+    ))
+      return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateIris,
+  prepareIrisAssets
+});
+//# sourceMappingURL=node.cjs.map