@ryanatkn/gro 0.138.2 → 0.139.0

package/dist/gro_plugin_gen.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_plugin_gen.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_gen.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAKpC,OAAO,KAAK,EAAC,WAAW,EAAE,OAAO,EAAC,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAgB,WAAW,EAAC,MAAM,YAAY,CAAC;AAK3D,MAAM,WAAW,SAAU,SAAQ,IAAI;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,OAAO;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,cAAc,uDAIxB,OAAO,KAAkB,MA8E3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBAChB,WAAW,aACb,CAAC,EAAE,EAAE,OAAO,KAAK,WAAW,GAAG,SAAS,WAC1C,WAAW,YACX,GAAG,CAAC,MAAM,CAAC,aACV,GAAG,CAAC,MAAM,CAAC,KACnB,GAAG,CAAC,MAAM,CAYZ,CAAC"}
+{"version":3,"file":"gro_plugin_gen.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_gen.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AACxC,OAAO,KAAK,EAAC,IAAI,EAAC,MAAM,WAAW,CAAC;AAIpC,OAAO,KAAK,EAAC,WAAW,EAAE,OAAO,EAAC,MAAM,WAAW,CAAC;AACpD,OAAO,KAAK,EAAgB,WAAW,EAAC,MAAM,YAAY,CAAC;AAI3D,MAAM,WAAW,SAAU,SAAQ,IAAI;IACtC,KAAK,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,MAAM,WAAW,OAAO;IACvB,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,eAAO,MAAM,cAAc,uDAIxB,OAAO,KAAkB,MAiF3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,gBAChB,WAAW,aACb,CAAC,EAAE,EAAE,OAAO,KAAK,WAAW,GAAG,SAAS,WAC1C,WAAW,YACX,GAAG,CAAC,MAAM,CAAC,aACV,GAAG,CAAC,MAAM,CAAC,KACnB,GAAG,CAAC,MAAM,CAYZ,CAAC"}

package/dist/gro_plugin_gen.js

@@ -1,9 +1,9 @@
 import { EMPTY_OBJECT } from '@ryanatkn/belt/object.js';
+import { throttle } from '@ryanatkn/belt/throttle.js';
+import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 import { paths } from './paths.js';
 import { find_genfiles, is_gen_path } from './gen.js';
-import { throttle } from './throttle.js';
 import { spawn_cli } from './cli.js';
-import { Unreachable_Error } from '@ryanatkn/belt/error.js';
 const FLUSH_DEBOUNCE_DELAY = 500;
 export const gro_plugin_gen = ({ input_paths = [paths.source], root_dirs = [paths.source], flush_debounce_delay = FLUSH_DEBOUNCE_DELAY, } = EMPTY_OBJECT) => {
     let flushing_timeout;
@@ -21,7 +21,7 @@ export const gro_plugin_gen = ({ input_paths = [paths.source], root_dirs = [path
         const files = Array.from(queued_files);
         queued_files.clear();
         await gen(files);
-    }, flush_debounce_delay);
+    }, { delay: flush_debounce_delay });
     const gen = (files = []) => spawn_cli('gro', ['gen', ...files]);
     let cleanup;
     return {

package/dist/gro_plugin_server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gro_plugin_server.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,EAAC,MAAM,IAAI,eAAe,EAAC,MAAM,eAAe,CAAC;AAI7D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAGrD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAiBxC,eAAO,MAAM,gBAAgB,6BAA0D,CAAC;AAExF,eAAO,MAAM,UAAU,0CAA8B,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAKpF,CAAC;AAEF,MAAM,WAAW,OAAO;IACvB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,CAAC,YAAY,EAAE,OAAO,CAAC,YAAY,KAAK,OAAO,CAAC,YAAY,CAAC;IACrF;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACxB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,QAAQ,CAAC;AAEzD,eAAO,MAAM,iBAAiB,yJAgB3B,OAAO,KAAQ,MAqJjB,CAAC"}
+{"version":3,"file":"gro_plugin_server.d.ts","sourceRoot":"../src/lib/","sources":["gro_plugin_server.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,KAAK,EAAC,MAAM,IAAI,eAAe,EAAC,MAAM,eAAe,CAAC;AAI7D,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,0BAA0B,CAAC;AAIrD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAgBxC,eAAO,MAAM,gBAAgB,6BAA0D,CAAC;AAExF,eAAO,MAAM,UAAU,0CAA8B,MAAM,CAAC,MAAM,EAAE;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,CAKpF,CAAC;AAEF,MAAM,WAAW,OAAO;IACvB;;OAEG;IACH,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB;;OAEG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,gBAAgB,CAAC,EAAE,eAAe,CAAC;IACnC;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,CAAC,YAAY,EAAE,OAAO,CAAC,YAAY,KAAK,OAAO,CAAC,YAAY,CAAC;IACrF;;;;OAIG;IACH,sBAAsB,CAAC,EAAE,MAAM,CAAC;IAChC;;;;OAIG;IACH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;OAGG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;CACd;AAED,MAAM,WAAW,QAAQ;IACxB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;IAChB;;OAEG;IACH,OAAO,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,GAAG,EAAE,OAAO,KAAK,QAAQ,CAAC;AAEzD,eAAO,MAAM,iBAAiB,yJAgB3B,OAAO,KAAQ,MAwJjB,CAAC"}

package/dist/gro_plugin_server.js

@@ -4,6 +4,7 @@ import { join, resolve } from 'node:path';
 import { identity } from '@ryanatkn/belt/function.js';
 import { strip_before, strip_end } from '@ryanatkn/belt/string.js';
 import { existsSync } from 'node:fs';
+import { throttle } from '@ryanatkn/belt/throttle.js';
 import { base_path_to_path_id, LIB_DIRNAME, paths } from './paths.js';
 import { GRO_DEV_DIRNAME, SERVER_DIST_PATH } from './path_constants.js';
 import { watch_dir } from './watch_dir.js';
@@ -15,7 +16,6 @@ import { esbuild_plugin_sveltekit_shim_alias } from './esbuild_plugin_sveltekit_
 import { esbuild_plugin_external_worker } from './esbuild_plugin_external_worker.js';
 import { esbuild_plugin_sveltekit_local_imports } from './esbuild_plugin_sveltekit_local_imports.js';
 import { esbuild_plugin_svelte } from './esbuild_plugin_svelte.js';
-import { throttle } from './throttle.js';
 // TODO sourcemap as a hoisted option? disable for production by default - or like `outpaths`, passed a `dev` param
 export const SERVER_SOURCE_ID = base_path_to_path_id(LIB_DIRNAME + '/server/server.ts');
 export const has_server = (path = SERVER_SOURCE_ID) => {
@@ -112,7 +112,7 @@ export const gro_plugin_server = ({ entry_points = [SERVER_SOURCE_ID], dir = pro
                 print_build_result(log, build_result);
                 deps = parse_deps(metafile.inputs, dir);
                 server_process?.restart();
-            }, rebuild_throttle_delay);
+            }, { delay: rebuild_throttle_delay });
             await rebuild();
             // uses chokidar instead of esbuild's watcher for efficiency
             if (watch) {

package/dist/package.d.ts

@@ -417,10 +417,6 @@ export declare const package_json: {
             types: string;
             default: string;
         };
-        './throttle.js': {
-            types: string;
-            default: string;
-        };
         './typecheck.task.js': {
             types: string;
             default: string;
@@ -1001,13 +997,6 @@ export declare const src_json: {
                 kind: string;
             }[];
         };
-        './throttle.js': {
-            path: string;
-            declarations: {
-                name: string;
-                kind: string;
-            }[];
-        };
         './typecheck.task.js': {
             path: string;
             declarations: {

package/dist/package.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8vBD,CAAC"}
+{"version":3,"file":"package.d.ts","sourceRoot":"../src/lib/","sources":["package.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsQD,CAAC;AAEzB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6vBD,CAAC"}

package/dist/package.js

@@ -1,7 +1,7 @@
 // generated by src/lib/package.gen.ts
 export const package_json = {
     name: '@ryanatkn/gro',
-    version: '0.138.2',
+    version: '0.139.0',
     description: 'task runner and toolkit extending SvelteKit',
     motto: 'generate, run, optimize',
     glyph: '🌰',
@@ -39,7 +39,7 @@ export const package_json = {
         'typescript',
     ],
     dependencies: {
-        '@ryanatkn/belt': '^0.25.0',
+        '@ryanatkn/belt': '^0.25.3',
         chokidar: '^4.0.1',
         dotenv: '^16.4.5',
         'es-module-lexer': '^1.5.4',
@@ -253,7 +253,6 @@ export const package_json = {
         './task_logging.js': { types: './dist/task_logging.d.ts', default: './dist/task_logging.js' },
         './task.js': { types: './dist/task.d.ts', default: './dist/task.js' },
         './test.task.js': { types: './dist/test.task.d.ts', default: './dist/test.task.js' },
-        './throttle.js': { types: './dist/throttle.d.ts', default: './dist/throttle.js' },
         './typecheck.task.js': {
             types: './dist/typecheck.task.d.ts',
             default: './dist/typecheck.task.js',
@@ -264,7 +263,7 @@ export const package_json = {
 };
 export const src_json = {
     name: '@ryanatkn/gro',
-    version: '0.138.2',
+    version: '0.139.0',
     modules: {
         '.': {
             path: 'index.ts',
@@ -1001,7 +1000,6 @@ export const src_json = {
                 { name: 'task', kind: 'variable' },
             ],
         },
-        './throttle.js': { path: 'throttle.ts', declarations: [{ name: 'throttle', kind: 'function' }] },
         './typecheck.task.js': {
             path: 'typecheck.task.ts',
             declarations: [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ryanatkn/gro",
-  "version": "0.138.2",
+  "version": "0.139.0",
   "description": "task runner and toolkit extending SvelteKit",
   "motto": "generate, run, optimize",
   "glyph": "🌰",
@@ -49,7 +49,7 @@
     "typescript"
   ],
   "dependencies": {
-    "@ryanatkn/belt": "^0.25.0",
+    "@ryanatkn/belt": "^0.25.3",
     "chokidar": "^4.0.1",
     "dotenv": "^16.4.5",
     "es-module-lexer": "^1.5.4",
@@ -438,10 +438,6 @@
       "types": "./dist/test.task.d.ts",
       "default": "./dist/test.task.js"
     },
-    "./throttle.js": {
-      "types": "./dist/throttle.d.ts",
-      "default": "./dist/throttle.js"
-    },
     "./typecheck.task.js": {
       "types": "./dist/typecheck.task.d.ts",
       "default": "./dist/typecheck.task.js"

package/src/lib/gro_plugin_gen.ts

@@ -1,14 +1,14 @@
 import {EMPTY_OBJECT} from '@ryanatkn/belt/object.js';
+import {throttle} from '@ryanatkn/belt/throttle.js';
+import {Unreachable_Error} from '@ryanatkn/belt/error.js';
 
 import type {Plugin} from './plugin.js';
 import type {Args} from './args.js';
 import {paths} from './paths.js';
 import {find_genfiles, is_gen_path} from './gen.js';
-import {throttle} from './throttle.js';
 import {spawn_cli} from './cli.js';
 import type {File_Filter, Path_Id} from './path.js';
 import type {Cleanup_Watch, Source_File} from './filer.js';
-import {Unreachable_Error} from '@ryanatkn/belt/error.js';
 
 const FLUSH_DEBOUNCE_DELAY = 500;
 
@@ -38,11 +38,14 @@ export const gro_plugin_gen = ({
 			}); // the timeout batches synchronously
 		}
 	};
-	const flush_gen_queue = throttle(async () => {
-		const files = Array.from(queued_files);
-		queued_files.clear();
-		await gen(files);
-	}, flush_debounce_delay);
+	const flush_gen_queue = throttle(
+		async () => {
+			const files = Array.from(queued_files);
+			queued_files.clear();
+			await gen(files);
+		},
+		{delay: flush_debounce_delay},
+	);
 	const gen = (files: string[] = []) => spawn_cli('gro', ['gen', ...files]);
 
 	let cleanup: Cleanup_Watch | undefined;

package/src/lib/gro_plugin_server.ts

@@ -6,6 +6,7 @@ import {identity} from '@ryanatkn/belt/function.js';
 import {strip_before, strip_end} from '@ryanatkn/belt/string.js';
 import type {Result} from '@ryanatkn/belt/result.js';
 import {existsSync} from 'node:fs';
+import {throttle} from '@ryanatkn/belt/throttle.js';
 
 import type {Plugin} from './plugin.js';
 import {base_path_to_path_id, LIB_DIRNAME, paths} from './paths.js';
@@ -20,7 +21,6 @@ import {esbuild_plugin_sveltekit_shim_alias} from './esbuild_plugin_sveltekit_sh
 import {esbuild_plugin_external_worker} from './esbuild_plugin_external_worker.js';
 import {esbuild_plugin_sveltekit_local_imports} from './esbuild_plugin_sveltekit_local_imports.js';
 import {esbuild_plugin_svelte} from './esbuild_plugin_svelte.js';
-import {throttle} from './throttle.js';
 
 // TODO sourcemap as a hoisted option? disable for production by default - or like `outpaths`, passed a `dev` param
 
@@ -208,20 +208,23 @@ export const gro_plugin_server = ({
 
 			timing_to_esbuild_create_context();
 
-			const rebuild = throttle(async () => {
-				let build_result;
-				try {
-					build_result = await build_ctx!.rebuild();
-				} catch (err) {
-					log.error('[gro_plugin_server] build failed', err);
-					return;
-				}
-				const {metafile} = build_result;
-				if (!metafile) return;
-				print_build_result(log, build_result);
-				deps = parse_deps(metafile.inputs, dir);
-				server_process?.restart();
-			}, rebuild_throttle_delay);
+			const rebuild = throttle(
+				async () => {
+					let build_result;
+					try {
+						build_result = await build_ctx!.rebuild();
+					} catch (err) {
+						log.error('[gro_plugin_server] build failed', err);
+						return;
+					}
+					const {metafile} = build_result;
+					if (!metafile) return;
+					print_build_result(log, build_result);
+					deps = parse_deps(metafile.inputs, dir);
+					server_process?.restart();
+				},
+				{delay: rebuild_throttle_delay},
+			);
 
 			await rebuild();
 

package/src/lib/package.ts

@@ -5,7 +5,7 @@ import type {Src_Json} from './src_json.js';
 
 export const package_json = {
 	name: '@ryanatkn/gro',
-	version: '0.138.2',
+	version: '0.139.0',
 	description: 'task runner and toolkit extending SvelteKit',
 	motto: 'generate, run, optimize',
 	glyph: '🌰',
@@ -44,7 +44,7 @@ export const package_json = {
 		'typescript',
 	],
 	dependencies: {
-		'@ryanatkn/belt': '^0.25.0',
+		'@ryanatkn/belt': '^0.25.3',
 		chokidar: '^4.0.1',
 		dotenv: '^16.4.5',
 		'es-module-lexer': '^1.5.4',
@@ -258,7 +258,6 @@ export const package_json = {
 		'./task_logging.js': {types: './dist/task_logging.d.ts', default: './dist/task_logging.js'},
 		'./task.js': {types: './dist/task.d.ts', default: './dist/task.js'},
 		'./test.task.js': {types: './dist/test.task.d.ts', default: './dist/test.task.js'},
-		'./throttle.js': {types: './dist/throttle.d.ts', default: './dist/throttle.js'},
 		'./typecheck.task.js': {
 			types: './dist/typecheck.task.d.ts',
 			default: './dist/typecheck.task.js',
@@ -270,7 +269,7 @@ export const package_json = {
 
 export const src_json = {
 	name: '@ryanatkn/gro',
-	version: '0.138.2',
+	version: '0.139.0',
 	modules: {
 		'.': {
 			path: 'index.ts',
@@ -1007,7 +1006,6 @@ export const src_json = {
 				{name: 'task', kind: 'variable'},
 			],
 		},
-		'./throttle.js': {path: 'throttle.ts', declarations: [{name: 'throttle', kind: 'function'}]},
 		'./typecheck.task.js': {
 			path: 'typecheck.task.ts',
 			declarations: [

package/dist/throttle.d.ts

@@ -1,19 +0,0 @@
-/**
- * Throttles calls to a callback that returns a void promise.
- * Immediately invokes the callback on the first call.
- * If the throttled function is called while the promise is already pending,
- * the call is queued to run after the pending promise completes plus `delay`,
- * and only the last call is invoked.
- * In other words, all calls and their args are discarded
- * during the pending window except for the most recent.
- * Unlike debouncing, this calls the throttled callback
- * both on the leading and trailing edges of the delay window,
- * and this can be customized by setting `leading` to `false`.
- * It also differs from a queue where every call to the throttled callback eventually runs.
- * @param cb - any function that returns a void promise
- * @param delay - delay this many milliseconds between the pending call finishing and the next starting
- * @param leading - if `true`, the default, the callback is called immediately
- * @returns same as `cb`
- */
-export declare const throttle: <T extends (...args: any[]) => Promise<void>>(cb: T, delay?: number, leading?: boolean) => T;
-//# sourceMappingURL=throttle.d.ts.map

package/dist/throttle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.d.ts","sourceRoot":"../src/lib/","sources":["throttle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,QAAQ,GAAI,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,MAC/D,CAAC,wCAGH,CA0CF,CAAC"}

package/dist/throttle.js

@@ -1,58 +0,0 @@
-/**
- * Throttles calls to a callback that returns a void promise.
- * Immediately invokes the callback on the first call.
- * If the throttled function is called while the promise is already pending,
- * the call is queued to run after the pending promise completes plus `delay`,
- * and only the last call is invoked.
- * In other words, all calls and their args are discarded
- * during the pending window except for the most recent.
- * Unlike debouncing, this calls the throttled callback
- * both on the leading and trailing edges of the delay window,
- * and this can be customized by setting `leading` to `false`.
- * It also differs from a queue where every call to the throttled callback eventually runs.
- * @param cb - any function that returns a void promise
- * @param delay - delay this many milliseconds between the pending call finishing and the next starting
- * @param leading - if `true`, the default, the callback is called immediately
- * @returns same as `cb`
- */
-export const throttle = (cb, delay = 0, leading = true) => {
-    let pending_promise = null;
-    let next_args = null;
-    let next_promise = null;
-    let next_promise_resolve = null;
-    const defer = (args) => {
-        next_args = args;
-        if (!next_promise) {
-            next_promise = new Promise((resolve) => {
-                next_promise_resolve = resolve;
-            });
-            setTimeout(flush, delay);
-        }
-        return next_promise;
-    };
-    const flush = async () => {
-        if (!next_promise_resolve)
-            return;
-        const result = await call(next_args);
-        next_args = null;
-        next_promise = null;
-        const resolve = next_promise_resolve;
-        next_promise_resolve = null;
-        resolve(result); // resolve last to prevent synchronous call issues
-    };
-    const call = (args) => {
-        pending_promise = cb(...args);
-        void pending_promise.then(() => {
-            pending_promise = null;
-        });
-        return pending_promise;
-    };
-    return ((...args) => {
-        if (pending_promise || !leading) {
-            return defer(args);
-        }
-        else {
-            return call(args);
-        }
-    });
-};

package/src/lib/throttle.ts

@@ -1,64 +0,0 @@
-/**
- * Throttles calls to a callback that returns a void promise.
- * Immediately invokes the callback on the first call.
- * If the throttled function is called while the promise is already pending,
- * the call is queued to run after the pending promise completes plus `delay`,
- * and only the last call is invoked.
- * In other words, all calls and their args are discarded
- * during the pending window except for the most recent.
- * Unlike debouncing, this calls the throttled callback
- * both on the leading and trailing edges of the delay window,
- * and this can be customized by setting `leading` to `false`.
- * It also differs from a queue where every call to the throttled callback eventually runs.
- * @param cb - any function that returns a void promise
- * @param delay - delay this many milliseconds between the pending call finishing and the next starting
- * @param leading - if `true`, the default, the callback is called immediately
- * @returns same as `cb`
- */
-export const throttle = <T extends (...args: any[]) => Promise<void>>(
-	cb: T,
-	delay = 0,
-	leading = true,
-): T => {
-	let pending_promise: Promise<void> | null = null;
-	let next_args: any[] | null = null;
-	let next_promise: Promise<void> | null = null;
-	let next_promise_resolve: ((value: any) => void) | null = null;
-
-	const defer = (args: any[]): Promise<void> => {
-		next_args = args;
-		if (!next_promise) {
-			next_promise = new Promise((resolve) => {
-				next_promise_resolve = resolve;
-			});
-			setTimeout(flush, delay);
-		}
-		return next_promise;
-	};
-
-	const flush = async (): Promise<void> => {
-		if (!next_promise_resolve) return;
-		const result = await call(next_args!);
-		next_args = null;
-		next_promise = null;
-		const resolve = next_promise_resolve;
-		next_promise_resolve = null;
-		resolve(result); // resolve last to prevent synchronous call issues
-	};
-
-	const call = (args: any[]): Promise<any> => {
-		pending_promise = cb(...args);
-		void pending_promise.then(() => {
-			pending_promise = null;
-		});
-		return pending_promise;
-	};
-
-	return ((...args) => {
-		if (pending_promise || !leading) {
-			return defer(args);
-		} else {
-			return call(args);
-		}
-	}) as T;
-};