@ryanatkn/gro 0.112.0

package/dist/module.js

@@ -0,0 +1,6 @@
+// TODO refactor to be configurable, probably following Rollup's patterns
+import { SOURCE_DIR, SOURCE_DIRNAME, LIB_DIRNAME } from './paths.js';
+export const MODULE_PATH_SRC_PREFIX = SOURCE_DIR;
+export const MODULE_PATH_LIB_PREFIX = `$${LIB_DIRNAME}/`;
+const INTERNAL_MODULE_MATCHER = new RegExp(`^(\\.?\\.?|${SOURCE_DIRNAME}|\\$${LIB_DIRNAME})\\/`, 'u');
+export const is_external_module = (module_name) => !INTERNAL_MODULE_MATCHER.test(module_name);

package/dist/module.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/module.test.js

@@ -0,0 +1,41 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { is_external_module } from './module.js';
+/* test__is_external_module */
+const test__is_external_module = suite('is_external_module');
+test__is_external_module('internal browser module patterns', () => {
+    assert.is(is_external_module('./foo'), false);
+    assert.is(is_external_module('./foo.js'), false);
+    assert.is(is_external_module('../foo'), false);
+    assert.is(is_external_module('../foo.js'), false);
+    assert.is(is_external_module('../../../foo'), false);
+    assert.is(is_external_module('../../../foo.js'), false);
+    assert.is(is_external_module('/foo'), false);
+    assert.is(is_external_module('/foo.js'), false);
+    assert.is(is_external_module('src/foo'), false);
+    assert.is(is_external_module('src/foo.js'), false);
+    assert.is(is_external_module('$lib/foo'), false);
+    assert.is(is_external_module('$lib/foo.js'), false);
+    assert.is(is_external_module('./foo/bar/baz'), false);
+    assert.is(is_external_module('./foo/bar/baz.js'), false);
+    assert.is(is_external_module('../foo/bar/baz'), false);
+    assert.is(is_external_module('../foo/bar/baz.js'), false);
+    assert.is(is_external_module('../../../foo/bar/baz'), false);
+    assert.is(is_external_module('../../../foo/bar/baz.js'), false);
+    assert.is(is_external_module('/foo/bar/baz'), false);
+    assert.is(is_external_module('/foo/bar/baz.js'), false);
+    assert.is(is_external_module('src/foo/bar/baz'), false);
+    assert.is(is_external_module('src/foo/bar/baz.js'), false);
+    assert.is(is_external_module('$lib/foo/bar/baz'), false);
+    assert.is(is_external_module('$lib/foo/bar/baz.js'), false);
+});
+test__is_external_module('external browser module patterns', () => {
+    assert.is(is_external_module('foo'), true);
+    assert.is(is_external_module('foo.js'), true);
+    assert.is(is_external_module('foo/bar/baz'), true);
+    assert.is(is_external_module('foo/bar/baz.js'), true);
+    assert.is(is_external_module('@foo/bar/baz'), true);
+    assert.is(is_external_module('@foo/bar/baz.js'), true);
+});
+test__is_external_module.run();
+/* test__is_external_module */

package/dist/modules.d.ts

@@ -0,0 +1,60 @@
+import type { Result } from '@ryanatkn/belt/result.js';
+import type { Path_Data } from './path.js';
+import { type Source_Id } from './paths.js';
+export interface Module_Meta<T_Module extends Record<string, any> = Record<string, any>> {
+    id: string;
+    mod: T_Module;
+}
+export type Load_Module_Result<T> = Result<{
+    mod: T;
+}, Load_Module_Failure>;
+export type Load_Module_Failure = {
+    ok: false;
+    type: 'importFailed';
+    id: string;
+    error: Error;
+} | {
+    ok: false;
+    type: 'invalid';
+    id: string;
+    mod: Record<string, any>;
+    validation: string;
+};
+export declare const load_module: <T extends Record<string, any>>(id: string, validate?: ((mod: Record<string, any>) => mod is T) | undefined) => Promise<Result<{
+    mod: T_1;
+}, Load_Module_Failure>>;
+export type Find_Modules_Result = Result<{
+    source_ids_by_input_path: Map<string, string[]>;
+    source_id_path_data_by_input_path: Map<string, Path_Data>;
+}, Find_Modules_Failure>;
+export type Find_Modules_Failure = {
+    type: 'unmapped_input_paths';
+    source_id_path_data_by_input_path: Map<string, Path_Data>;
+    unmapped_input_paths: string[];
+    reasons: string[];
+} | {
+    type: 'input_directories_with_no_files';
+    source_ids_by_input_path: Map<string, string[]>;
+    source_id_path_data_by_input_path: Map<string, Path_Data>;
+    input_directories_with_no_files: string[];
+    reasons: string[];
+};
+export type Load_Modules_Result<T_Module_Meta extends Module_Meta> = Result<{
+    modules: T_Module_Meta[];
+}, {
+    type: 'load_module_failures';
+    load_module_failures: Load_Module_Failure[];
+    reasons: string[];
+    modules: T_Module_Meta[];
+}>;
+export declare const find_modules: (input_paths: string[], custom_search_fs?: (dir: string, options?: import("./search_fs.js").Search_Fs_Options) => Promise<Map<string, import("./path.js").Path_Stats>>, get_possible_source_ids?: ((input_path: string) => string[]) | undefined, timings?: any) => Promise<Find_Modules_Result>;
+export declare const load_modules: <Module_Type extends Record<string, any>, T_Module_Meta extends Module_Meta<Module_Type>>(source_ids_by_input_path: Map<string, string[]>, load_module_by_id: (source_id: Flavored<string, "Source_Id">) => Promise<Result<{
+    mod: T;
+}, Load_Module_Failure>>, timings?: any) => Promise<Result<{
+    modules: T_Module_Meta_1[];
+}, {
+    type: 'load_module_failures';
+    load_module_failures: Load_Module_Failure[];
+    reasons: string[];
+    modules: T_Module_Meta_1[];
+}>>;

package/dist/modules.js

@@ -0,0 +1,103 @@
+import { red } from 'kleur/colors';
+import { Unreachable_Error } from '@ryanatkn/belt/error.js';
+import { print_error } from '@ryanatkn/belt/print.js';
+import { load_source_path_data_by_input_path, load_source_ids_by_input_path } from './input_path.js';
+import { paths_from_id, print_path, print_path_or_gro_path } from './paths.js';
+import { search_fs } from './search_fs.js';
+export const load_module = async (id, validate) => {
+    let mod;
+    try {
+        mod = await import(id);
+    }
+    catch (err) {
+        return { ok: false, type: 'importFailed', id, error: err };
+    }
+    if (validate && !validate(mod)) {
+        return { ok: false, type: 'invalid', id, mod, validation: validate.name };
+    }
+    return { ok: true, mod: { id, mod } };
+};
+/*
+
+Finds modules from input paths. (see `src/lib/input_path.ts` for more)
+
+*/
+export const find_modules = async (input_paths, custom_search_fs = search_fs, get_possible_source_ids, timings) => {
+    // Check which extension variation works - if it's a directory, prefer others first!
+    const timing_to_map_input_paths = timings?.start('map input paths');
+    const { source_id_path_data_by_input_path, unmapped_input_paths } = await load_source_path_data_by_input_path(input_paths, get_possible_source_ids);
+    timing_to_map_input_paths?.();
+    // Error if any input path could not be mapped.
+    if (unmapped_input_paths.length) {
+        return {
+            ok: false,
+            type: 'unmapped_input_paths',
+            source_id_path_data_by_input_path,
+            unmapped_input_paths,
+            reasons: unmapped_input_paths.map((input_path) => red(`Input path ${print_path_or_gro_path(input_path, paths_from_id(input_path))} cannot be mapped to a file or directory.`)),
+        };
+    }
+    // Find all of the files for any directories.
+    const timing_to_search_fs = timings?.start('find files');
+    const { source_ids_by_input_path, input_directories_with_no_files } = await load_source_ids_by_input_path(source_id_path_data_by_input_path, custom_search_fs);
+    timing_to_search_fs?.();
+    // Error if any input path has no files. (means we have an empty directory)
+    return input_directories_with_no_files.length
+        ? {
+            ok: false,
+            type: 'input_directories_with_no_files',
+            source_id_path_data_by_input_path,
+            source_ids_by_input_path,
+            input_directories_with_no_files,
+            reasons: input_directories_with_no_files.map((input_path) => red(`Input directory ${print_path_or_gro_path(source_id_path_data_by_input_path.get(input_path).id, paths_from_id(input_path))} contains no matching files.`)),
+        }
+        : { ok: true, source_ids_by_input_path, source_id_path_data_by_input_path };
+};
+/*
+
+Load modules by source id.
+
+TODO parallelize, originally it needed to be serial for a specific usecase we no longer have
+
+*/
+export const load_modules = async (source_ids_by_input_path, // TODO maybe make this a flat array and remove `input_path`?
+load_module_by_id, timings) => {
+    const timing_to_load_modules = timings?.start('load modules');
+    const modules = [];
+    const load_module_failures = [];
+    const reasons = [];
+    for (const [input_path, source_ids] of source_ids_by_input_path) {
+        for (const id of source_ids) {
+            const result = await load_module_by_id(id); // eslint-disable-line no-await-in-loop
+            if (result.ok) {
+                modules.push(result.mod);
+            }
+            else {
+                load_module_failures.push(result);
+                switch (result.type) {
+                    case 'importFailed': {
+                        reasons.push(`Module import ${print_path(id, paths_from_id(id))} failed from input ${print_path(input_path, paths_from_id(input_path))}: ${print_error(result.error)}`);
+                        break;
+                    }
+                    case 'invalid': {
+                        // TODO try to make this a good error message for the task case
+                        reasons.push(`Module ${print_path(id, paths_from_id(id))} failed validation '${result.validation}'.`);
+                        break;
+                    }
+                    default:
+                        throw new Unreachable_Error(result);
+                }
+            }
+        }
+    }
+    timing_to_load_modules?.();
+    return load_module_failures.length
+        ? {
+            ok: false,
+            type: 'load_module_failures',
+            load_module_failures,
+            reasons,
+            modules,
+        }
+        : { ok: true, modules };
+};

package/dist/modules.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/modules.test.js

@@ -0,0 +1,182 @@
+import { suite } from 'uvu';
+import * as assert from 'uvu/assert';
+import { resolve, join } from 'node:path';
+import { find_modules, load_modules, load_module } from './modules.js';
+import { get_possible_source_ids } from './input_path.js';
+import { search_fs } from './search_fs.js';
+// TODO if we import directly, svelte-package generates types in `src/fixtures`
+/* eslint-disable no-useless-concat */
+const modTest1 = await import('../fixtures/' + 'test1.foo.js');
+const modTestBaz1 = await import('../fixtures/' + 'baz1/test1.baz.js');
+const modTestBaz2 = await import('../fixtures/' + 'baz2/test2.baz.js');
+/* test__load_module */
+const test__load_module = suite('load_module');
+test__load_module('basic behavior', async () => {
+    const id = resolve('src/fixtures/test1.foo.js');
+    let validated_mod;
+    const result = await load_module(id, ((mod) => {
+        validated_mod = mod;
+        return true;
+    }));
+    assert.ok(result.ok);
+    assert.is(result.mod.id, id);
+    assert.is(result.mod.mod, validated_mod);
+    assert.is(result.mod.mod, modTest1);
+});
+test__load_module('without validation', async () => {
+    const id = resolve('src/fixtures/test1.foo.js');
+    const result = await load_module(id);
+    assert.ok(result.ok);
+    assert.is(result.mod.id, id);
+    assert.is(result.mod.mod, modTest1);
+});
+test__load_module('fails validation', async () => {
+    const id = resolve('src/fixtures/test1.foo.js');
+    let validated_mod;
+    const test_validation = (mod) => {
+        validated_mod = mod;
+        return false;
+    };
+    const result = await load_module(id, test_validation);
+    assert.ok(!result.ok);
+    if (result.type === 'invalid') {
+        assert.is(result.validation, test_validation.name);
+        assert.is(result.id, id);
+        assert.is(result.mod, validated_mod);
+        assert.is(result.mod, modTest1);
+    }
+    else {
+        throw Error('Should be invalid');
+    }
+});
+test__load_module('fails to import', async () => {
+    const id = resolve('foo/test/failure');
+    const result = await load_module(id);
+    assert.ok(!result.ok);
+    if (result.type === 'importFailed') {
+        assert.is(result.id, id);
+        assert.ok(result.error instanceof Error);
+    }
+    else {
+        throw Error('Should fail to import');
+    }
+});
+test__load_module.run();
+/* test__load_module */
+/* test__find_modules */
+const test__find_modules = suite('find_modules');
+test__find_modules('with and without extension', async () => {
+    const path1 = resolve('src/fixtures/test1');
+    const id1 = resolve('src/fixtures/test1.foo.ts');
+    const id2 = resolve('src/fixtures/test2.foo.ts');
+    const result = await find_modules([path1, id2], (id) => search_fs(id, { files_only: false }), (input_path) => get_possible_source_ids(input_path, ['.foo.ts']));
+    assert.ok(result.ok);
+    assert.equal(result.source_ids_by_input_path, new Map([
+        [path1, [id1]],
+        [id2, [id2]],
+    ]));
+    assert.equal(result.source_id_path_data_by_input_path, new Map([
+        [path1, { id: id1, isDirectory: false }],
+        [id2, { id: id2, isDirectory: false }],
+    ]));
+});
+test__find_modules('directory', async () => {
+    const id = resolve('src/fixtures/');
+    const result = await find_modules([id], (id) => search_fs(id, { filter: (path) => path.includes('.foo.') }));
+    assert.ok(result.ok);
+    assert.equal(result.source_ids_by_input_path, new Map([[id, [join(id, 'test1.foo.ts'), join(id, 'test2.foo.ts')]]]));
+    assert.equal(result.source_id_path_data_by_input_path, new Map([[id, { id, isDirectory: true }]]));
+});
+test__find_modules('fail with unmapped_input_paths', async () => {
+    const result = await find_modules([
+        resolve('src/fixtures/bar1'),
+        resolve('src/fixtures/failme1'),
+        resolve('src/fixtures/bar2'),
+        resolve('src/fixtures/failme2'),
+    ], (id) => search_fs(id, { files_only: false }), (input_path) => get_possible_source_ids(input_path, ['.foo.ts']));
+    assert.ok(!result.ok);
+    assert.ok(result.reasons.length);
+    if (result.type === 'unmapped_input_paths') {
+        assert.equal(result.unmapped_input_paths, [
+            resolve('src/fixtures/failme1'),
+            resolve('src/fixtures/failme2'),
+        ]);
+    }
+    else {
+        throw Error('Expected to fail with unmapped_input_paths');
+    }
+});
+test__find_modules('fail with input_directories_with_no_files', async () => {
+    const result = await find_modules([
+        resolve('src/fixtures/baz1'),
+        resolve('src/fixtures/bar1'),
+        resolve('src/fixtures/bar2'),
+        resolve('src/fixtures/baz2'),
+    ], (id) => search_fs(id, { filter: (path) => !path.includes('.bar.'), files_only: false }));
+    assert.ok(!result.ok);
+    assert.ok(result.reasons.length);
+    if (result.type === 'input_directories_with_no_files') {
+        assert.equal(result.input_directories_with_no_files, [
+            resolve('src/fixtures/bar1'),
+            resolve('src/fixtures/bar2'),
+        ]);
+    }
+    else {
+        throw Error('Expected to fail with input_directories_with_no_files');
+    }
+});
+test__find_modules.run();
+/* test__find_modules */
+/* test__load_modules */
+const test__load_modules = suite('load_modules');
+test__load_modules('fail with load_module_failures', async () => {
+    const path_bar1 = resolve('src/fixtures/bar1');
+    const path_bar2 = resolve('src/fixtures/bar2');
+    const path_baz1 = resolve('src/fixtures/baz1');
+    const path_baz2 = resolve('src/fixtures/baz2');
+    const id_bar1 = join(path_bar1, 'test1.bar.ts');
+    const id_bar2 = join(path_bar2, 'test2.bar.ts');
+    const id_baz1 = join(path_baz1, 'test1.baz.ts');
+    const id_baz2 = join(path_baz2, 'test2.baz.ts');
+    const test_validation = ((mod) => mod.bar !== 1);
+    let error;
+    const result = await load_modules(new Map([
+        [path_bar1, [id_bar1, id_bar2]],
+        [path_baz1, [id_baz1, id_baz2]],
+    ]), async (id) => {
+        if (id === id_bar2) {
+            return {
+                ok: false,
+                type: 'importFailed',
+                id,
+                error: (error = new Error('Test failed import')),
+            };
+        }
+        return load_module(id, test_validation);
+    });
+    assert.ok(!result.ok);
+    assert.ok(result.reasons.length);
+    if (result.type !== 'load_module_failures') {
+        throw Error('Expected to fail with load_module_failures');
+    }
+    assert.is(result.load_module_failures.length, 2);
+    const [failure1, failure2] = result.load_module_failures;
+    if (failure1.type !== 'invalid') {
+        throw Error('Expected to fail with invalid');
+    }
+    assert.is(failure1.id, id_bar1);
+    assert.ok(failure1.mod);
+    assert.is(failure1.validation, test_validation.name);
+    if (failure2.type !== 'importFailed') {
+        throw Error('Expected to fail with importFailed');
+    }
+    assert.is(failure2.id, id_bar2);
+    assert.is(failure2.error, error);
+    assert.is(result.modules.length, 2);
+    assert.is(result.modules[0].id, id_baz1);
+    assert.is(result.modules[0].mod, modTestBaz1);
+    assert.is(result.modules[1].id, id_baz2);
+    assert.is(result.modules[1].mod, modTestBaz2);
+});
+test__load_modules.run();
+/* test__load_modules */