@ryanatkn/gro 0.129.9 → 0.129.10

package/dist/search_fs.test.js

@@ -1,48 +0,0 @@
-import { test } from 'uvu';
-import * as assert from 'uvu/assert';
-import { resolve } from 'node:path';
-import { search_fs } from './search_fs.js';
-test('search_fs basic behavior', () => {
-    const ignored_path = 'test1.foo.ts';
-    let has_ignored_path = false;
-    const result = search_fs('./src/fixtures', {
-        filter: (path) => {
-            if (!has_ignored_path)
-                has_ignored_path = path.endsWith(ignored_path);
-            return !path.endsWith(ignored_path);
-        },
-        sort: (a, b) => a.path.localeCompare(b.path) * -1,
-    });
-    assert.ok(has_ignored_path); // makes sure the test isn't wrong
-    const expected_files = [
-        'test2.foo.ts',
-        'test_ts.ts',
-        'test_task_module.task_fixture.ts',
-        'test_js.js',
-        'test_invalid_task_module.ts',
-        'test_file.other.ext',
-        'test_failing_task_module.ts',
-        'some_test_side_effect.ts',
-        'some_test_json.json',
-        'some_test_exports3.ts',
-        'some_test_exports2.ts',
-        'some_test_exports.ts',
-        'modules/some_test_ts.ts',
-        'modules/Some_Test_Svelte.svelte',
-        'modules/some_test_svelte_ts.svelte.ts',
-        'modules/some_test_svelte_js.svelte.js',
-        'modules/some_test_server.ts',
-        'modules/some_test_json.json',
-        'modules/some_test_js.js',
-        'modules/some_test_css.css',
-        'changelog_example.md',
-        'changelog_cache.json',
-        'baz2/test2.baz.ts',
-        'baz1/test1.baz.ts',
-        'bar2/test2.bar.ts',
-        'bar1/test1.bar.ts',
-    ];
-    assert.equal(result.map((f) => f.path), expected_files);
-    assert.equal(result.map((f) => f.id), expected_files.map((f) => resolve(`src/fixtures/${f}`)));
-});
-test.run();

package/dist/src_json.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=src_json.test.d.ts.map

package/dist/src_json.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"src_json.test.d.ts","sourceRoot":"","sources":["../../../src/lib/src_json.test.ts"],"names":[],"mappings":""}

package/dist/src_json.test.js

@@ -1,39 +0,0 @@
-import { test } from 'uvu';
-import * as assert from 'uvu/assert';
-import { to_src_modules } from './src_json.js';
-import { to_package_exports } from './package_json.js';
-import { paths } from './paths.js';
-test('to_package_modules', () => {
-    assert.equal(to_src_modules(to_package_exports([
-        'fixtures/modules/some_test_css.css',
-        'fixtures/modules/Some_Test_Svelte.svelte',
-        'fixtures/modules/some_test_ts.ts',
-        'fixtures/modules/some_test_json.json',
-    ]), undefined, paths.source), {
-        './package.json': { path: 'package.json', declarations: [] },
-        './fixtures/modules/some_test_css.css': {
-            path: 'fixtures/modules/some_test_css.css',
-            declarations: [],
-        },
-        './fixtures/modules/some_test_json.json': {
-            path: 'fixtures/modules/some_test_json.json',
-            declarations: [],
-        },
-        './fixtures/modules/Some_Test_Svelte.svelte': {
-            path: 'fixtures/modules/Some_Test_Svelte.svelte',
-            declarations: [],
-        },
-        './fixtures/modules/some_test_ts.js': {
-            path: 'fixtures/modules/some_test_ts.ts',
-            declarations: [
-                { name: 'a', kind: 'variable' },
-                { name: 'some_test_ts', kind: 'variable' },
-                { name: 'some_test_fn', kind: 'function' },
-                { name: 'Some_Test_Type', kind: 'type' },
-                { name: 'Some_Test_Interface', kind: 'type' },
-                { name: 'Some_Test_Class', kind: 'class' },
-            ],
-        },
-    });
-});
-test.run();

package/dist/task.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=task.test.d.ts.map

package/dist/task.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"task.test.d.ts","sourceRoot":"","sources":["../../../src/lib/task.test.ts"],"names":[],"mappings":""}

package/dist/task.test.js

@@ -1,46 +0,0 @@
-import { test } from 'uvu';
-import * as assert from 'uvu/assert';
-import { resolve } from 'node:path';
-import { is_task_path, to_task_name, validate_task_module, find_tasks, load_tasks } from './task.js';
-import * as actual_test_task_module from './test.task.js';
-import { create_empty_config } from './config.js';
-test('is_task_path basic behavior', () => {
-    assert.ok(is_task_path('foo.task.ts'));
-    assert.ok(is_task_path('foo.task.js'));
-    assert.ok(!is_task_path('foo.ts'));
-    assert.ok(is_task_path('bar/baz/foo.task.ts'));
-    assert.ok(!is_task_path('bar/baz/foo.ts'));
-});
-test('to_task_name basic behavior', () => {
-    assert.is(to_task_name('foo.task.ts', process.cwd(), '', ''), 'foo');
-    assert.is(to_task_name('bar/baz/foo.task.ts', process.cwd(), '', ''), 'bar/baz/foo');
-    assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b/c', '', ''), 'foo');
-    assert.is(to_task_name('a/b/c/foo.task.ts', 'a', '', ''), 'b/c/foo');
-    assert.is(to_task_name('a/b/c/foo.task.ts', 'a/b', '', ''), 'c/foo');
-    assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/d'), '../c/foo');
-    assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b'), 'c/foo');
-    assert.is(to_task_name('/a/b/c/foo.task.ts', '/a/b', '/a/b', '/a/b/c'), 'foo');
-    assert.is(to_task_name('/a/b/d/foo.task.js', '/a/b/d', '/a/b/d/foo', '/a/c'), '../b/d/foo');
-    assert.is(to_task_name('/a/node_modules/b/c/foo.task.js', '/a/node_modules/b/c', '/a/node_modules/b/c/foo', '/a'), 'foo');
-    assert.is(to_task_name('/a/node_modules/b/c/foo.task.js', '/a/node_modules/b/c/', // compared to the above, adds a trailing slash here
-    '/a/node_modules/b/c/foo', '/a'), 'foo');
-    assert.is(to_task_name('/a/node_modules/b/c/foo.task.js', '/a/node_modules/b/c', '/a/node_modules/b/c/foo', '/a/'), 'foo');
-    assert.is(to_task_name(resolve('a/b'), resolve('b'), '', ''), resolve('a/b'), 'falls back to the id when unresolved');
-});
-// TODO if we import directly, svelte-package generates types in `src/fixtures`
-const test_task_module = await import('../fixtures/' + 'test_task_module.task_fixture'); // eslint-disable-line no-useless-concat
-const test_invalid_task_module = await import('../fixtures/' + 'test_invalid_task_module.js'); // eslint-disable-line no-useless-concat
-test('validate_task_module basic behavior', () => {
-    assert.ok(validate_task_module(test_task_module));
-    assert.ok(!validate_task_module(test_invalid_task_module));
-    assert.ok(!validate_task_module({ task: { run: {} } }));
-});
-test('load_tasks basic behavior', async () => {
-    const found = find_tasks([resolve('src/lib/test'), resolve('src/lib/test.task.ts')], [resolve('src/lib')], create_empty_config());
-    assert.ok(found.ok);
-    const result = await load_tasks(found.value);
-    assert.ok(result.ok);
-    assert.is(result.value.modules.length, 1);
-    assert.is(result.value.modules[0].mod, actual_test_task_module);
-});
-test.run();

package/dist/throttle.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=throttle.test.d.ts.map

package/dist/throttle.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"throttle.test.d.ts","sourceRoot":"","sources":["../../../src/lib/throttle.test.ts"],"names":[],"mappings":""}

package/dist/throttle.test.js

@@ -1,49 +0,0 @@
-import { wait } from '@ryanatkn/belt/async.js';
-import { test } from 'uvu';
-import * as assert from 'uvu/assert';
-import { throttle } from './throttle.js';
-test('throttles calls to a function', async () => {
-    const results = [];
-    const fn = throttle(async (name) => {
-        results.push(name + '_run');
-        await wait();
-        results.push(name + '_done');
-    });
-    const promise_a = fn('a');
-    const promise_b = fn('b'); // discarded
-    const promise_c = fn('c'); // discarded
-    const promise_d = fn('d');
-    assert.ok(promise_a !== promise_b);
-    assert.is(promise_b, promise_c);
-    assert.is(promise_b, promise_d);
-    assert.equal(results, ['a_run']);
-    await promise_a;
-    assert.equal(results, ['a_run', 'a_done']);
-    await promise_b;
-    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']);
-    const promise_e = fn('e'); // discarded
-    const promise_f = fn('f');
-    assert.ok(promise_d !== promise_e);
-    assert.is(promise_e, promise_f);
-    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done']); // delayed
-    await wait();
-    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run']);
-    await promise_e;
-    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']);
-    const promise_g = fn('g');
-    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done']); // delayed
-    await wait();
-    assert.equal(results, ['a_run', 'a_done', 'd_run', 'd_done', 'f_run', 'f_done', 'g_run']);
-    await promise_g;
-    assert.equal(results, [
-        'a_run',
-        'a_done',
-        'd_run',
-        'd_done',
-        'f_run',
-        'f_done',
-        'g_run',
-        'g_done',
-    ]);
-});
-test.run();