@riebeckite/plugin-icons 0.0.35 → 0.0.36

package/dist/index.js

@@ -417,30 +417,30 @@ function readSource(source, target, manual) {
       exists: found !== void 0
     };
   }
-  const path3 = target.path;
+  const path4 = target.path;
   switch (source) {
     case "icon":
       return { kind: "string", value: manual?.icon ?? "" };
     case "color":
       return { kind: "string", value: manual?.color ?? "" };
     case "name": {
-      const name = path3.split("/").pop() ?? path3;
+      const name = path4.split("/").pop() ?? path4;
       return {
         kind: "string",
         value: name.replace(/\.[^.]+$/, "")
       };
     }
     case "filename":
-      return { kind: "string", value: path3.split("/").pop() ?? path3 };
+      return { kind: "string", value: path4.split("/").pop() ?? path4 };
     case "extension": {
-      const name = path3.split("/").pop() ?? path3;
+      const name = path4.split("/").pop() ?? path4;
       const dot = name.lastIndexOf(".");
       return { kind: "string", value: dot > 0 ? name.slice(dot + 1) : "" };
     }
     case "tree":
-      return { kind: "string", value: path3.split("/").slice(0, -1).join("/") };
+      return { kind: "string", value: path4.split("/").slice(0, -1).join("/") };
     case "path":
-      return { kind: "string", value: path3 };
+      return { kind: "string", value: path4 };
     case "tags":
       return { kind: "array", value: target.tags ?? [] };
     case "links":
@@ -601,15 +601,99 @@ function toBoolean(value) {
 }
 
 // src/settings.ts
-import { promises as fs } from "node:fs";
-import path from "node:path";
+import { promises as fs2 } from "node:fs";
+import path2 from "node:path";
 import {
   fingerprintExternalValue
 } from "@riebeckite/core";
+
+// src/icon_packs.ts
+import { promises as fs } from "node:fs";
+import path from "node:path";
+var MAX_SVG_BYTES = 256 * 1024;
+function normalizeIconName(name) {
+  return name.split(/[\s_-]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+async function loadIconPacks(root, diagnostics) {
+  const packs = /* @__PURE__ */ new Map();
+  let entries;
+  try {
+    entries = await fs.readdir(root, { withFileTypes: true });
+  } catch {
+    return packs;
+  }
+  let zipCount = 0;
+  for (const entry of entries) {
+    if (entry.isSymbolicLink()) continue;
+    if (entry.isFile() && entry.name.toLowerCase().endsWith(".zip")) {
+      zipCount += 1;
+      continue;
+    }
+    if (!entry.isDirectory()) continue;
+    const packPath = path.join(root, entry.name);
+    const realPack = await safeRealPath(packPath);
+    if (!realPack || !isWithin(root, realPack)) continue;
+    let files;
+    try {
+      files = await fs.readdir(realPack, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    const pack = /* @__PURE__ */ new Map();
+    for (const file of files) {
+      if (!file.isFile() || !file.name.toLowerCase().endsWith(".svg")) {
+        continue;
+      }
+      const filePath = path.join(realPack, file.name);
+      const realFile = await safeRealPath(filePath);
+      if (!realFile || !isWithin(root, realFile)) continue;
+      try {
+        const stat = await fs.stat(realFile);
+        if (stat.size > MAX_SVG_BYTES) continue;
+        const iconName = normalizeIconName(
+          file.name.slice(0, -".svg".length)
+        ).toLowerCase();
+        if (!iconName) continue;
+        pack.set(iconName, {
+          name: file.name,
+          filePath: realFile,
+          size: stat.size,
+          modified: stat.mtimeMs
+        });
+      } catch {
+      }
+    }
+    if (pack.size > 0) {
+      const packName = normalizeIconName(entry.name).toLowerCase();
+      if (packName) packs.set(packName, pack);
+    }
+  }
+  if (zipCount > 0) {
+    diagnostics.push({
+      code: "icons-unsupported-zip-pack",
+      severity: "info",
+      message: "Zip-based Iconize icon packs are not read; extract them into folders under the icon packs directory.",
+      meta: { packCount: zipCount }
+    });
+  }
+  return packs;
+}
+function isWithin(root, target) {
+  const relative = path.relative(path.resolve(root), path.resolve(target));
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+async function safeRealPath(value) {
+  try {
+    return await fs.realpath(value);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/settings.ts
 var ICONIZE_ID = "obsidian-icon-folder";
 var ICONIC_ID = "iconic";
 var MAX_SETTINGS_BYTES = 2 * 1024 * 1024;
-var MAX_SVG_BYTES = 256 * 1024;
 var DEFAULT_ICONIZE_SETTINGS = {
   iconPacksPath: ".obsidian/icons",
   iconColor: null,
@@ -686,9 +770,6 @@ function findIconPackFile(packs, packName, iconName) {
   if (!pack) return void 0;
   return pack.get(normalizeIconName(iconName).toLowerCase());
 }
-function normalizeIconName(name) {
-  return name.split(/[\s_-]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
-}
 function normalizeVaultPath(value) {
   const normalized = value.normalize("NFC").replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "").replace(/\/{2,}/g, "/");
   if (!normalized || normalized.includes("\0")) return void 0;
@@ -700,18 +781,18 @@ function normalizeVaultPath(value) {
 }
 async function resolveVaultRoot(options, contentDirectory) {
   if (options.vaultRoot) {
-    const explicit = path.resolve(options.vaultRoot);
-    const root = path.basename(explicit) === ".obsidian" ? path.dirname(explicit) : explicit;
+    const explicit = path2.resolve(options.vaultRoot);
+    const root = path2.basename(explicit) === ".obsidian" ? path2.dirname(explicit) : explicit;
     return await isDirectory(root) ? root : void 0;
   }
   const starts = [contentDirectory, process.cwd()].filter(
     (value) => typeof value === "string"
   );
   for (const start of starts) {
-    let current = path.resolve(start);
+    let current = path2.resolve(start);
     for (; ; ) {
-      if (await isDirectory(path.join(current, ".obsidian"))) return current;
-      const parent = path.dirname(current);
+      if (await isDirectory(path2.join(current, ".obsidian"))) return current;
+      const parent = path2.dirname(current);
       if (parent === current) break;
       current = parent;
     }
@@ -723,8 +804,8 @@ function resolveVaultPrefix(options, vaultRoot, contentDirectory) {
     return normalizeVaultPath(options.vaultPrefix) ?? "";
   }
   if (!vaultRoot || !contentDirectory) return "";
-  const relative = path.relative(vaultRoot, path.resolve(contentDirectory));
-  if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+  const relative = path2.relative(vaultRoot, path2.resolve(contentDirectory));
+  if (!relative || relative.startsWith("..") || path2.isAbsolute(relative)) {
     return "";
   }
   return `${normalizeVaultPath(relative) ?? ""}/`.replace(/^\/+/, "");
@@ -732,8 +813,8 @@ function resolveVaultPrefix(options, vaultRoot, contentDirectory) {
 async function resolveDataFile(input) {
   const root = input.vaultRoot ?? input.root;
   if (input.explicit) {
-    const resolved = path.resolve(input.root, input.explicit);
-    if (!isWithin(root, resolved)) {
+    const resolved = path2.resolve(input.root, input.explicit);
+    if (!isWithin2(root, resolved)) {
       input.diagnostics.push({
         code: "icons-untrusted-settings-path",
         severity: "warning",
@@ -744,7 +825,7 @@ async function resolveDataFile(input) {
     }
     return await isFile(resolved) ? resolved : void 0;
   }
-  const candidate = path.join(
+  const candidate = path2.join(
     root,
     ".obsidian",
     "plugins",
@@ -778,10 +859,10 @@ async function readJsonFile(filePath, source, diagnostics) {
 }
 async function readTextFile(filePath, maxBytes) {
   try {
-    const stat = await fs.lstat(filePath);
+    const stat = await fs2.lstat(filePath);
     if (!stat.isFile() || stat.isSymbolicLink()) return void 0;
     if (stat.size > maxBytes) return void 0;
-    return await fs.readFile(filePath, "utf8");
+    return await fs2.readFile(filePath, "utf8");
   } catch {
     return void 0;
   }
@@ -928,73 +1009,9 @@ function parseIconicRules(value) {
   }
   return rules;
 }
-async function loadIconPacks(root, diagnostics) {
-  const packs = /* @__PURE__ */ new Map();
-  let entries;
-  try {
-    entries = await fs.readdir(root, { withFileTypes: true });
-  } catch {
-    return packs;
-  }
-  let zipCount = 0;
-  for (const entry of entries) {
-    if (entry.isSymbolicLink()) continue;
-    if (entry.isFile() && entry.name.toLowerCase().endsWith(".zip")) {
-      zipCount += 1;
-      continue;
-    }
-    if (!entry.isDirectory()) continue;
-    const packPath = path.join(root, entry.name);
-    const realPack = await safeRealPath(packPath);
-    if (!realPack || !isWithin(root, realPack)) continue;
-    let files;
-    try {
-      files = await fs.readdir(realPack, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    const pack = /* @__PURE__ */ new Map();
-    for (const file of files) {
-      if (!file.isFile() || !file.name.toLowerCase().endsWith(".svg")) {
-        continue;
-      }
-      const filePath = path.join(realPack, file.name);
-      const realFile = await safeRealPath(filePath);
-      if (!realFile || !isWithin(root, realFile)) continue;
-      try {
-        const stat = await fs.stat(realFile);
-        if (stat.size > MAX_SVG_BYTES) continue;
-        const iconName = normalizeIconName(
-          file.name.slice(0, -".svg".length)
-        ).toLowerCase();
-        if (!iconName) continue;
-        pack.set(iconName, {
-          name: file.name,
-          filePath: realFile,
-          size: stat.size,
-          modified: stat.mtimeMs
-        });
-      } catch {
-      }
-    }
-    if (pack.size > 0) {
-      const packName = normalizeIconName(entry.name).toLowerCase();
-      if (packName) packs.set(packName, pack);
-    }
-  }
-  if (zipCount > 0) {
-    diagnostics.push({
-      code: "icons-unsupported-zip-pack",
-      severity: "info",
-      message: "Zip-based Iconize icon packs are not read; extract them into folders under the icon packs directory.",
-      meta: { packCount: zipCount }
-    });
-  }
-  return packs;
-}
 function resolvePackRoot(vaultRoot, value) {
-  const resolved = path.resolve(vaultRoot, value);
-  return isWithin(vaultRoot, resolved) ? resolved : void 0;
+  const resolved = path2.resolve(vaultRoot, value);
+  return isWithin2(vaultRoot, resolved) ? resolved : void 0;
 }
 function isLucidePackType(value) {
   return value === "none" || value === "custom" || value === "native";
@@ -1005,13 +1022,13 @@ function nonEmptyString(value) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isWithin(root, target) {
-  const relative = path.relative(path.resolve(root), path.resolve(target));
-  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+function isWithin2(root, target) {
+  const relative = path2.relative(path2.resolve(root), path2.resolve(target));
+  return relative === "" || !relative.startsWith("..") && !path2.isAbsolute(relative);
 }
 async function isDirectory(value) {
   try {
-    const stat = await fs.lstat(value);
+    const stat = await fs2.lstat(value);
     return stat.isDirectory() && !stat.isSymbolicLink();
   } catch {
     return false;
@@ -1019,19 +1036,12 @@ async function isDirectory(value) {
 }
 async function isFile(value) {
   try {
-    const stat = await fs.lstat(value);
+    const stat = await fs2.lstat(value);
     return stat.isFile() && !stat.isSymbolicLink();
   } catch {
     return false;
   }
 }
-async function safeRealPath(value) {
-  try {
-    return await fs.realpath(value);
-  } catch {
-    return void 0;
-  }
-}
 
 // src/iconize.ts
 function resolveIconize(data, target, options) {
@@ -1101,7 +1111,7 @@ function matchesRule2(pattern, value) {
 // src/render.ts
 import { readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import path2 from "node:path";
+import path3 from "node:path";
 import {
   escapeHtml,
   escapeHtmlAttribute
@@ -1220,7 +1230,7 @@ var IconRenderer = class {
       const name = reference.slice("lucide:".length);
       if (/^[a-z0-9-]+$/.test(name) && this.#lucideDirectory) {
         html = renderSvg(
-          readSvg(path2.join(this.#lucideDirectory, `${name}.svg`))
+          readSvg(path3.join(this.#lucideDirectory, `${name}.svg`))
         );
       }
     } else if (reference.startsWith("text:")) {
@@ -1254,17 +1264,17 @@ function resolveLucideDirectory() {
   try {
     const require2 = createRequire(import.meta.url);
     try {
-      return path2.join(
-        path2.dirname(require2.resolve("lucide-static/package.json")),
+      return path3.join(
+        path3.dirname(require2.resolve("lucide-static/package.json")),
         "icons"
       );
     } catch {
-      let current = path2.dirname(require2.resolve("lucide-static"));
+      let current = path3.dirname(require2.resolve("lucide-static"));
       for (; ; ) {
-        if (path2.basename(current) === "lucide-static") {
-          return path2.join(current, "icons");
+        if (path3.basename(current) === "lucide-static") {
+          return path3.join(current, "icons");
         }
-        const parent = path2.dirname(current);
+        const parent = path3.dirname(current);
         if (parent === current) return void 0;
         current = parent;
       }

package/dist/src/icon_packs.d.ts

@@ -0,0 +1,15 @@
+export type IconDiagnostic = {
+    readonly code: string;
+    readonly severity: "info" | "warning";
+    readonly message: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+};
+export type IconPackFile = {
+    readonly name: string;
+    readonly filePath: string;
+    readonly size: number;
+    readonly modified: number;
+};
+export type IconPacks = ReadonlyMap<string, ReadonlyMap<string, IconPackFile>>;
+export declare function normalizeIconName(name: string): string;
+export declare function loadIconPacks(root: string, diagnostics: IconDiagnostic[]): Promise<IconPacks>;

package/dist/src/settings.d.ts

@@ -1,18 +1,8 @@
 import { type ResolvedRiebeckiteConfig } from "@riebeckite/core";
+import { type IconDiagnostic, type IconPackFile, type IconPacks } from "./icon_packs.js";
 import type { IconicData, IconizeData, ResolvedIconsOptions } from "./types.js";
-type IconDiagnostic = {
-    readonly code: string;
-    readonly severity: "info" | "warning";
-    readonly message: string;
-    readonly meta?: Readonly<Record<string, unknown>>;
-};
-type IconPackFile = {
-    readonly name: string;
-    readonly filePath: string;
-    readonly size: number;
-    readonly modified: number;
-};
-export type IconPacks = ReadonlyMap<string, ReadonlyMap<string, IconPackFile>>;
+export type { IconPacks } from "./icon_packs.js";
+export { normalizeIconName } from "./icon_packs.js";
 export type LoadedIconsSettings = {
     readonly iconize?: IconizeData;
     readonly iconic?: IconicData;
@@ -24,6 +14,4 @@ export type LoadedIconsSettings = {
 };
 export declare function loadIconsSettings(options: ResolvedIconsOptions, config: ResolvedRiebeckiteConfig | undefined): Promise<LoadedIconsSettings>;
 export declare function findIconPackFile(packs: IconPacks, packName: string, iconName: string): IconPackFile | undefined;
-export declare function normalizeIconName(name: string): string;
 export declare function normalizeVaultPath(value: string): string | undefined;
-export {};

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@riebeckite/plugin-icons",
-  "version": "0.0.35",
+  "version": "0.0.36",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
-    "@riebeckite/core": "0.0.35",
+    "@riebeckite/core": "0.0.36",
     "@types/mdast": "^4.0.4",
     "lucide-static": "^1.61.0",
     "sanitize-html": "^2.18.1"