@eve-online-tools/eve-resfile 0.0.1

package/dist/rollup/index.js

@@ -0,0 +1,64 @@
+import {
+  isVirtualResId,
+  loadResfileAssetModule,
+  resPathFromVirtualId,
+  resolveEveResfileOptions,
+  resolveResfileId
+} from "../chunk-IX5WVBZL.js";
+import {
+  __async,
+  loadResfileIndexData
+} from "../chunk-RP7V25VC.js";
+
+// src/rollup/plugin.ts
+var eveResfile = (options = {}) => {
+  var _a;
+  const userOptions = resolveEveResfileOptions(options, (_a = options.root) != null ? _a : process.cwd());
+  const indexOptions = userOptions;
+  let indexPromise = null;
+  let loadedIndex = null;
+  const ensureIndex = () => {
+    indexPromise != null ? indexPromise : indexPromise = loadResfileIndexData(indexOptions).then((index) => {
+      loadedIndex = index;
+      return index;
+    });
+    return indexPromise;
+  };
+  return {
+    name: "eve-resfile-rollup",
+    buildStart() {
+      return __async(this, null, function* () {
+        const index = yield ensureIndex();
+        this.info(
+          `Loaded EVE resfileindex (build ${index.buildNumber}, ${index.resPathToCdnPath.size} entries).`
+        );
+      });
+    },
+    resolveId(source) {
+      return resolveResfileId(source);
+    },
+    load(id) {
+      return __async(this, null, function* () {
+        if (!isVirtualResId(id)) {
+          return null;
+        }
+        const resPath = resPathFromVirtualId(id);
+        const index = loadedIndex != null ? loadedIndex : yield ensureIndex();
+        return loadResfileAssetModule({
+          watchMode: this.meta.watchMode,
+          assetOrigin: userOptions.assetOrigin,
+          index,
+          resPath,
+          emitAsset: (name, source) => this.emitFile({
+            type: "asset",
+            name,
+            source
+          })
+        });
+      });
+    }
+  };
+};
+export {
+  eveResfile
+};

package/dist/types-DUuyxUdh.d.cts

@@ -0,0 +1,28 @@
+type EveResfileOptions = {
+    /** Pin to a specific client build; omit to fetch latest from eveclient_TQ.json */
+    buildNumber?: number | string;
+    /** Override index CDN (default: https://binaries.eveonline.com) */
+    indexOrigin?: string;
+    /** Override asset CDN (default: https://resources.eveonline.com) */
+    assetOrigin?: string;
+    /** Cache dir relative to project root, or an absolute path (default: .cache/eve-resfile) */
+    cacheDir?: string;
+    /** Project root for resolving cacheDir (Rollup, or when not using the Vite plugin) */
+    root?: string;
+};
+type ResolvedEveResfileOptions = {
+    buildNumber?: number | string;
+    indexOrigin: string;
+    assetOrigin: string;
+    /** Absolute cache directory path */
+    cacheDir: string;
+};
+type ResfileIndex = {
+    buildNumber: string;
+    resPathToCdnPath: Map<string, string>;
+};
+type EveClientManifest = {
+    buildNumber: string;
+};
+
+export type { EveClientManifest as E, ResolvedEveResfileOptions as R, ResfileIndex as a, EveResfileOptions as b };

package/dist/types-DUuyxUdh.d.ts

@@ -0,0 +1,28 @@
+type EveResfileOptions = {
+    /** Pin to a specific client build; omit to fetch latest from eveclient_TQ.json */
+    buildNumber?: number | string;
+    /** Override index CDN (default: https://binaries.eveonline.com) */
+    indexOrigin?: string;
+    /** Override asset CDN (default: https://resources.eveonline.com) */
+    assetOrigin?: string;
+    /** Cache dir relative to project root, or an absolute path (default: .cache/eve-resfile) */
+    cacheDir?: string;
+    /** Project root for resolving cacheDir (Rollup, or when not using the Vite plugin) */
+    root?: string;
+};
+type ResolvedEveResfileOptions = {
+    buildNumber?: number | string;
+    indexOrigin: string;
+    assetOrigin: string;
+    /** Absolute cache directory path */
+    cacheDir: string;
+};
+type ResfileIndex = {
+    buildNumber: string;
+    resPathToCdnPath: Map<string, string>;
+};
+type EveClientManifest = {
+    buildNumber: string;
+};
+
+export type { EveClientManifest as E, ResolvedEveResfileOptions as R, ResfileIndex as a, EveResfileOptions as b };

package/dist/vite/client.d.ts

@@ -0,0 +1,4 @@
+declare module "res:/*" {
+  const src: string;
+  export default src;
+}

package/dist/vite/index.cjs

@@ -0,0 +1,416 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve2, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/vite/index.ts
+var vite_exports = {};
+__export(vite_exports, {
+  eveResfile: () => eveResfile
+});
+module.exports = __toCommonJS(vite_exports);
+
+// src/content-type.ts
+var import_node_path = require("path");
+var CONTENT_TYPES = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".dds": "image/vnd-ms.dds",
+  ".mp3": "audio/mpeg",
+  ".ogg": "audio/ogg",
+  ".wav": "audio/wav",
+  ".webm": "video/webm",
+  ".mp4": "video/mp4",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".json": "application/json",
+  ".txt": "text/plain"
+};
+var contentTypeForPath = (resPath) => {
+  var _a;
+  return (_a = CONTENT_TYPES[(0, import_node_path.extname)(resPath).toLowerCase()]) != null ? _a : "application/octet-stream";
+};
+
+// src/constants.ts
+var DEFAULT_INDEX_ORIGIN = "https://binaries.eveonline.com";
+var DEFAULT_ASSET_ORIGIN = "https://resources.eveonline.com";
+var DEFAULT_CACHE_DIR = ".cache/eve-resfile";
+var EVE_CLIENT_MANIFEST = "eveclient_TQ.json";
+var RESFILE_INDEX_PATH = "app:/resfileindex.txt";
+var VIRTUAL_PREFIX = "\0res:";
+var DEV_PROXY_PREFIX = "/__eve_res__/";
+var RES_IMPORT_PREFIX = "res:/";
+
+// src/fetch.ts
+var fetchText = (url) => __async(null, null, function* () {
+  const response = yield fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url} (${response.status}).`);
+  }
+  return response.text();
+});
+var fetchBuffer = (url) => __async(null, null, function* () {
+  const response = yield fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch ${url} (${response.status}).`);
+  }
+  const arrayBuffer = yield response.arrayBuffer();
+  return Buffer.from(arrayBuffer);
+});
+
+// src/index-loader.ts
+var import_promises2 = require("fs/promises");
+
+// src/cache.ts
+var import_node_fs = require("fs");
+var import_promises = require("fs/promises");
+var import_node_path2 = require("path");
+var buildCacheDir = (cacheDir, buildNumber) => (0, import_node_path2.join)(cacheDir, buildNumber);
+var buildIndexPath = (cacheDir, buildNumber) => (0, import_node_path2.join)(buildCacheDir(cacheDir, buildNumber), "build-index.txt");
+var resfileIndexPath = (cacheDir, buildNumber) => (0, import_node_path2.join)(buildCacheDir(cacheDir, buildNumber), "resfileindex.txt");
+var resfileMapPath = (cacheDir, buildNumber) => (0, import_node_path2.join)(buildCacheDir(cacheDir, buildNumber), "resfile-map.json");
+var readCachedText = (path) => __async(null, null, function* () {
+  if (!(0, import_node_fs.existsSync)(path)) {
+    return null;
+  }
+  return (0, import_promises.readFile)(path, "utf8");
+});
+var writeCachedText = (path, content) => __async(null, null, function* () {
+  yield (0, import_promises.mkdir)((0, import_node_path2.join)(path, ".."), { recursive: true });
+  yield (0, import_promises.writeFile)(path, content);
+});
+var readCachedMap = (path) => __async(null, null, function* () {
+  if (!(0, import_node_fs.existsSync)(path)) {
+    return null;
+  }
+  const parsed = JSON.parse(yield (0, import_promises.readFile)(path, "utf8"));
+  return new Map(Object.entries(parsed));
+});
+var writeCachedMap = (path, map) => __async(null, null, function* () {
+  yield (0, import_promises.mkdir)((0, import_node_path2.join)(path, ".."), { recursive: true });
+  yield (0, import_promises.writeFile)(path, JSON.stringify(Object.fromEntries(map)));
+});
+
+// src/parse.ts
+var parseFirstTwoColumns = (line) => {
+  const commaIndex = line.indexOf(",");
+  if (commaIndex === -1) {
+    return null;
+  }
+  const path = line.slice(0, commaIndex);
+  const remainder = line.slice(commaIndex + 1);
+  const secondComma = remainder.indexOf(",");
+  const cdnPath = secondComma === -1 ? remainder : remainder.slice(0, secondComma);
+  if (!path || !cdnPath) {
+    return null;
+  }
+  return [path, cdnPath];
+};
+var parseResfileIndex = (content) => {
+  const map = /* @__PURE__ */ new Map();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const parsed = parseFirstTwoColumns(trimmed);
+    if (!parsed) {
+      continue;
+    }
+    const [resPath, cdnPath] = parsed;
+    map.set(resPath, cdnPath);
+  }
+  return map;
+};
+var findResfileIndexCdnPath = (buildIndex) => {
+  for (const line of buildIndex.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const parsed = parseFirstTwoColumns(trimmed);
+    if (!parsed) {
+      continue;
+    }
+    const [path, cdnPath] = parsed;
+    if (path === RESFILE_INDEX_PATH) {
+      return cdnPath;
+    }
+  }
+  throw new Error(`${RESFILE_INDEX_PATH} not found in build index.`);
+};
+
+// src/index-loader.ts
+var resolveBuildNumber = (options) => __async(null, null, function* () {
+  if (options.buildNumber !== void 0) {
+    return String(options.buildNumber);
+  }
+  const manifestUrl = `${options.indexOrigin}/${EVE_CLIENT_MANIFEST}`;
+  const manifest = JSON.parse(yield fetchText(manifestUrl));
+  if (!manifest.buildNumber) {
+    throw new Error(`Missing buildNumber in ${manifestUrl}.`);
+  }
+  return manifest.buildNumber;
+});
+var loadBuildIndex = (options, buildNumber) => __async(null, null, function* () {
+  const cachedPath = buildIndexPath(options.cacheDir, buildNumber);
+  const cached = yield readCachedText(cachedPath);
+  if (cached) {
+    return cached;
+  }
+  const buildIndexUrl = `${options.indexOrigin}/eveonline_${buildNumber}.txt`;
+  const content = yield fetchText(buildIndexUrl);
+  yield writeCachedText(cachedPath, content);
+  return content;
+});
+var loadResfileIndex = (options, buildNumber, cdnPath) => __async(null, null, function* () {
+  const cachedPath = resfileIndexPath(options.cacheDir, buildNumber);
+  const cached = yield readCachedText(cachedPath);
+  if (cached) {
+    return cached;
+  }
+  const resfileIndexUrl = `${options.indexOrigin}/${cdnPath}`;
+  const content = yield fetchText(resfileIndexUrl);
+  yield writeCachedText(cachedPath, content);
+  return content;
+});
+var loadResfileIndexData = (options) => __async(null, null, function* () {
+  const { cacheDir } = options;
+  const buildNumber = yield resolveBuildNumber(options);
+  yield (0, import_promises2.mkdir)(buildCacheDir(cacheDir, buildNumber), { recursive: true });
+  const cachedMap = yield readCachedMap(resfileMapPath(cacheDir, buildNumber));
+  if (cachedMap) {
+    return { buildNumber, resPathToCdnPath: cachedMap };
+  }
+  const buildIndex = yield loadBuildIndex(options, buildNumber);
+  const resfileIndexCdnPath = findResfileIndexCdnPath(buildIndex);
+  const resfileIndex = yield loadResfileIndex(options, buildNumber, resfileIndexCdnPath);
+  const resPathToCdnPath = parseResfileIndex(resfileIndex);
+  yield writeCachedMap(resfileMapPath(cacheDir, buildNumber), resPathToCdnPath);
+  return { buildNumber, resPathToCdnPath };
+});
+
+// src/lookup.ts
+var normalizeResPath = (source) => {
+  var _a;
+  const withoutQuery = (_a = source.split(/[?#]/)[0]) != null ? _a : source;
+  if (withoutQuery.startsWith(RES_IMPORT_PREFIX)) {
+    return withoutQuery;
+  }
+  if (withoutQuery.startsWith("res:")) {
+    const path = withoutQuery.slice("res:".length);
+    return path.startsWith("/") ? `res:${path}` : `res:/${path}`;
+  }
+  throw new Error(`Invalid res import "${source}". Expected a path starting with "res:/".`);
+};
+var lookupCdnPath = (index, resPath) => index.get(resPath);
+var devProxyUrl = (resPath) => {
+  const encoded = encodeURIComponent(resPath.slice(RES_IMPORT_PREFIX.length));
+  return `/__eve_res__/${encoded}`;
+};
+var resPathFromDevProxyUrl = (pathname) => {
+  if (!pathname.startsWith("/__eve_res__/")) {
+    return null;
+  }
+  const encoded = pathname.slice("/__eve_res__/".length);
+  if (!encoded) {
+    return null;
+  }
+  return `${RES_IMPORT_PREFIX}${decodeURIComponent(encoded)}`;
+};
+
+// src/plugin-core.ts
+var import_node_path3 = require("path");
+var resolveEveResfileOptions = (options = {}, root) => {
+  var _a, _b, _c;
+  const cacheDir = (_a = options.cacheDir) != null ? _a : DEFAULT_CACHE_DIR;
+  return {
+    buildNumber: options.buildNumber,
+    indexOrigin: (_b = options.indexOrigin) != null ? _b : DEFAULT_INDEX_ORIGIN,
+    assetOrigin: (_c = options.assetOrigin) != null ? _c : DEFAULT_ASSET_ORIGIN,
+    cacheDir: (0, import_node_path3.isAbsolute)(cacheDir) ? cacheDir : (0, import_node_path3.resolve)(root, cacheDir)
+  };
+};
+var isVirtualResId = (id) => id.startsWith(VIRTUAL_PREFIX);
+var virtualIdForResPath = (resPath) => `${VIRTUAL_PREFIX}${resPath}`;
+var resPathFromVirtualId = (id) => id.slice(VIRTUAL_PREFIX.length);
+var lookupOrThrow = (index, resPath) => {
+  const cdnPath = lookupCdnPath(index.resPathToCdnPath, resPath);
+  if (!cdnPath) {
+    throw new Error(`${resPath} not found in resfileindex (build ${index.buildNumber}).`);
+  }
+  return cdnPath;
+};
+var resolveResfileId = (source) => {
+  if (!source.startsWith(RES_IMPORT_PREFIX)) {
+    return null;
+  }
+  return virtualIdForResPath(normalizeResPath(source));
+};
+var loadResfileAssetModule = (_0) => __async(null, [_0], function* ({
+  watchMode,
+  assetOrigin,
+  index,
+  resPath,
+  emitAsset
+}) {
+  const cdnPath = lookupOrThrow(index, resPath);
+  if (watchMode) {
+    return `export default ${JSON.stringify(devProxyUrl(resPath))}`;
+  }
+  const buffer = yield fetchBuffer(`${assetOrigin}/${cdnPath}`);
+  const referenceId = emitAsset((0, import_node_path3.basename)(resPath), buffer);
+  return `export default import.meta.ROLLUP_FILE_URL_${referenceId}`;
+});
+
+// src/vite/plugin.ts
+var createDevProxyMiddleware = (ensureIndex, assetOrigin) => {
+  return (req, res, next) => __async(null, null, function* () {
+    if (!req.url || req.method !== "GET") {
+      next();
+      return;
+    }
+    const pathname = new URL(req.url, "http://localhost").pathname;
+    if (!pathname.startsWith(DEV_PROXY_PREFIX)) {
+      next();
+      return;
+    }
+    const resPath = resPathFromDevProxyUrl(pathname);
+    if (!resPath) {
+      res.statusCode = 400;
+      res.end("Invalid resfile proxy path.");
+      return;
+    }
+    let cdnPath;
+    try {
+      const index = yield ensureIndex();
+      cdnPath = lookupOrThrow(index, resPath);
+    } catch (error) {
+      res.statusCode = 404;
+      res.end(error instanceof Error ? error.message : "Resfile not found.");
+      return;
+    }
+    try {
+      const buffer = yield fetchBuffer(`${assetOrigin}/${cdnPath}`);
+      res.statusCode = 200;
+      res.setHeader("Content-Type", contentTypeForPath(resPath));
+      res.setHeader("Cache-Control", "public, max-age=86400");
+      res.end(buffer);
+    } catch (error) {
+      res.statusCode = 502;
+      res.end(error instanceof Error ? error.message : "Failed to fetch resfile from CDN.");
+    }
+  });
+};
+var eveResfile = (options = {}) => {
+  let resolvedOptions = null;
+  let indexPromise = null;
+  let loadedIndex = null;
+  const ensureIndex = () => {
+    if (!resolvedOptions) {
+      throw new Error("@eve-online-tools/eve-resfile/vite: configResolved has not run yet.");
+    }
+    indexPromise != null ? indexPromise : indexPromise = loadResfileIndexData(resolvedOptions).then((index) => {
+      loadedIndex = index;
+      return index;
+    });
+    return indexPromise;
+  };
+  return {
+    name: "eve-resfile-vite",
+    enforce: "pre",
+    configResolved(config) {
+      resolvedOptions = resolveEveResfileOptions(options, config.root);
+    },
+    buildStart() {
+      return __async(this, null, function* () {
+        const index = yield ensureIndex();
+        this.info(
+          `Loaded EVE resfileindex (build ${index.buildNumber}, ${index.resPathToCdnPath.size} entries).`
+        );
+      });
+    },
+    configureServer: {
+      order: "pre",
+      handler(server) {
+        var _a2;
+        server.middlewares.use(
+          createDevProxyMiddleware(
+            ensureIndex,
+            (_a2 = resolvedOptions == null ? void 0 : resolvedOptions.assetOrigin) != null ? _a2 : DEFAULT_ASSET_ORIGIN
+          )
+        );
+      }
+    },
+    resolveId(source) {
+      return resolveResfileId(source);
+    },
+    load(id) {
+      return __async(this, null, function* () {
+        if (!isVirtualResId(id)) {
+          return null;
+        }
+        if (!resolvedOptions) {
+          throw new Error("@eve-online-tools/eve-resfile/vite: configResolved has not run yet.");
+        }
+        const resPath = resPathFromVirtualId(id);
+        const index = loadedIndex != null ? loadedIndex : yield ensureIndex();
+        return loadResfileAssetModule({
+          watchMode: this.meta.watchMode,
+          assetOrigin: resolvedOptions.assetOrigin,
+          index,
+          resPath,
+          emitAsset: (name, source) => this.emitFile({
+            type: "asset",
+            name,
+            source
+          })
+        });
+      });
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  eveResfile
+});

package/dist/vite/index.d.cts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+import { b as EveResfileOptions } from '../types-DUuyxUdh.cjs';
+
+declare const eveResfile: (options?: EveResfileOptions) => Plugin;
+
+export { EveResfileOptions, eveResfile };

package/dist/vite/index.d.ts

@@ -0,0 +1,6 @@
+import { Plugin } from 'vite';
+import { b as EveResfileOptions } from '../types-DUuyxUdh.js';
+
+declare const eveResfile: (options?: EveResfileOptions) => Plugin;
+
+export { EveResfileOptions, eveResfile };