@mokup/shared 1.0.2 → 1.1.1

package/dist/chokidar.cjs

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 const chokidar = require('chokidar');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
@@ -10,14 +8,4 @@ const chokidar__default = /*#__PURE__*/_interopDefaultCompat(chokidar);
 
 
 
-exports.default = chokidar__default;
-Object.prototype.hasOwnProperty.call(chokidar, '__proto__') &&
-	!Object.prototype.hasOwnProperty.call(exports, '__proto__') &&
-	Object.defineProperty(exports, '__proto__', {
-		enumerable: true,
-		value: chokidar['__proto__']
-	});
-
-Object.keys(chokidar).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) exports[k] = chokidar[k];
-});
+module.exports = chokidar__default;

package/dist/chokidar.mjs

@@ -1,2 +1 @@
-export * from 'chokidar';
 export { default } from 'chokidar';

package/dist/index.d.cts

@@ -81,6 +81,12 @@ type PlaygroundOptionsInput = boolean | {
      * @default "/__mokup"
      */
     path?: string;
+    /**
+     * Emit playground assets during production builds.
+     *
+     * @default false
+     */
+    build?: boolean;
     /**
      * Enable or disable the playground routes.
      *

package/dist/index.d.mts

@@ -81,6 +81,12 @@ type PlaygroundOptionsInput = boolean | {
      * @default "/__mokup"
      */
     path?: string;
+    /**
+     * Emit playground assets during production builds.
+     *
+     * @default false
+     */
+    build?: boolean;
     /**
      * Enable or disable the playground routes.
      *

package/dist/index.d.ts

@@ -81,6 +81,12 @@ type PlaygroundOptionsInput = boolean | {
      * @default "/__mokup"
      */
     path?: string;
+    /**
+     * Emit playground assets during production builds.
+     *
+     * @default false
+     */
+    build?: boolean;
     /**
      * Enable or disable the playground routes.
      *

package/dist/path-utils.cjs

@@ -0,0 +1,57 @@
+'use strict';
+
+const node_process = require('node:process');
+const pathe = require('pathe');
+
+function isWindowsLikePath(normalized) {
+  return node_process.platform === "win32" || /^[a-z]:\//i.test(normalized) || normalized.startsWith("//");
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizePath(value) {
+  return pathe.normalize(toPosix(value));
+}
+function normalizePathForComparison(value) {
+  const normalized = normalizePath(value);
+  return isWindowsLikePath(normalized) ? normalized.toLowerCase() : normalized;
+}
+function isInDirs(file, dirs) {
+  const normalized = normalizePathForComparison(file);
+  return dirs.some((dir) => {
+    const normalizedDir = normalizePathForComparison(dir).replace(/\/$/, "");
+    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
+  });
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = normalizePathForComparison(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+function hasIgnoredPrefix(file, rootDir, prefixes) {
+  if (prefixes.length === 0) {
+    return false;
+  }
+  const normalizedRoot = normalizePathForComparison(rootDir);
+  const normalizedFile = normalizePathForComparison(file);
+  const relativePath = toPosix(pathe.relative(normalizedRoot, normalizedFile));
+  const segments = relativePath.split("/");
+  return segments.some(
+    (segment) => prefixes.some((prefix) => segment.startsWith(prefix))
+  );
+}
+
+exports.hasIgnoredPrefix = hasIgnoredPrefix;
+exports.isInDirs = isInDirs;
+exports.matchesFilter = matchesFilter;
+exports.normalizePathForComparison = normalizePathForComparison;
+exports.toPosix = toPosix;

package/dist/path-utils.d.cts

@@ -0,0 +1,7 @@
+declare function toPosix(value: string): string;
+declare function normalizePathForComparison(value: string): string;
+declare function isInDirs(file: string, dirs: string[]): boolean;
+declare function matchesFilter(file: string, include?: RegExp | RegExp[], exclude?: RegExp | RegExp[]): boolean;
+declare function hasIgnoredPrefix(file: string, rootDir: string, prefixes: string[]): boolean;
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/path-utils.d.mts

@@ -0,0 +1,7 @@
+declare function toPosix(value: string): string;
+declare function normalizePathForComparison(value: string): string;
+declare function isInDirs(file: string, dirs: string[]): boolean;
+declare function matchesFilter(file: string, include?: RegExp | RegExp[], exclude?: RegExp | RegExp[]): boolean;
+declare function hasIgnoredPrefix(file: string, rootDir: string, prefixes: string[]): boolean;
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/path-utils.d.ts

@@ -0,0 +1,7 @@
+declare function toPosix(value: string): string;
+declare function normalizePathForComparison(value: string): string;
+declare function isInDirs(file: string, dirs: string[]): boolean;
+declare function matchesFilter(file: string, include?: RegExp | RegExp[], exclude?: RegExp | RegExp[]): boolean;
+declare function hasIgnoredPrefix(file: string, rootDir: string, prefixes: string[]): boolean;
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/path-utils.mjs

@@ -0,0 +1,51 @@
+import { platform } from 'node:process';
+import { relative, normalize } from 'pathe';
+
+function isWindowsLikePath(normalized) {
+  return platform === "win32" || /^[a-z]:\//i.test(normalized) || normalized.startsWith("//");
+}
+function toPosix(value) {
+  return value.replace(/\\/g, "/");
+}
+function normalizePath(value) {
+  return normalize(toPosix(value));
+}
+function normalizePathForComparison(value) {
+  const normalized = normalizePath(value);
+  return isWindowsLikePath(normalized) ? normalized.toLowerCase() : normalized;
+}
+function isInDirs(file, dirs) {
+  const normalized = normalizePathForComparison(file);
+  return dirs.some((dir) => {
+    const normalizedDir = normalizePathForComparison(dir).replace(/\/$/, "");
+    return normalized === normalizedDir || normalized.startsWith(`${normalizedDir}/`);
+  });
+}
+function testPatterns(patterns, value) {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  return list.some((pattern) => pattern.test(value));
+}
+function matchesFilter(file, include, exclude) {
+  const normalized = normalizePathForComparison(file);
+  if (exclude && testPatterns(exclude, normalized)) {
+    return false;
+  }
+  if (include) {
+    return testPatterns(include, normalized);
+  }
+  return true;
+}
+function hasIgnoredPrefix(file, rootDir, prefixes) {
+  if (prefixes.length === 0) {
+    return false;
+  }
+  const normalizedRoot = normalizePathForComparison(rootDir);
+  const normalizedFile = normalizePathForComparison(file);
+  const relativePath = toPosix(relative(normalizedRoot, normalizedFile));
+  const segments = relativePath.split("/");
+  return segments.some(
+    (segment) => prefixes.some((prefix) => segment.startsWith(prefix))
+  );
+}
+
+export { hasIgnoredPrefix, isInDirs, matchesFilter, normalizePathForComparison, toPosix };

package/dist/playground-grouping.cjs

@@ -0,0 +1,95 @@
+'use strict';
+
+const node_process = require('node:process');
+const pathe = require('pathe');
+const pathUtils = require('./path-utils.cjs');
+
+function normalizePath(value) {
+  return pathe.normalize(pathUtils.toPosix(value));
+}
+function isAncestor(parent, child) {
+  const normalizedParent = pathUtils.normalizePathForComparison(parent).replace(/\/$/, "");
+  const normalizedChild = pathUtils.normalizePathForComparison(child);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}/`);
+}
+function resolveGroupRoot(dirs, serverRoot) {
+  if (!dirs || dirs.length === 0) {
+    return serverRoot ?? node_process.cwd();
+  }
+  if (serverRoot) {
+    const normalizedRoot = normalizePath(serverRoot);
+    const canUseRoot = dirs.every((dir) => isAncestor(normalizedRoot, dir));
+    if (canUseRoot) {
+      return normalizedRoot;
+    }
+  }
+  if (dirs.length === 1) {
+    return normalizePath(pathe.dirname(dirs[0]));
+  }
+  let common = normalizePath(dirs[0]);
+  for (const dir of dirs.slice(1)) {
+    const normalizedDir = normalizePath(dir);
+    while (common && !isAncestor(common, normalizedDir)) {
+      const parent = normalizePath(pathe.dirname(common));
+      if (parent === common) {
+        break;
+      }
+      common = parent;
+    }
+  }
+  if (!common || common === "/") {
+    return serverRoot ?? node_process.cwd();
+  }
+  return common;
+}
+function resolveGroups(dirs, root) {
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    const normalized = normalizePath(dir);
+    const compareKey = pathUtils.normalizePathForComparison(dir);
+    if (seen.has(compareKey)) {
+      continue;
+    }
+    seen.add(compareKey);
+    const rel = pathUtils.toPosix(pathe.relative(root, normalized));
+    const label = rel && !rel.startsWith("..") ? rel : normalized;
+    groups.push({
+      key: normalized,
+      label,
+      path: normalized
+    });
+  }
+  return groups;
+}
+function resolveRouteGroup(routeFile, groups) {
+  if (groups.length === 0) {
+    return void 0;
+  }
+  const normalizedFile = pathUtils.normalizePathForComparison(routeFile);
+  let matched;
+  for (const group of groups) {
+    const normalizedGroup = pathUtils.normalizePathForComparison(group.path);
+    if (normalizedFile === normalizedGroup || normalizedFile.startsWith(`${normalizedGroup}/`)) {
+      if (!matched || group.path.length > matched.path.length) {
+        matched = group;
+      }
+    }
+  }
+  return matched;
+}
+function formatRouteFile(file, root) {
+  if (!root) {
+    return pathUtils.toPosix(file);
+  }
+  const rel = pathUtils.toPosix(pathe.relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return pathUtils.toPosix(file);
+  }
+  return rel;
+}
+
+exports.formatRouteFile = formatRouteFile;
+exports.resolveGroupRoot = resolveGroupRoot;
+exports.resolveGroups = resolveGroups;
+exports.resolveRouteGroup = resolveRouteGroup;

package/dist/playground-grouping.d.cts

@@ -0,0 +1,12 @@
+interface PlaygroundGroup {
+    key: string;
+    label: string;
+    path: string;
+}
+declare function resolveGroupRoot(dirs: string[], serverRoot?: string): string;
+declare function resolveGroups(dirs: string[], root: string): PlaygroundGroup[];
+declare function resolveRouteGroup(routeFile: string, groups: PlaygroundGroup[]): PlaygroundGroup | undefined;
+declare function formatRouteFile(file: string, root?: string): string;
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };
+export type { PlaygroundGroup };

package/dist/playground-grouping.d.mts

@@ -0,0 +1,12 @@
+interface PlaygroundGroup {
+    key: string;
+    label: string;
+    path: string;
+}
+declare function resolveGroupRoot(dirs: string[], serverRoot?: string): string;
+declare function resolveGroups(dirs: string[], root: string): PlaygroundGroup[];
+declare function resolveRouteGroup(routeFile: string, groups: PlaygroundGroup[]): PlaygroundGroup | undefined;
+declare function formatRouteFile(file: string, root?: string): string;
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };
+export type { PlaygroundGroup };

package/dist/playground-grouping.d.ts

@@ -0,0 +1,12 @@
+interface PlaygroundGroup {
+    key: string;
+    label: string;
+    path: string;
+}
+declare function resolveGroupRoot(dirs: string[], serverRoot?: string): string;
+declare function resolveGroups(dirs: string[], root: string): PlaygroundGroup[];
+declare function resolveRouteGroup(routeFile: string, groups: PlaygroundGroup[]): PlaygroundGroup | undefined;
+declare function formatRouteFile(file: string, root?: string): string;
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };
+export type { PlaygroundGroup };

package/dist/playground-grouping.mjs

@@ -0,0 +1,90 @@
+import { cwd } from 'node:process';
+import { relative, dirname, normalize } from 'pathe';
+import { toPosix, normalizePathForComparison } from './path-utils.mjs';
+
+function normalizePath(value) {
+  return normalize(toPosix(value));
+}
+function isAncestor(parent, child) {
+  const normalizedParent = normalizePathForComparison(parent).replace(/\/$/, "");
+  const normalizedChild = normalizePathForComparison(child);
+  return normalizedChild === normalizedParent || normalizedChild.startsWith(`${normalizedParent}/`);
+}
+function resolveGroupRoot(dirs, serverRoot) {
+  if (!dirs || dirs.length === 0) {
+    return serverRoot ?? cwd();
+  }
+  if (serverRoot) {
+    const normalizedRoot = normalizePath(serverRoot);
+    const canUseRoot = dirs.every((dir) => isAncestor(normalizedRoot, dir));
+    if (canUseRoot) {
+      return normalizedRoot;
+    }
+  }
+  if (dirs.length === 1) {
+    return normalizePath(dirname(dirs[0]));
+  }
+  let common = normalizePath(dirs[0]);
+  for (const dir of dirs.slice(1)) {
+    const normalizedDir = normalizePath(dir);
+    while (common && !isAncestor(common, normalizedDir)) {
+      const parent = normalizePath(dirname(common));
+      if (parent === common) {
+        break;
+      }
+      common = parent;
+    }
+  }
+  if (!common || common === "/") {
+    return serverRoot ?? cwd();
+  }
+  return common;
+}
+function resolveGroups(dirs, root) {
+  const groups = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const dir of dirs) {
+    const normalized = normalizePath(dir);
+    const compareKey = normalizePathForComparison(dir);
+    if (seen.has(compareKey)) {
+      continue;
+    }
+    seen.add(compareKey);
+    const rel = toPosix(relative(root, normalized));
+    const label = rel && !rel.startsWith("..") ? rel : normalized;
+    groups.push({
+      key: normalized,
+      label,
+      path: normalized
+    });
+  }
+  return groups;
+}
+function resolveRouteGroup(routeFile, groups) {
+  if (groups.length === 0) {
+    return void 0;
+  }
+  const normalizedFile = normalizePathForComparison(routeFile);
+  let matched;
+  for (const group of groups) {
+    const normalizedGroup = normalizePathForComparison(group.path);
+    if (normalizedFile === normalizedGroup || normalizedFile.startsWith(`${normalizedGroup}/`)) {
+      if (!matched || group.path.length > matched.path.length) {
+        matched = group;
+      }
+    }
+  }
+  return matched;
+}
+function formatRouteFile(file, root) {
+  if (!root) {
+    return toPosix(file);
+  }
+  const rel = toPosix(relative(root, file));
+  if (!rel || rel.startsWith("..")) {
+    return toPosix(file);
+  }
+  return rel;
+}
+
+export { formatRouteFile, resolveGroupRoot, resolveGroups, resolveRouteGroup };

package/dist/timing.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+function createDebouncer(delayMs, fn) {
+  let timer = null;
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      fn();
+    }, delayMs);
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+exports.createDebouncer = createDebouncer;
+exports.delay = delay;

package/dist/timing.d.cts

@@ -0,0 +1,4 @@
+declare function createDebouncer(delayMs: number, fn: () => void): () => void;
+declare function delay(ms: number): Promise<void>;
+
+export { createDebouncer, delay };

package/dist/timing.d.mts

@@ -0,0 +1,4 @@
+declare function createDebouncer(delayMs: number, fn: () => void): () => void;
+declare function delay(ms: number): Promise<void>;
+
+export { createDebouncer, delay };

package/dist/timing.d.ts

@@ -0,0 +1,4 @@
+declare function createDebouncer(delayMs: number, fn: () => void): () => void;
+declare function delay(ms: number): Promise<void>;
+
+export { createDebouncer, delay };

package/dist/timing.mjs

@@ -0,0 +1,17 @@
+function createDebouncer(delayMs, fn) {
+  let timer = null;
+  return () => {
+    if (timer) {
+      clearTimeout(timer);
+    }
+    timer = setTimeout(() => {
+      timer = null;
+      fn();
+    }, delayMs);
+  };
+}
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export { createDebouncer, delay };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mokup/shared",
   "type": "module",
-  "version": "1.0.2",
+  "version": "1.1.1",
   "description": "Shared dependency exports for mokup.",
   "license": "MIT",
   "homepage": "https://mokup.icebreaker.top",
@@ -43,6 +43,21 @@
       "import": "./dist/pathe.mjs",
       "require": "./dist/pathe.cjs"
     },
+    "./path-utils": {
+      "types": "./dist/path-utils.d.ts",
+      "import": "./dist/path-utils.mjs",
+      "require": "./dist/path-utils.cjs"
+    },
+    "./playground-grouping": {
+      "types": "./dist/playground-grouping.d.ts",
+      "import": "./dist/playground-grouping.mjs",
+      "require": "./dist/playground-grouping.cjs"
+    },
+    "./timing": {
+      "types": "./dist/timing.d.ts",
+      "import": "./dist/timing.mjs",
+      "require": "./dist/timing.cjs"
+    },
     "./jsonc-parser": {
       "types": "./dist/jsonc-parser.d.ts",
       "import": "./dist/jsonc-parser.mjs",