@maizzle/framework 6.1.1 → 6.1.3

package/dist/utils/watchPaths.d.ts

@@ -4,8 +4,35 @@
  * chokidar matches any of the given globs. Patterns are interpreted as
  * project-relative; a leading `./` is stripped so user-supplied globs like
  * `./locales/**` behave identically to `locales/**`.
+ *
+ * Negated patterns (`!…`) are excludes: a file matches when it matches an
+ * include pattern and no exclude pattern. They must not reach `matchesGlob`
+ * as-is — it treats a lone negated pattern as "everything except", which
+ * under `some()` would make the predicate true for almost every file.
  */
 declare function createWatchedFileMatcher(patterns: string[], cwd: string): (file: string) => boolean;
+/**
+ * Derive the directories the dev server watcher must cover explicitly now
+ * that its Vite root is the dev UI directory, not the project cwd: the
+ * static prefixes of the content globs, component source dirs, the Maizzle
+ * root, and the static prefixes of the watch globs. Directories, not globs —
+ * the dev server runs with Vite's default `disableGlobbing`, so globs passed
+ * to `watcher.add` are treated literally.
+ *
+ * Negated patterns are excludes and produce no watch root. A watch pattern
+ * with no static prefix (a bare `*.json`, or a glob starting with `**`)
+ * deliberately falls back to `cwd`:
+ * it asks for project-wide matching, and only a project-wide watch can honor
+ * it. Content patterns cannot hit that fallback — they arrive from
+ * `resolveConfig` already resolved against the (absolute) root.
+ */
+declare function deriveWatchRoots(options: {
+  content: string[];
+  componentDirs: string[];
+  root?: string;
+  watchPaths: string[];
+  cwd: string;
+}): string[];
 //#endregion
-export { createWatchedFileMatcher };
+export { createWatchedFileMatcher, deriveWatchRoots };
 //# sourceMappingURL=watchPaths.d.ts.map

package/dist/utils/watchPaths.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"watchPaths.d.ts","names":[],"sources":["../../src/utils/watchPaths.ts"],"mappings":";;;;;;;iBAQgB,yBAAyB,oBAAoB,eAEnD"}
+{"version":3,"file":"watchPaths.d.ts","names":[],"sources":["../../src/utils/watchPaths.ts"],"mappings":";;;;;;;;;;;;iBAagB,yBAAyB,oBAAoB,eAInD;;;;;;;;;;;;;;;;iBAqBM,iBAAiB;EAC/B;EACA;EACA;EACA;EACA"}

package/dist/utils/watchPaths.js

@@ -5,15 +5,50 @@ import { matchesGlob, relative } from "pathe";
 * chokidar matches any of the given globs. Patterns are interpreted as
 * project-relative; a leading `./` is stripped so user-supplied globs like
 * `./locales/**` behave identically to `locales/**`.
+*
+* Negated patterns (`!…`) are excludes: a file matches when it matches an
+* include pattern and no exclude pattern. They must not reach `matchesGlob`
+* as-is — it treats a lone negated pattern as "everything except", which
+* under `some()` would make the predicate true for almost every file.
 */
 function createWatchedFileMatcher(patterns, cwd) {
-	const normalized = patterns.map((p) => p.replace(/^\.\//, ""));
+	const stripDotSlash = (p) => p.replace(/^\.\//, "");
+	const includes = patterns.filter((p) => !p.startsWith("!")).map(stripDotSlash);
+	const excludes = patterns.filter((p) => p.startsWith("!")).map((p) => stripDotSlash(p.slice(1)));
 	return (file) => {
 		const rel = relative(cwd, file);
-		return normalized.some((p) => matchesGlob(rel, p));
+		return includes.some((p) => matchesGlob(rel, p)) && !excludes.some((p) => matchesGlob(rel, p));
 	};
 }
+/**
+* Derive the directories the dev server watcher must cover explicitly now
+* that its Vite root is the dev UI directory, not the project cwd: the
+* static prefixes of the content globs, component source dirs, the Maizzle
+* root, and the static prefixes of the watch globs. Directories, not globs —
+* the dev server runs with Vite's default `disableGlobbing`, so globs passed
+* to `watcher.add` are treated literally.
+*
+* Negated patterns are excludes and produce no watch root. A watch pattern
+* with no static prefix (a bare `*.json`, or a glob starting with `**`)
+* deliberately falls back to `cwd`:
+* it asks for project-wide matching, and only a project-wide watch can honor
+* it. Content patterns cannot hit that fallback — they arrive from
+* `resolveConfig` already resolved against the (absolute) root.
+*/
+function deriveWatchRoots(options) {
+	const { content, componentDirs, root, watchPaths, cwd } = options;
+	const globFreePrefix = (pattern) => {
+		const prefix = pattern.split(/[*?{[]|[+@!]\(/)[0];
+		return prefix.endsWith("/") ? prefix.slice(0, -1) : prefix;
+	};
+	return [...new Set([
+		...content.filter((p) => !p.startsWith("!")).map(globFreePrefix),
+		...componentDirs,
+		...root ? [root] : [],
+		...watchPaths.filter((p) => !p.startsWith("!")).map((p) => globFreePrefix(p) || cwd)
+	].filter(Boolean))];
+}
 //#endregion
-export { createWatchedFileMatcher };
+export { createWatchedFileMatcher, deriveWatchRoots };
 
 //# sourceMappingURL=watchPaths.js.map

package/dist/utils/watchPaths.js.map

@@ -1 +1 @@
-{"version":3,"file":"watchPaths.js","names":[],"sources":["../../src/utils/watchPaths.ts"],"sourcesContent":["import { matchesGlob, relative } from 'pathe'\n\n/**\n * Build a predicate that tells whether an absolute file path emitted by\n * chokidar matches any of the given globs. Patterns are interpreted as\n * project-relative; a leading `./` is stripped so user-supplied globs like\n * `./locales/**` behave identically to `locales/**`.\n */\nexport function createWatchedFileMatcher(patterns: string[], cwd: string) {\n  const normalized = patterns.map(p => p.replace(/^\\.\\//, ''))\n  return (file: string) => {\n    const rel = relative(cwd, file)\n    return normalized.some(p => matchesGlob(rel, p))\n  }\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,yBAAyB,UAAoB,KAAa;CACxE,MAAM,aAAa,SAAS,KAAI,MAAK,EAAE,QAAQ,SAAS,EAAE,CAAC;CAC3D,QAAQ,SAAiB;EACvB,MAAM,MAAM,SAAS,KAAK,IAAI;EAC9B,OAAO,WAAW,MAAK,MAAK,YAAY,KAAK,CAAC,CAAC;CACjD;AACF"}
+{"version":3,"file":"watchPaths.js","names":[],"sources":["../../src/utils/watchPaths.ts"],"sourcesContent":["import { matchesGlob, relative } from 'pathe'\n\n/**\n * Build a predicate that tells whether an absolute file path emitted by\n * chokidar matches any of the given globs. Patterns are interpreted as\n * project-relative; a leading `./` is stripped so user-supplied globs like\n * `./locales/**` behave identically to `locales/**`.\n *\n * Negated patterns (`!…`) are excludes: a file matches when it matches an\n * include pattern and no exclude pattern. They must not reach `matchesGlob`\n * as-is — it treats a lone negated pattern as \"everything except\", which\n * under `some()` would make the predicate true for almost every file.\n */\nexport function createWatchedFileMatcher(patterns: string[], cwd: string) {\n  const stripDotSlash = (p: string) => p.replace(/^\\.\\//, '')\n  const includes = patterns.filter(p => !p.startsWith('!')).map(stripDotSlash)\n  const excludes = patterns.filter(p => p.startsWith('!')).map(p => stripDotSlash(p.slice(1)))\n  return (file: string) => {\n    const rel = relative(cwd, file)\n    return includes.some(p => matchesGlob(rel, p)) && !excludes.some(p => matchesGlob(rel, p))\n  }\n}\n\n/**\n * Derive the directories the dev server watcher must cover explicitly now\n * that its Vite root is the dev UI directory, not the project cwd: the\n * static prefixes of the content globs, component source dirs, the Maizzle\n * root, and the static prefixes of the watch globs. Directories, not globs —\n * the dev server runs with Vite's default `disableGlobbing`, so globs passed\n * to `watcher.add` are treated literally.\n *\n * Negated patterns are excludes and produce no watch root. A watch pattern\n * with no static prefix (a bare `*.json`, or a glob starting with `**`)\n * deliberately falls back to `cwd`:\n * it asks for project-wide matching, and only a project-wide watch can honor\n * it. Content patterns cannot hit that fallback — they arrive from\n * `resolveConfig` already resolved against the (absolute) root.\n */\nexport function deriveWatchRoots(options: {\n  content: string[]\n  componentDirs: string[]\n  root?: string\n  watchPaths: string[]\n  cwd: string\n}): string[] {\n  const { content, componentDirs, root, watchPaths, cwd } = options\n\n  // Stop at any glob syntax across both glob backends in use — pathe's\n  // matchesGlob for the watched-file matcher (wildcards, ?, braces, bracket\n  // classes) and tinyglobby/picomatch for template listing (additionally\n  // extglobs: +(…), @(…), !(…), matched as two-char openers so bare\n  // parentheses in directory names stay literal). Splitting too late would\n  // leave a literal never-existing path as the root and silently lose\n  // coverage; splitting too early merely watches the parent directory,\n  // which still covers the target — so err on the side of splitting.\n  const globFreePrefix = (pattern: string) => {\n    const prefix = pattern.split(/[*?{[]|[+@!]\\(/)[0]\n    return prefix.endsWith('/') ? prefix.slice(0, -1) : prefix\n  }\n\n  return [...new Set([\n    ...content.filter(p => !p.startsWith('!')).map(globFreePrefix),\n    ...componentDirs,\n    ...(root ? [root] : []),\n    ...watchPaths.filter(p => !p.startsWith('!')).map(p => globFreePrefix(p) || cwd),\n  ].filter(Boolean))]\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,yBAAyB,UAAoB,KAAa;CACxE,MAAM,iBAAiB,MAAc,EAAE,QAAQ,SAAS,EAAE;CAC1D,MAAM,WAAW,SAAS,QAAO,MAAK,CAAC,EAAE,WAAW,GAAG,CAAC,CAAC,CAAC,IAAI,aAAa;CAC3E,MAAM,WAAW,SAAS,QAAO,MAAK,EAAE,WAAW,GAAG,CAAC,CAAC,CAAC,KAAI,MAAK,cAAc,EAAE,MAAM,CAAC,CAAC,CAAC;CAC3F,QAAQ,SAAiB;EACvB,MAAM,MAAM,SAAS,KAAK,IAAI;EAC9B,OAAO,SAAS,MAAK,MAAK,YAAY,KAAK,CAAC,CAAC,KAAK,CAAC,SAAS,MAAK,MAAK,YAAY,KAAK,CAAC,CAAC;CAC3F;AACF;;;;;;;;;;;;;;;;AAiBA,SAAgB,iBAAiB,SAMpB;CACX,MAAM,EAAE,SAAS,eAAe,MAAM,YAAY,QAAQ;CAU1D,MAAM,kBAAkB,YAAoB;EAC1C,MAAM,SAAS,QAAQ,MAAM,gBAAgB,CAAC,CAAC;EAC/C,OAAO,OAAO,SAAS,GAAG,IAAI,OAAO,MAAM,GAAG,EAAE,IAAI;CACtD;CAEA,OAAO,CAAC,GAAG,IAAI,IAAI;EACjB,GAAG,QAAQ,QAAO,MAAK,CAAC,EAAE,WAAW,GAAG,CAAC,CAAC,CAAC,IAAI,cAAc;EAC7D,GAAG;EACH,GAAI,OAAO,CAAC,IAAI,IAAI,CAAC;EACrB,GAAG,WAAW,QAAO,MAAK,CAAC,EAAE,WAAW,GAAG,CAAC,CAAC,CAAC,KAAI,MAAK,eAAe,CAAC,KAAK,GAAG;CACjF,CAAC,CAAC,OAAO,OAAO,CAAC,CAAC;AACpB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maizzle/framework",
-  "version": "6.1.1",
+  "version": "6.1.3",
   "description": "Maizzle is a framework that helps you quickly build HTML emails with Tailwind CSS.",
   "license": "MIT",
   "type": "module",
@@ -58,11 +58,11 @@
     "markdown-exit": "^1.1.0-beta.2",
     "nodemailer": "^9.0.0",
     "ora": "^9.3.0",
-    "oxfmt": "^0.64.0",
+    "oxfmt": "^0.65.0",
     "pathe": "^2.0.3",
     "postcss": "^8.5.6",
     "postcss-calc": "^10.1.1",
-    "postcss-merge-longhand": "^8.0.0",
+    "postcss-merge-longhand": "^9.0.1",
     "postcss-safe-parser": "^7.0.1",
     "postcss-sort-media-queries": "^6.5.0",
     "postcss-value-parser": "^4.2.0",