@cdklabs/cdk-construct-connect-datalake 0.0.12 → 0.0.14

package/node_modules/watchpack/lib/index.js

@@ -5,9 +5,9 @@
 "use strict";
 
 const { EventEmitter } = require("events");
-const globToRegExp = require("glob-to-regexp");
 const LinkResolver = require("./LinkResolver");
 const getWatcherManager = require("./getWatcherManager");
+const globToRegExp = require("./util/globToRegExp");
 const watchEventSource = require("./watchEventSource");
 
 /** @typedef {import("./getWatcherManager").WatcherManager} WatcherManager */
@@ -45,8 +45,9 @@ const watchEventSource = require("./watchEventSource");
 /** @typedef {`scan (${string})` | "change" | "rename" | `watch ${string}` | `directory-removed ${string}`} EventType */
 /** @typedef {{ safeTime: number, timestamp: number, accuracy: number }} Entry */
 /** @typedef {{ safeTime: number }} OnlySafeTimeEntry */
+
 // eslint-disable-next-line jsdoc/ts-no-empty-object-type
-/** @typedef {{}} ExistenceOnlyTimeEntry */
+/** @typedef {{  }} ExistenceOnlyTimeEntry */
 /** @typedef {Map<string, Entry | OnlySafeTimeEntry | ExistenceOnlyTimeEntry | null>} TimeInfoEntries */
 /** @typedef {Set<string>} Changes */
 /** @typedef {Set<string>} Removals */
@@ -60,10 +61,8 @@ const watchEventSource = require("./watchEventSource");
  */
 function addWatchersToSet(watchers, set) {
 	for (const ww of watchers) {
-		const w = ww.watcher;
-		if (!set.has(w.directoryWatcher)) {
-			set.add(w.directoryWatcher);
-		}
+		// Set.add is already idempotent, so skip the redundant has() probe.
+		set.add(ww.watcher.directoryWatcher);
 	}
 }
 
@@ -75,31 +74,47 @@ const stringToRegexp = (ignored) => {
 	if (ignored.length === 0) {
 		return;
 	}
-	const { source } = globToRegExp(ignored, { globstar: true, extended: true });
-	return `${source.slice(0, -1)}(?:$|\\/)`;
+	return `^${globToRegExp(ignored)}(?:$|\\/)`;
 };
 
+/**
+ * Normalizes path separators for regex testing. `String.prototype.replace`
+ * always allocates a new string, even when the pattern finds nothing; for
+ * POSIX paths (the common case) that allocation is pure overhead. Check for
+ * a backslash with `indexOf` first so we skip the copy on paths that are
+ * already normalized.
+ * @param {string} item item
+ * @returns {string} item with backslashes normalized to forward slashes
+ */
+const normalizeSeparators = (item) =>
+	item.includes("\\") ? item.replace(/\\/g, "/") : item;
+
 /**
  * @param {Ignored=} ignored ignored
  * @returns {(item: string) => boolean} ignored to function
  */
 const ignoredToFunction = (ignored) => {
 	if (Array.isArray(ignored)) {
-		const stringRegexps = ignored.map((i) => stringToRegexp(i)).filter(Boolean);
+		const stringRegexps =
+			/** @type {string[]} */
+			(ignored.map((i) => stringToRegexp(i)).filter(Boolean));
 		if (stringRegexps.length === 0) {
 			return () => false;
 		}
-		const regexp = new RegExp(stringRegexps.join("|"));
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		const regexp =
+			stringRegexps.length === 1
+				? new RegExp(stringRegexps[0])
+				: new RegExp(stringRegexps.join("|"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (typeof ignored === "string") {
 		const stringRegexp = stringToRegexp(ignored);
 		if (!stringRegexp) {
 			return () => false;
 		}
 		const regexp = new RegExp(stringRegexp);
-		return (item) => regexp.test(item.replace(/\\/g, "/"));
+		return (item) => regexp.test(normalizeSeparators(item));
 	} else if (ignored instanceof RegExp) {
-		return (item) => ignored.test(item.replace(/\\/g, "/"));
+		return (item) => ignored.test(normalizeSeparators(item));
 	} else if (typeof ignored === "function") {
 		return ignored;
 	} else if (ignored) {
@@ -463,8 +478,10 @@ class Watchpack extends EventEmitter {
 		/** @type {Record<string, number>} */
 		const obj = Object.create(null);
 		for (const w of directoryWatchers) {
+			// getTimes() returns a prototype-less object, so for...in is safe
+			// and avoids the throwaway array that Object.keys would allocate.
 			const times = w.getTimes();
-			for (const file of Object.keys(times)) obj[file] = times[file];
+			for (const file in times) obj[file] = times[file];
 		}
 		return obj;
 	}
@@ -551,4 +568,27 @@ class Watchpack extends EventEmitter {
 	}
 }
 
-module.exports = Watchpack;
+/**
+ * @template A
+ * @template B
+ * @param {A} obj input a
+ * @param {B} exports input b
+ * @returns {A & B} merged
+ */
+const mergeExports = (obj, exports) => {
+	const descriptors = Object.getOwnPropertyDescriptors(exports);
+	Object.defineProperties(obj, descriptors);
+	return /** @type {A & B} */ (Object.freeze(obj));
+};
+
+/** @typedef {typeof Watchpack & { util: { readonly globToRegExp: typeof globToRegExp } }} WatchpackExports */
+
+module.exports = /** @type {WatchpackExports} */ (
+	mergeExports(Watchpack, {
+		util: {
+			get globToRegExp() {
+				return globToRegExp;
+			},
+		},
+	})
+);

package/node_modules/watchpack/lib/reducePlan.js

@@ -67,45 +67,66 @@ module.exports = (plan, limit) => {
 			}
 		}
 	}
-	// Reduce until limit reached
-	while (currentCount > limit) {
-		// Select node that helps reaching the limit most effectively without overmerging
-		const overLimit = currentCount - limit;
-		let bestNode;
-		let bestCost = Infinity;
+	// Reduce until limit reached. When no reduction is needed at all, skip
+	// building the candidate set entirely to avoid paying for the setup on the
+	// common fast path.
+	if (currentCount > limit) {
+		// Pre-filter candidate nodes so the inner selection loop skips structural
+		// non-candidates entirely. `children` length and parent presence are
+		// fixed after tree construction; only `entries` can change (it can only
+		// decrease), so a node that fails the `entries` check in a later round
+		// is simply skipped via `continue`. When we merge a subtree we drop the
+		// descendants from the candidate set to keep it shrinking over
+		// iterations.
+		/** @type {Set<TreeNode<T>>} */
+		const candidates = new Set();
 		for (const node of treeMap.values()) {
-			if (node.entries <= 1 || !node.children || !node.parent) continue;
+			if (!node.parent || !node.children) continue;
 			if (node.children.length === 0) continue;
 			if (node.children.length === 1 && !node.value) continue;
-			// Try to select the node with has just a bit more entries than we need to reduce
-			// When just a bit more is over 30% over the limit,
-			// also consider just a bit less entries then we need to reduce
-			const cost =
-				node.entries - 1 >= overLimit
-					? node.entries - 1 - overLimit
-					: overLimit - node.entries + 1 + limit * 0.3;
-			if (cost < bestCost) {
-				bestNode = node;
-				bestCost = cost;
-			}
-		}
-		if (!bestNode) break;
-		// Merge all children
-		const reduction = bestNode.entries - 1;
-		bestNode.active = true;
-		bestNode.entries = 1;
-		currentCount -= reduction;
-		let { parent } = bestNode;
-		while (parent) {
-			parent.entries -= reduction;
-			parent = parent.parent;
+			candidates.add(node);
 		}
-		const queue = new Set(bestNode.children);
-		for (const node of queue) {
-			node.active = false;
-			node.entries = 0;
-			if (node.children) {
-				for (const child of node.children) queue.add(child);
+		const costBias = limit * 0.3;
+		while (currentCount > limit) {
+			// Select node that helps reaching the limit most effectively without overmerging
+			const overLimit = currentCount - limit;
+			let bestNode;
+			let bestCost = Infinity;
+			for (const node of candidates) {
+				if (node.entries <= 1) continue;
+				// Try to select the node with has just a bit more entries than we need to reduce
+				// When just a bit more is over 30% over the limit,
+				// also consider just a bit less entries then we need to reduce
+				const diff = node.entries - 1 - overLimit;
+				const cost = diff >= 0 ? diff : -diff + costBias;
+				if (cost < bestCost) {
+					bestNode = node;
+					bestCost = cost;
+					// A cost of 0 means the merge reduces exactly to the limit;
+					// no further candidate can improve on that, so stop scanning.
+					if (cost === 0) break;
+				}
+			}
+			if (!bestNode) break;
+			// Merge all children
+			const reduction = bestNode.entries - 1;
+			bestNode.active = true;
+			bestNode.entries = 1;
+			candidates.delete(bestNode);
+			currentCount -= reduction;
+			let { parent } = bestNode;
+			while (parent) {
+				parent.entries -= reduction;
+				parent = parent.parent;
+			}
+			const queue = new Set(bestNode.children);
+			for (const node of queue) {
+				node.active = false;
+				node.entries = 0;
+				candidates.delete(node);
+				if (node.children) {
+					for (const child of node.children) queue.add(child);
+				}
 			}
 		}
 	}

package/node_modules/watchpack/lib/util/globToRegExp.js

@@ -0,0 +1,142 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Haijie Xie @hai-x
+*/
+
+"use strict";
+
+// Based on https://github.com/fitzgen/glob-to-regexp (MIT)
+// Specialized for watchpack: `extended` and `globstar` always enabled.
+// Returns the regexp source without `^`/`$` anchors.
+
+const CC_EXCLAMATION = 33; // "!"
+const CC_DOLLAR = 36; // "$"
+const CC_LEFT_PARENTHESIS = 40; // "("
+const CC_RIGHT_PARENTHESIS = 41; // ")"
+const CC_ASTERISK = 42; // "*"
+const CC_PLUS = 43; // "+"
+const CC_COMMA = 44; // ","
+const CC_DOT = 46; // "."
+const CC_SLASH = 47; // "/"
+const CC_EQUAL = 61; // "="
+const CC_QUESTION_MARK = 63; // "?"
+const CC_LEFT_BRACKET = 91; // "["
+const CC_RIGHT_BRACKET = 93; // "]"
+const CC_CARET = 94; // "^"
+const CC_LEFT_BRACE = 123; // "{"
+const CC_PIPE = 124; // "|"
+const CC_RIGHT_BRACE = 125; // "}"
+
+/**
+ * @param {string} glob glob pattern
+ * @returns {string} regexp source without anchors
+ */
+module.exports = (glob) => {
+	if (typeof glob !== "string") {
+		throw new TypeError("Expected a string");
+	}
+
+	const len = glob.length;
+	let reStr = "";
+	let inGroup = false;
+	// Start of the current run of literal characters, copied with one slice
+	let literalStart = 0;
+
+	for (let i = 0; i < len; i++) {
+		const cc = glob.charCodeAt(i);
+		const tokenStart = i;
+		let mapped;
+
+		switch (cc) {
+			case CC_SLASH:
+				mapped = "\\/";
+				break;
+			case CC_DOLLAR:
+				mapped = "\\$";
+				break;
+			case CC_CARET:
+				mapped = "\\^";
+				break;
+			case CC_PLUS:
+				mapped = "\\+";
+				break;
+			case CC_DOT:
+				mapped = "\\.";
+				break;
+			case CC_LEFT_PARENTHESIS:
+				mapped = "\\(";
+				break;
+			case CC_RIGHT_PARENTHESIS:
+				mapped = "\\)";
+				break;
+			case CC_EQUAL:
+				mapped = "\\=";
+				break;
+			case CC_EXCLAMATION:
+				mapped = "\\!";
+				break;
+			case CC_PIPE:
+				mapped = "\\|";
+				break;
+			case CC_QUESTION_MARK:
+				mapped = ".";
+				break;
+			case CC_LEFT_BRACKET:
+				mapped = "[";
+				break;
+			case CC_RIGHT_BRACKET:
+				mapped = "]";
+				break;
+			case CC_LEFT_BRACE:
+				inGroup = true;
+				mapped = "(";
+				break;
+			case CC_RIGHT_BRACE:
+				inGroup = false;
+				mapped = ")";
+				break;
+			case CC_COMMA:
+				mapped = inGroup ? "|" : "\\,";
+				break;
+			case CC_ASTERISK: {
+				const atStart = i === 0;
+				const afterSlash = !atStart && glob.charCodeAt(i - 1) === CC_SLASH;
+				let starCount = 1;
+				while (i + 1 < len && glob.charCodeAt(i + 1) === CC_ASTERISK) {
+					starCount++;
+					i++;
+				}
+				const atEnd = i + 1 === len;
+				const beforeSlash = !atEnd && glob.charCodeAt(i + 1) === CC_SLASH;
+				if (
+					starCount > 1 &&
+					(atStart || afterSlash) &&
+					(atEnd || beforeSlash)
+				) {
+					// Globstar segment, matches zero or more path segments
+					mapped = "((?:[^/]*(?:\\/|$))*)";
+					i++; // Move over the "/"
+				} else {
+					// Not a globstar, matches one path segment
+					mapped = "([^/]*)";
+				}
+				break;
+			}
+			default:
+				// Literal character, extend the current run
+				continue;
+		}
+
+		if (literalStart < tokenStart) {
+			reStr += glob.slice(literalStart, tokenStart);
+		}
+		reStr += mapped;
+		literalStart = i + 1;
+	}
+
+	if (literalStart < len) {
+		reStr += literalStart === 0 ? glob : glob.slice(literalStart);
+	}
+
+	return reStr;
+};

package/node_modules/watchpack/lib/watchEventSource.js

@@ -61,6 +61,9 @@ function createEPERMError(filePath) {
  * @returns {(type: "rename" | "change", filename: string) => void} handler of change event
  */
 function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
+	// path.basename(filePath) is invariant for the lifetime of the watcher,
+	// so compute it once rather than on every dispatched event.
+	const ownBasename = path.basename(filePath);
 	return (type, filename) => {
 		// TODO: After Node.js v22, fs.watch(dir) and deleting a dir will trigger the rename change event.
 		// Here we just ignore it and keep the same behavior as before v22
@@ -68,7 +71,7 @@ function createHandleChangeEvent(watcher, filePath, handleChangeEvent) {
 		if (
 			type === "rename" &&
 			path.isAbsolute(filename) &&
-			path.basename(filename) === path.basename(filePath)
+			path.basename(filename) === ownBasename
 		) {
 			if (!IS_OSX) {
 				// Before v22, windows will throw EPERM error
@@ -429,16 +432,21 @@ module.exports.watch = (filePath) => {
 		directWatcher.add(watcher);
 		return watcher;
 	}
-	let current = filePath;
-	for (;;) {
-		const recursiveWatcher = recursiveWatchers.get(current);
-		if (recursiveWatcher !== undefined) {
-			recursiveWatcher.add(filePath, watcher);
-			return watcher;
+	// Only platforms with recursive fs.watch ever populate recursiveWatchers,
+	// so skip the entire parent walk when the map is empty (always the case
+	// on Linux and the common case before the watcher limit is reached).
+	if (recursiveWatchers.size !== 0) {
+		let current = filePath;
+		for (;;) {
+			const recursiveWatcher = recursiveWatchers.get(current);
+			if (recursiveWatcher !== undefined) {
+				recursiveWatcher.add(filePath, watcher);
+				return watcher;
+			}
+			const parent = path.dirname(current);
+			if (parent === current) break;
+			current = parent;
 		}
-		const parent = path.dirname(current);
-		if (parent === current) break;
-		current = parent;
 	}
 	// Queue up watcher for creation
 	pendingWatchers.set(watcher, filePath);

package/node_modules/watchpack/package.json

@@ -1,6 +1,6 @@
 {
   "name": "watchpack",
-  "version": "2.5.1",
+  "version": "2.5.2",
   "description": "",
   "homepage": "https://github.com/webpack/watchpack",
   "bugs": {
@@ -24,12 +24,12 @@
   "scripts": {
     "lint": "npm run lint:code && npm run lint:types && npm run lint:types-test && npm run lint:declarations && npm run fmt:check",
     "lint:code": "eslint --cache .",
-    "lint:types": "tsc",
-    "lint:types-test": "tsc -p tsconfig.types.test.json",
+    "lint:types": "tsc --noEmit",
+    "lint:types-test": "tsc -p tsconfig.types.test.json --noEmit",
     "lint:declarations": "npm run fix:declarations && git diff --exit-code ./types",
     "fix": "npm run fix:code && npm run fix:declarations",
     "fix:code": "npm run lint:code -- --fix",
-    "fix:declarations": "tsc --noEmit false --declaration --emitDeclarationOnly --outDir types && npm run fmt -- ./types",
+    "fix:declarations": "tsc && npm run fmt -- ./types",
     "fmt": "npm run fmt:base -- --log-level warn --write",
     "fmt:check": "npm run fmt:base -- --check",
     "fmt:base": "prettier --cache --ignore-unknown .",
@@ -38,35 +38,29 @@
     "test:base": "jest --runInBand",
     "test:only": "npm run test:base",
     "test:watch": "npm run test:base -- --watch",
-    "test:coverage": "npm run test:base -- --collectCoverageFrom=\"lib/**/*.js\" --coverage"
+    "test:coverage": "npm run test:base -- --collectCoverageFrom=\"lib/**/*.js\" --coverage",
+    "benchmark": "node --max-old-space-size=4096 --hash-seed=1 --random-seed=1 --no-opt --predictable --predictable-gc-schedule --interpreted-frames-native-stack --allow-natives-syntax --expose-gc --no-concurrent-sweeping ./benchmark/run.mjs",
+    "version": "changeset version",
+    "release": "changeset publish"
   },
   "dependencies": {
-    "glob-to-regexp": "^0.4.1",
     "graceful-fs": "^4.1.2"
   },
   "devDependencies": {
-    "@eslint/js": "^9.28.0",
-    "@eslint/markdown": "^7.5.1",
-    "@stylistic/eslint-plugin": "^5.6.1",
+    "@changesets/cli": "^2.30.0",
+    "@changesets/get-github-info": "^0.8.0",
+    "@codspeed/core": "^5.2.0",
     "@types/glob-to-regexp": "^0.4.4",
     "@types/graceful-fs": "^4.1.9",
-    "@types/jest": "^27.5.1",
+    "@types/jest": "^30.0.0",
     "@types/node": "^24.10.4",
     "eslint": "^9.39.2",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-config-webpack": "^4.7.3",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jest": "^29.5.0",
-    "eslint-plugin-jsdoc": "^61.5.0",
-    "eslint-plugin-n": "^17.23.1",
-    "eslint-plugin-prettier": "^5.5.4",
-    "eslint-plugin-unicorn": "^62.0.0",
-    "globals": "^16.5.0",
-    "jest": "^27.5.1",
+    "eslint-config-webpack": "^4.9.3",
+    "jest": "^30.3.0",
     "prettier": "^3.7.4",
-    "rimraf": "^2.6.2",
-    "typescript": "^5.9.3",
-    "write-file-atomic": "^3.0.1"
+    "tinybench": "^6.0.0",
+    "typescript": "^6.0.2",
+    "write-file-atomic": "^8.0.0"
   },
   "engines": {
     "node": ">=10.13.0"

package/node_modules/watchpack/types/DirectoryWatcher.d.ts

@@ -48,6 +48,8 @@ declare class DirectoryWatcher extends EventEmitter<{
 	filesWithoutCase: Map<string, number>;
 	/** @type {Map<string, Watcher<DirectoryWatcherEvents> | boolean>} */
 	directories: Map<string, Watcher<DirectoryWatcherEvents> | boolean>;
+	/** @type {Map<string, Watcher<FileWatcherEvents>>} */
+	_symlinkTargetWatchers: Map<string, Watcher<FileWatcherEvents>>;
 	lastWatchEvent: number;
 	initialScan: boolean;
 	ignored: import("./index").IgnoredFunction;