@kenjura/ursa 0.90.1 → 0.95.0

package/meta/templates/default-template/widgets.js

@@ -6,10 +6,15 @@
  * dropdown panels. One widget can be open per side at a time.
  * 
  * Widget state (open/closed) is persisted in localStorage so it survives page reloads.
+ *
+ * An open panel carries data-active-widget naming whichever widget is showing,
+ * and loses it when it closes. The panels are shared containers, so this is what
+ * lets CSS — Ursa's own and a site's — tell one widget's panel from another's.
+ * See "Styling one widget at a time" in the README.
  * 
  * Built-in widgets:
  *   Left: Recent Activity (open by default)
- *   Right: TOC, Search, Profile
+ *   Right: TOC (open by default, persistent), Search, Profile
  */
 class WidgetManager {
   constructor() {
@@ -19,8 +24,31 @@ class WidgetManager {
     this.activeRight = null;
     this.activeLeft = null;
 
-    // Widgets that default to open on first visit
-    this.defaultOpen = new Set(['recent-activity']);
+    // Widgets that default to open on first visit. The TOC is here because it
+    // is reference furniture rather than a tool you go and fetch: it belongs
+    // beside the article the way page numbers belong on a page. It costs
+    // nothing to leave up — the stylesheet gives it the right margin, and
+    // takes it away again on a viewport with no margin to spare.
+    this.defaultOpen = new Set(['recent-activity', 'toc']);
+
+    // Widgets that are furniture rather than a drawer. Two things follow.
+    //
+    // A click elsewhere on the page does not dismiss them. Light dismissal is
+    // right for something you pull open, glance at and are done with, but the
+    // first half of following a link is a click on the page — so for a widget
+    // meant to stay up it fired constantly, and, because dismissal is recorded,
+    // it wrote down "the reader closed this" every time. One click on an
+    // article and the TOC was off for good, on that page and every page after.
+    // Escape is out for the same reason: it would be remembered.
+    //
+    // And they own their side of the nav. Another widget opening there is
+    // borrowing it, not replacing them — the loan is not recorded as a closure,
+    // and they come back when it is handed back.
+    //
+    // Which leaves the button in the nav and the panel's own close button as
+    // the only two things that decide whether a persistent widget is showing.
+    // Those are unambiguous, and those are remembered.
+    this.persistent = new Set(['toc']);
     
     if (this.buttons.length === 0) return;
     
@@ -86,12 +114,14 @@ class WidgetManager {
     document.addEventListener('click', (e) => {
       // Close right-side widget if click is outside
       if (this.activeRight && this.dropdownRight &&
+          !this.persistent.has(this.activeRight) &&
           !this.dropdownRight.contains(e.target) &&
           !e.target.closest('.widget-button')) {
         this.close('right');
       }
       // Close left-side widget if click is outside
       if (this.activeLeft && this.dropdownLeft &&
+          !this.persistent.has(this.activeLeft) &&
           !this.dropdownLeft.contains(e.target) &&
           !e.target.closest('.widget-button')) {
         this.close('left');
@@ -101,8 +131,8 @@ class WidgetManager {
     // Close on Escape
     document.addEventListener('keydown', (e) => {
       if (e.key === 'Escape') {
-        if (this.activeRight) this.close('right');
-        if (this.activeLeft) this.close('left');
+        if (this.activeRight && !this.persistent.has(this.activeRight)) this.close('right');
+        if (this.activeLeft && !this.persistent.has(this.activeLeft)) this.close('left');
       }
     });
 
@@ -130,6 +160,29 @@ class WidgetManager {
     } catch (e) { /* localStorage not available */ }
   }
   
+  /**
+   * Whether a widget should be showing, as far as the reader's own choices go:
+   * what they last decided, or the default if they have not decided anything.
+   */
+  wantsToBeOpen(widgetName) {
+    let saved;
+    try {
+      saved = localStorage.getItem(`ursa-widget-${widgetName}`);
+    } catch (e) { /* localStorage not available */ }
+    
+    return saved === 'open' || (saved == null && this.defaultOpen.has(widgetName));
+  }
+  
+  /**
+   * The widget that owns a side of the nav when nothing else is using it.
+   */
+  residentOf(side) {
+    for (const widgetName of this.persistent) {
+      if (this.getSide(widgetName) === side) return widgetName;
+    }
+    return null;
+  }
+  
   /**
    * Restore widget states from localStorage. 
    * For widgets with no saved state, use their default (defaultOpen set).
@@ -140,19 +193,24 @@ class WidgetManager {
     this.buttons.forEach(btn => widgetNames.add(btn.dataset.widget));
     
     for (const widgetName of widgetNames) {
-      const key = `ursa-widget-${widgetName}`;
-      let saved;
-      try {
-        saved = localStorage.getItem(key);
-      } catch (e) { /* localStorage not available */ }
-      
-      const shouldOpen = saved === 'open' || (saved === null && this.defaultOpen.has(widgetName));
-      if (shouldOpen) {
+      if (this.wantsToBeOpen(widgetName) && this.hasContent(widgetName)) {
         this.open(widgetName);
       }
     }
   }
   
+  /**
+   * Whether a widget has anything to show. A widget that has hidden its own
+   * button has nothing — the TOC generator does exactly that on a page with no
+   * headings — and restoring it would put an empty panel on screen with no
+   * button to shut it again. Only relevant on restore: a widget the reader
+   * opens by hand plainly has a button to have clicked.
+   */
+  hasContent(widgetName) {
+    const btn = document.querySelector(`.widget-button[data-widget="${widgetName}"]`);
+    return !btn || btn.style.display !== 'none';
+  }
+
   /**
    * Toggle a widget open/closed.
    */
@@ -178,8 +236,12 @@ class WidgetManager {
     const currentActive = this.getActive(side);
     if (currentActive) {
       this.deactivateContent(currentActive);
-      // Save the closed widget's state
-      this.saveState(currentActive, false);
+      // Save the closed widget's state — unless it is only lending its side out,
+      // in which case it has not been closed and should not be written down as
+      // closed. close() hands the side back when the borrower is done.
+      if (!this.persistent.has(currentActive)) {
+        this.saveState(currentActive, false);
+      }
     }
     
     this.setActive(side, widgetName);
@@ -233,6 +295,17 @@ class WidgetManager {
     
     // Fire event
     document.dispatchEvent(new CustomEvent('widget-closed', { detail: { widget: active, side } }));
+    
+    // Give the side back to its resident, if it has one and the reader has not
+    // put it away themselves. Guarded against the resident being the very thing
+    // just closed — otherwise closing the TOC would reopen it. (It cannot
+    // recurse either way: the side is already empty by this point, so the open()
+    // below finds nothing to displace.)
+    const resident = this.residentOf(side);
+    if (resident && resident !== active &&
+        this.wantsToBeOpen(resident) && this.hasContent(resident)) {
+      this.open(resident);
+    }
   }
   
   /**

package/package.json

@@ -2,7 +2,7 @@
   "name": "@kenjura/ursa",
   "author": "Andrew London <andrew@kenjura.com>",
   "type": "module",
-  "version": "0.90.1",
+  "version": "0.95.0",
   "description": "static site generator from MD/wikitext/YML",
   "main": "lib/index.js",
   "bin": {
@@ -51,6 +51,7 @@
     "yargs": "^17.7.2"
   },
   "devDependencies": {
+    "@tabler/icons": "^3.46.0",
     "jest": "^29.6.2",
     "node-static": "^0.7.11",
     "nodemon": "^2.0.15"

package/src/dev.js

@@ -372,6 +372,15 @@ async function renderDocument(urlPath) {
   }
   
   const { sourcePath, type } = resolved;
+
+  // `hidden: true` means the folder takes no part in the build. `generate`
+  // writes nothing for it, so serving it on demand would make `serve` and
+  // `generate` disagree — the page works all through development and 404s in
+  // production, the exact failure mode this is meant to prevent.
+  if (isFolderHidden(dirname(sourcePath), source)) {
+    return null;
+  }
+
   const ext = type;
   const base = basename(sourcePath, ext);
   const dir = addTrailingSlash(dirname(sourcePath)).replace(source, "");
@@ -428,7 +437,7 @@ async function renderDocument(urlPath) {
   }
 
   // Inject breadcrumbs before the H1
-  const breadcrumbs = generateBreadcrumbs(dir, base, fileMeta);
+  const breadcrumbs = generateBreadcrumbs(dir, base, fileMeta, source);
   if (breadcrumbs) {
     body = breadcrumbs + body;
   }
@@ -834,6 +843,26 @@ export async function dev({
   app.use(async (req, res, next) => {
     const url = req.url;
     
+    // Nothing under a folder that config.json marks `hidden: true` is served.
+    //
+    // This gate sits ahead of everything, including the `express.static`
+    // fallbacks mounted below — falling through with `next()` would just hand
+    // the file to them. `generate` writes no output for a hidden folder, so
+    // anything served here would work all through development and 404 in
+    // production, which is precisely what the setting exists to avoid.
+    let requestedSourcePath = null;
+    try {
+      requestedSourcePath = join(sourceDir, decodeURIComponent(url.split('?')[0]));
+    } catch (e) {
+      // Malformed percent-encoding — not a path we can classify; let it fall through
+    }
+    // Tested against the path itself, not its parent: `/foo/_art/` and
+    // `/foo/_art/index.html` must both be refused, and a file simply has no
+    // config.json of its own, so the ancestors decide either way.
+    if (requestedSourcePath && isFolderHidden(requestedSourcePath, sourceDir)) {
+      return res.status(404).send('<h1>404 Not Found</h1>');
+    }
+    
     // Handle search index requests
     if (url === '/public/search-index.json' || url === '/public/fulltext-index.json') {
       if (!devState.searchReady) {

package/src/helper/__test__/breadcrumbs.test.js

@@ -0,0 +1,71 @@
+import { join } from "path";
+import { mkdtemp, mkdir, writeFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import { generateBreadcrumbs } from "../breadcrumbs.js";
+import { clearConfigCache } from "../folderConfig.js";
+
+let source;
+beforeEach(async () => {
+  source = await mkdtemp(join(tmpdir(), "ursa-breadcrumbs-"));
+  clearConfigCache();
+});
+afterEach(async () => {
+  await rm(source, { recursive: true, force: true });
+  clearConfigCache();
+});
+
+describe("generateBreadcrumbs", () => {
+  it("names folder segments the way the menu does", async () => {
+    await mkdir(join(source, "campaigns", "bnw"), { recursive: true });
+    await writeFile(
+      join(source, "campaigns", "bnw", "index.md"),
+      "---\nmenu-label: 'BNW - Brave New World'\n---\n# Brave New World\n"
+    );
+
+    const html = generateBreadcrumbs("campaigns/bnw/", "quests", null, source);
+
+    expect(html).toContain(">BNW - Brave New World</a>");
+    expect(html).toContain('aria-current="page">Quests</span>');
+  });
+
+  it("falls back to config.json when a folder has no index", async () => {
+    await mkdir(join(source, "campaigns", "hfr"), { recursive: true });
+    await writeFile(
+      join(source, "campaigns", "hfr", "config.json"),
+      JSON.stringify({ label: "HFR - Hyacinth: Fury Road" })
+    );
+
+    const html = generateBreadcrumbs("campaigns/hfr/", "sessions", null, source);
+
+    expect(html).toContain(">HFR - Hyacinth: Fury Road</a>");
+  });
+
+  it("uses the folder label for the current crumb on a folder's index page", async () => {
+    await mkdir(join(source, "campaigns", "bnw"), { recursive: true });
+    await writeFile(
+      join(source, "campaigns", "bnw", "index.md"),
+      "---\nmenu-label: 'BNW - Brave New World'\n---\n# Brave New World\n"
+    );
+
+    const html = generateBreadcrumbs("campaigns/bnw/", "index", null, source);
+
+    expect(html).toContain('aria-current="page">BNW - Brave New World</span>');
+  });
+
+  it("keeps the document's own frontmatter override for the last crumb", () => {
+    const withMenuLabel = generateBreadcrumbs("guides/", "setup", {
+      "menu-label": "Getting Started",
+      title: "Setup Guide",
+    });
+    expect(withMenuLabel).toContain('aria-current="page">Getting Started</span>');
+
+    // menu-label absent: title still wins, as it always has
+    const withTitle = generateBreadcrumbs("guides/", "setup", { title: "Setup Guide" });
+    expect(withTitle).toContain('aria-current="page">Setup Guide</span>');
+  });
+
+  it("preserves interior capitalization without a source root", () => {
+    const html = generateBreadcrumbs("campaigns/SoL/", "index", null);
+    expect(html).toContain('aria-current="page">SoL</span>');
+  });
+});

package/src/helper/__test__/contentHash.test.js

@@ -0,0 +1,114 @@
+import { join } from "path";
+import { mkdtemp, rm, mkdir, writeFile, readFile } from "fs/promises";
+import { existsSync } from "fs";
+import { tmpdir } from "os";
+import {
+  enforceCacheVersion,
+  getUrsaDir,
+  loadHashCache,
+  saveHashCache,
+} from "../contentHash.js";
+
+let sourceDir;
+beforeEach(async () => {
+  sourceDir = await mkdtemp(join(tmpdir(), "ursa-cachestamp-"));
+});
+afterEach(async () => {
+  await rm(sourceDir, { recursive: true, force: true });
+});
+
+/** Write a populated `.ursa/` as an older build of ursa would have left it. */
+async function seedCache(stampVersion) {
+  const ursaDir = getUrsaDir(sourceDir);
+  await mkdir(ursaDir, { recursive: true });
+  await saveHashCache(sourceDir, new Map([["/site/a.md", "abc123"]]));
+  if (stampVersion !== null) {
+    await writeFile(
+      join(ursaDir, "cache-stamp.json"),
+      JSON.stringify({ ursaVersion: stampVersion })
+    );
+  }
+}
+
+describe("enforceCacheVersion", () => {
+  it("stamps a first build without reporting a reset", async () => {
+    const result = await enforceCacheVersion(sourceDir, "1.0.0");
+
+    expect(result).toEqual({ reset: false, previous: null, version: "1.0.0" });
+    const stamp = JSON.parse(
+      await readFile(join(getUrsaDir(sourceDir), "cache-stamp.json"), "utf8")
+    );
+    expect(stamp.ursaVersion).toBe("1.0.0");
+  });
+
+  it("keeps the cache when the stamp matches", async () => {
+    await seedCache("1.0.0");
+
+    const result = await enforceCacheVersion(sourceDir, "1.0.0");
+
+    expect(result.reset).toBe(false);
+    expect(await loadHashCache(sourceDir)).toEqual(
+      new Map([["/site/a.md", "abc123"]])
+    );
+  });
+
+  it("discards the cache when ursa has been upgraded", async () => {
+    await seedCache("1.0.0");
+
+    const result = await enforceCacheVersion(sourceDir, "1.1.0");
+
+    expect(result).toEqual({ reset: true, previous: "1.0.0", version: "1.1.0" });
+    expect(await loadHashCache(sourceDir)).toEqual(new Map());
+  });
+
+  it("discards the cache when ursa has been downgraded", async () => {
+    await seedCache("1.1.0");
+
+    const result = await enforceCacheVersion(sourceDir, "1.0.0");
+
+    expect(result.reset).toBe(true);
+    expect(await loadHashCache(sourceDir)).toEqual(new Map());
+  });
+
+  it("discards a cache left by a version that predates stamping", async () => {
+    await seedCache(null);
+
+    const result = await enforceCacheVersion(sourceDir, "1.0.0");
+
+    expect(result).toEqual({ reset: true, previous: null, version: "1.0.0" });
+    expect(await loadHashCache(sourceDir)).toEqual(new Map());
+  });
+
+  it("discards the cache when the stamp is unreadable", async () => {
+    await seedCache("1.0.0");
+    await writeFile(join(getUrsaDir(sourceDir), "cache-stamp.json"), "not json");
+
+    const result = await enforceCacheVersion(sourceDir, "1.0.0");
+
+    expect(result.reset).toBe(true);
+    expect(await loadHashCache(sourceDir)).toEqual(new Map());
+  });
+
+  it("leaves a stamp that the next run accepts", async () => {
+    await seedCache("1.0.0");
+
+    await enforceCacheVersion(sourceDir, "1.1.0");
+    await saveHashCache(sourceDir, new Map([["/site/a.md", "def456"]]));
+    const second = await enforceCacheVersion(sourceDir, "1.1.0");
+
+    expect(second.reset).toBe(false);
+    expect(await loadHashCache(sourceDir)).toEqual(
+      new Map([["/site/a.md", "def456"]])
+    );
+  });
+
+  it("removes every cache file in .ursa, not just the hashes", async () => {
+    await seedCache("1.0.0");
+    const navCache = join(getUrsaDir(sourceDir), "nav-cache.json");
+    await writeFile(navCache, JSON.stringify({ stale: true }));
+
+    await enforceCacheVersion(sourceDir, "1.1.0");
+
+    expect(existsSync(navCache)).toBe(false);
+  });
+});

package/src/helper/__test__/folderConfig.test.js

@@ -0,0 +1,89 @@
+import { join } from "path";
+import { mkdtemp, mkdir, writeFile, rm } from "fs/promises";
+import { tmpdir } from "os";
+import {
+  clearConfigCache,
+  isFolderHidden,
+  isFolderSelfHidden,
+} from "../folderConfig.js";
+
+let source;
+beforeEach(async () => {
+  source = await mkdtemp(join(tmpdir(), "ursa-folderconfig-"));
+  clearConfigCache();
+});
+afterEach(async () => {
+  await rm(source, { recursive: true, force: true });
+});
+
+async function hide(...segments) {
+  const dir = join(source, ...segments);
+  await mkdir(dir, { recursive: true });
+  await writeFile(join(dir, "config.json"), JSON.stringify({ hidden: true }));
+  return dir;
+}
+
+describe("isFolderHidden", () => {
+  it("matches the hidden folder itself", async () => {
+    const art = await hide("everdew", "_art");
+    expect(isFolderHidden(art, source)).toBe(true);
+  });
+
+  it("matches a descendant folder of a hidden folder", async () => {
+    await hide("everdew", "_art");
+    const nested = join(source, "everdew", "_art", "prompts", "people");
+    await mkdir(nested, { recursive: true });
+    expect(isFolderHidden(nested, source)).toBe(true);
+  });
+
+  it("matches file paths, not just directories", async () => {
+    // The build filters one list holding both files and directories through
+    // this predicate, so a file must resolve via its ancestors.
+    await hide("everdew", "_art");
+    expect(
+      isFolderHidden(join(source, "everdew", "_art", "prompts.md"), source)
+    ).toBe(true);
+    expect(
+      isFolderHidden(join(source, "everdew", "_art", "img", "map.png"), source)
+    ).toBe(true);
+  });
+
+  it("leaves siblings and ancestors of a hidden folder visible", async () => {
+    await hide("everdew", "_art");
+    await mkdir(join(source, "everdew", "people"), { recursive: true });
+    expect(isFolderHidden(join(source, "everdew", "people"), source)).toBe(false);
+    expect(isFolderHidden(join(source, "everdew"), source)).toBe(false);
+    expect(
+      isFolderHidden(join(source, "everdew", "people", "alice.md"), source)
+    ).toBe(false);
+  });
+
+  it("ignores a config.json that does not set hidden", async () => {
+    const dir = join(source, "everdew");
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, "config.json"), JSON.stringify({ label: "Everdew" }));
+    expect(isFolderHidden(dir, source)).toBe(false);
+  });
+
+  it("tolerates a trailing slash on the docroot", async () => {
+    const art = await hide("everdew", "_art");
+    expect(isFolderHidden(art, source + "/")).toBe(true);
+  });
+});
+
+describe("isFolderSelfHidden", () => {
+  it("is true only for the folder carrying the config, not its descendants", async () => {
+    const art = await hide("everdew", "_art");
+    const nested = join(art, "prompts");
+    await mkdir(nested, { recursive: true });
+
+    expect(isFolderSelfHidden(art)).toBe(true);
+    expect(isFolderSelfHidden(nested)).toBe(false);
+  });
+
+  it("is false for a folder with no config.json", async () => {
+    const dir = join(source, "people");
+    await mkdir(dir, { recursive: true });
+    expect(isFolderSelfHidden(dir)).toBe(false);
+  });
+});

package/src/helper/automenu.js

@@ -3,8 +3,15 @@ import { isHiddenOrSystemPath } from "./hiddenPaths.js";
 import { extname, basename, join, dirname } from "path";
 import { existsSync, readFileSync } from "fs";
 import { getFolderConfig, isFolderHidden, getRootConfig } from "./folderConfig.js";
-import { extractMetadata, isMetadataOnly } from "./metadataExtractor.js";
-import { stripHtml } from "./stripHtml.js";
+import { isMetadataOnly } from "./metadataExtractor.js";
+import {
+  INDEX_EXTENSIONS,
+  toDisplayName,
+  getMenuLabelFromFile,
+  getMenuSortAsFromFile,
+  getFolderLabel,
+  getFolderSortKey,
+} from "./menuLabels.js";
 
 // Icon extensions to check for custom icons
 const ICON_EXTENSIONS = ['.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico'];
@@ -14,93 +21,6 @@ const FOLDER_ICON = '📁';
 const DOCUMENT_ICON = '📄';
 const HOME_ICON = '🏠';
 
-// Index file extensions to check for folder links
-const INDEX_EXTENSIONS = ['.md', '.mdx', '.txt', '.yml', '.yaml'];
-
-// Convert filename to display name (e.g., "foo-bar" -> "Foo Bar")
-function toDisplayName(filename) {
-  return filename
-    .replace(/[-_]/g, ' ')  // Replace dashes and underscores with spaces
-    .replace(/\b\w/g, c => c.toUpperCase());  // Capitalize first letter of each word
-}
-
-/**
- * Get the menu label from a file's frontmatter
- * @param {string} filePath - Path to the markdown file
- * @returns {string|null} The menu-label value (with HTML stripped), or null if not found
- */
-function getMenuLabelFromFile(filePath) {
-  try {
-    if (!existsSync(filePath)) return null;
-    const content = readFileSync(filePath, 'utf8');
-    const metadata = extractMetadata(content);
-    if (metadata && metadata['menu-label']) {
-      return stripHtml(String(metadata['menu-label']));
-    }
-  } catch (e) {
-    // Ignore read errors
-  }
-  return null;
-}
-
-/**
- * Get the menu-sort-as value from a file's frontmatter
- * @param {string} filePath - Path to the markdown file
- * @returns {string|null} The menu-sort-as value (with HTML stripped), or null if not found
- */
-function getMenuSortAsFromFile(filePath) {
-  try {
-    if (!existsSync(filePath)) return null;
-    const content = readFileSync(filePath, 'utf8');
-    const metadata = extractMetadata(content);
-    if (metadata && metadata['menu-sort-as']) {
-      return stripHtml(String(metadata['menu-sort-as']));
-    }
-  } catch (e) {
-    // Ignore read errors
-  }
-  return null;
-}
-
-/**
- * Get the menu label for a folder from its index.md frontmatter
- * Falls back to config.json label (deprecated), then display name
- * @param {string} dirPath - Path to the folder
- * @param {object|null} folderConfig - The folder's config.json if any
- * @param {string} baseName - The folder's base name
- * @returns {string} The label to display
- */
-function getFolderLabel(dirPath, folderConfig, baseName) {
-  // First, check index.md for menu-label (preferred method)
-  for (const ext of INDEX_EXTENSIONS) {
-    const indexPath = join(dirPath, `index${ext}`);
-    const label = getMenuLabelFromFile(indexPath);
-    if (label) return label;
-  }
-  
-  // Fall back to config.json label (deprecated)
-  if (folderConfig?.label) {
-    return folderConfig.label;
-  }
-  
-  // Default to display name from folder name
-  return toDisplayName(baseName);
-}
-
-/**
- * Get the sort key for a folder from its index.md frontmatter
- * @param {string} dirPath - Path to the folder
- * @returns {string|null} The menu-sort-as value, or null if not found
- */
-function getFolderSortKey(dirPath) {
-  for (const ext of INDEX_EXTENSIONS) {
-    const indexPath = join(dirPath, `index${ext}`);
-    const sortKey = getMenuSortAsFromFile(indexPath);
-    if (sortKey) return sortKey;
-  }
-  return null;
-}
-
 /**
  * Check if a file is an index file
  * @param {string} baseName - The file's base name (without extension)
@@ -298,8 +218,10 @@ function buildMenuData(tree, source, validPaths, parentPath = '', includeDebug =
       }
     }
     
-    // Check if this folder is hidden via config.json
-    if (hasChildren && isFolderHidden(item.path, source)) {
+    // Check if this folder is hidden via config.json.
+    // Not gated on hasChildren: a hidden folder is ignored whether or not the
+    // tree walker found children under it.
+    if (isFolderHidden(item.path, source)) {
       continue; // Skip hidden folders
     }