locter 0.8.2 → 1.0.0

package/README.MD

@@ -6,7 +6,7 @@
 [![Known Vulnerabilities](https://snyk.io/test/github/Tada5hi/locter/badge.svg?targetFile=package.json)](https://snyk.io/test/github/Tada5hi/locter?targetFile=package.json)
 [![semantic-release: angular](https://img.shields.io/badge/semantic--release-angular-e10079?logo=semantic-release)](https://github.com/semantic-release/semantic-release)
 
-Locter is a library to locate and load a file regarding specific criteria.
+Locter is a library to locate and load a file/modules regarding specific criteria.
 
 **Table of Contents**
 
@@ -40,10 +40,10 @@ The following examples are based on some shared assumptions:
 Locating multiple files will return information about all files matching the pattern.
 
 ```typescript
-import { locateFiles } from 'locter';
+import { locateMany } from 'locter';
 
 (async () => {
-    let files = await locateFiles(
+    let files = await locateMany(
         'files/example.{js,.ts}',
         {
             path: process.cwd()
@@ -58,7 +58,7 @@ import { locateFiles } from 'locter';
     ]
      */
 
-    files = await locateFiles(
+    files = await locateMany(
         'files/*.{js,ts}',
         {
             path: process.cwd()
@@ -76,17 +76,17 @@ import { locateFiles } from 'locter';
 })
 ```
 
-A synchronous variant is also available: `locateFilesSync`
+A synchronous variant is also available: `locateManySync`
 
 **Single**
 
 Locating a single file will return information about the first file matching the pattern.
 
 ```typescript
-import { locateFile } from 'locter';
+import { locate } from 'locter';
 
 (async () => {
-    let file = await locateFile(
+    let file = await locate(
         'files/example.{js,.ts}',
         {
             path: process.cwd()
@@ -100,32 +100,77 @@ import { locateFile } from 'locter';
 })
 ```
 
-A synchronous variant is also available: `locateFileSync`
+A synchronous variant is also available: `locateSync`
 
 ### Loader
 
-The method will load the located file.
+The `load` method can be used to load a file/module in an asynchronous fashion.
+Either a string or the output of the locate/locateSync method can be passed as argument.
 
 ```typescript
-import { loadFile, locateFile } from 'locter';
+import { load, locate } from 'locter';
 
 (async () => {
-    const file = await locateFile(
+    const file = await locate(
         'files/example.{js,.ts}',
         {
             path: process.cwd()
         }
     );
 
-    const content = loadFile(file);
+    let content = await load(file);
+    console.log(content);
+    // ...
+
+    content = await load('...');
+    console.log(content);
+    // ...
+})
+```
+
+There is also a synchronous method called `loadSync` to load files.
+
+```typescript
+import { loadSync, locateSync } from 'locter';
+
+(async () => {
+    const file = await locateSync(
+        'files/example.{js,.ts}',
+        {
+            path: process.cwd()
+        }
+    );
 
+    let content = await loadSync(file);
     console.log(content);
+    // ...
 
+    content = await loadSync('...');
+    console.log(content);
     // ...
 })
 ```
 
-A synchronous variant is also available: `loadFileSync`
+Two loaders are predefined from scratch and already registered:
+- **JsonLoader**: This loader allows to load `.json` files.
+- **ModuleLoader**: This loader allows to load modules with
+  `.js`, `.mjs`, `.mts`, `.cjs`, `.cts`, `.ts` file extensions independent of the environment (cjs or esm).
+
+To register loader for other file types, the function `registerLoader` can be used.
+
+```typescript
+import { LocatorInfo, registerLoader } from 'locter';
+
+registerLoader(['.ext'], {
+    execute(info: LocatorInfo) {
+
+    },
+    executeSync(info: LocatorInfo) {
+
+    }
+})
+```
+
 
 ## License
 

package/dist/index.cjs

@@ -71,7 +71,7 @@ function hasStringProperty(obj, prop) {
  * Author Peter Placzek (tada5hi)
  * For the full copyright and license information,
  * view the LICENSE file that was distributed with this source code.
- */ var _options, _options1;
+ */ var _options;
 function buildLocatorOptions(options) {
     options = options || {};
     options.path = options.path || [];
@@ -79,10 +79,13 @@ function buildLocatorOptions(options) {
     if (options.path.length === 0) {
         options.path.push(process.cwd());
     }
-    (_options = options).soft ?? (_options.soft = true);
-    (_options1 = options).ignore ?? (_options1.ignore = []);
+    (_options = options).ignore ?? (_options.ignore = []);
     return options;
 }
+function isFilePath(input) {
+    const info = path.parse(input);
+    return info.ext !== '';
+}
 function pathToLocatorInfo(input, skipResolve) {
     if (!skipResolve && !path.isAbsolute(input)) {
         input = path.resolve(process.cwd(), input);
@@ -96,7 +99,7 @@ function pathToLocatorInfo(input, skipResolve) {
 }
 
 const globAsync = node_util.promisify(glob);
-async function locateFiles(pattern, options) {
+async function locateMany(pattern, options) {
     options = buildLocatorOptions(options);
     const patterns = Array.isArray(pattern) ? pattern : [
         pattern
@@ -117,7 +120,7 @@ async function locateFiles(pattern, options) {
     }
     return items;
 }
-async function locateFile(pattern, options) {
+async function locate(pattern, options) {
     options = buildLocatorOptions(options);
     const patterns = Array.isArray(pattern) ? pattern : [
         pattern
@@ -136,13 +139,10 @@ async function locateFile(pattern, options) {
             }
         }
     }
-    if (!options.soft) {
-        throw new Error('The file could not be located.');
-    }
     return undefined;
 }
 
-function locateFilesSync(pattern, options) {
+function locateManySync(pattern, options) {
     options = buildLocatorOptions(options);
     const patterns = Array.isArray(pattern) ? pattern : [
         pattern
@@ -163,7 +163,7 @@ function locateFilesSync(pattern, options) {
     }
     return items;
 }
-function locateFileSync(pattern, options) {
+function locateSync(pattern, options) {
     options = buildLocatorOptions(options);
     const patterns = Array.isArray(pattern) ? pattern : [
         pattern
@@ -185,7 +185,13 @@ function locateFileSync(pattern, options) {
     return undefined;
 }
 
-function buildLoaderFilePath(info, withExtension) {
+function buildLoaderFilePath(input, withExtension) {
+    let info;
+    if (typeof input === 'string') {
+        info = pathToLocatorInfo(input);
+    } else {
+        info = input;
+    }
     if (withExtension) {
         return path.join(info.path, info.name) + info.extension;
     }
@@ -224,30 +230,28 @@ function isTsNodeRuntimeEnvironment() {
     return !!process[Symbol.for('ts-node.register.instance')];
 }
 
-class ScriptLoader {
-    async execute(info) {
-        const filePath = buildLoaderFilePath(info);
+class ModuleLoader {
+    async execute(input) {
         let output;
         try {
-            output = await this.load(info);
+            output = await this.load(input);
         } catch (e) {
             // jiti + ts-node
             // issue: https://github.com/nuxt/bridge/issues/228
             if (isTsNodeRuntimeEnvironment()) {
-                output = this.loadSync(info);
+                output = this.loadSync(input);
             } else {
-                output = this.jiti(filePath);
+                output = this.jiti(input);
             }
         }
         return output;
     }
-    executeSync(info) {
-        const filePath = buildLoaderFilePath(info);
+    executeSync(input) {
         let output;
         try {
-            output = this.loadSync(info);
+            output = this.loadSync(input);
         } catch (e) {
-            output = this.jiti(filePath);
+            output = this.jiti(input);
         }
         return output;
     }
@@ -325,17 +329,17 @@ class ScriptLoader {
         }
     }
     constructor(){
-        /*
-        const loaderMap : Record<string, ESLoader> = {
-            '.mjs': 'js',
-            '.js': 'js',
-            '.jsx': 'jsx',
-            '.ts': 'ts',
-            '.tsx': 'tsx',
-        };
-        */ // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
         // @ts-ignore
         this.jiti = createJITI(undefined, {
+            extensions: [
+                '.js',
+                '.mjs',
+                '.mts',
+                '.cjs',
+                '.cts',
+                '.ts'
+            ],
             esmResolve: true
         });
     }
@@ -362,35 +366,59 @@ class JSONLoader {
     }
 }
 
+/*
+ * Copyright (c) 2023.
+ * Author Peter Placzek (tada5hi)
+ * For the full copyright and license information,
+ * view the LICENSE file that was distributed with this source code.
+ */ var LoaderId;
+(function(LoaderId) {
+    LoaderId["MODULE"] = 'module';
+    LoaderId["JSON"] = 'json';
+})(LoaderId || (LoaderId = {}));
+
 class LoaderManager {
-    register(rule) {
-        this.rules.push(rule);
+    register(test, loader) {
+        if (typeof loader !== 'undefined') {
+            this.rules.push({
+                test,
+                loader
+            });
+            return;
+        }
+        this.rules.push(test);
     }
-    async execute(info) {
-        const rule = this.findRule(info);
-        if (!rule) {
+    async execute(input) {
+        const id = this.findLoader(input);
+        if (!id) {
+            const info = pathToLocatorInfo(input);
             throw new Error(`No loader registered for extension: "${info.extension}"`);
         }
-        const loader = this.resolve(rule.loader);
-        return loader.execute(info);
+        const loader = this.resolve(id);
+        return loader.execute(input);
     }
-    executeSync(info) {
-        const rule = this.findRule(info);
-        if (!rule) {
+    executeSync(input) {
+        const id = this.findLoader(input);
+        if (!id) {
+            const info = pathToLocatorInfo(input);
             throw new Error(`No loader registered for extension: ${info.extension || 'unknown'}`);
         }
-        const loader = this.resolve(rule.loader);
-        return loader.executeSync(info);
+        const loader = this.resolve(id);
+        return loader.executeSync(input);
     }
-    findRule(info) {
+    findLoader(input) {
+        if (!isFilePath(input)) {
+            return LoaderId.MODULE;
+        }
+        const info = pathToLocatorInfo(input);
         for(let i = 0; i < this.rules.length; i++){
             const { test  } = this.rules[i];
             if (Array.isArray(test)) {
                 if (test.indexOf(info.extension) !== -1) {
-                    return this.rules[i];
+                    return this.rules[i].loader;
                 }
             } else if (test.test(buildLoaderFilePath(info))) {
-                return this.rules[i];
+                return this.rules[i].loader;
             }
         }
         return undefined;
@@ -403,27 +431,48 @@ class LoaderManager {
         if (typeof id !== 'string') {
             return id;
         }
-        if (this.loaders[id]) {
+        if (Object.prototype.hasOwnProperty.call(this.loaders, id)) {
             return this.loaders[id];
         }
         let loader;
+        // built-in
         switch(id){
-            case 'script':
+            case LoaderId.MODULE:
                 {
-                    loader = new ScriptLoader();
+                    loader = new ModuleLoader();
                     break;
                 }
-            case 'json':
+            case LoaderId.JSON:
                 {
                     loader = new JSONLoader();
                     break;
                 }
+            default:
+                {
+                    const pluginPath = this.normalizePath(id);
+                    const moduleLoader = this.resolve(LoaderId.MODULE);
+                    loader = moduleLoader.executeSync(pluginPath);
+                    break;
+                }
         }
         if (typeof loader !== 'undefined') {
+            this.loaders[id] = loader;
             return loader;
         }
         throw new Error(`The loader ${id} could not be resolved.`);
     }
+    normalizePath(input) {
+        if (path.isAbsolute(input) || input.startsWith('./')) {
+            return input;
+        }
+        if (input.startsWith('module:')) {
+            return input.substring(0, 'module:'.length);
+        }
+        if (!input.startsWith('@')) {
+            return `@locter/${input}`;
+        }
+        return input;
+    }
     constructor(){
         this.loaders = {};
         this.rules = [
@@ -431,23 +480,25 @@ class LoaderManager {
                 test: [
                     '.js',
                     '.mjs',
+                    '.mts',
                     '.cjs',
+                    '.cts',
                     '.ts'
                 ],
-                loader: 'script'
+                loader: LoaderId.MODULE
             },
             {
                 test: [
                     '.json'
                 ],
-                loader: 'json'
+                loader: LoaderId.JSON
             }
         ];
     }
 }
 
 let instance;
-function useLoaderManager() {
+function useLoader() {
     if (typeof instance !== 'undefined') {
         return instance;
     }
@@ -455,45 +506,50 @@ function useLoaderManager() {
     return instance;
 }
 
-async function loadFile(input) {
-    let info;
+function registerLoader(test, loader) {
+    const manager = useLoader();
+    if (typeof loader !== 'undefined') {
+        manager.register(test, loader);
+        return;
+    }
+    manager.register(test);
+}
+async function load(input) {
+    const manager = useLoader();
     if (typeof input === 'string') {
-        info = pathToLocatorInfo(input);
-    } else {
-        info = input;
+        return manager.execute(input);
     }
-    const manager = useLoaderManager();
-    return manager.execute(info);
+    return manager.execute(buildLoaderFilePath(input));
 }
-function loadFileSync(input) {
-    let info;
+function loadSync(input) {
+    const manager = useLoader();
     if (typeof input === 'string') {
-        info = pathToLocatorInfo(input);
-    } else {
-        info = input;
+        return manager.executeSync(input);
     }
-    const manager = useLoaderManager();
-    return manager.executeSync(info);
+    return manager.executeSync(buildLoaderFilePath(input));
 }
 
 exports.JSONLoader = JSONLoader;
-exports.ScriptLoader = ScriptLoader;
+exports.LoaderManager = LoaderManager;
+exports.ModuleLoader = ModuleLoader;
 exports.buildLoaderFilePath = buildLoaderFilePath;
 exports.buildLocatorOptions = buildLocatorOptions;
 exports.getExportItem = getExportItem;
 exports.handleFileLoadError = handleFileLoadError;
 exports.hasOwnProperty = hasOwnProperty;
 exports.hasStringProperty = hasStringProperty;
+exports.isFilePath = isFilePath;
 exports.isJestRuntimeEnvironment = isJestRuntimeEnvironment;
 exports.isObject = isObject;
 exports.isTsNodeRuntimeEnvironment = isTsNodeRuntimeEnvironment;
-exports.loadFile = loadFile;
-exports.loadFileSync = loadFileSync;
-exports.locateFile = locateFile;
-exports.locateFileSync = locateFileSync;
-exports.locateFiles = locateFiles;
-exports.locateFilesSync = locateFilesSync;
+exports.load = load;
+exports.loadSync = loadSync;
+exports.locate = locate;
+exports.locateMany = locateMany;
+exports.locateManySync = locateManySync;
+exports.locateSync = locateSync;
 exports.pathToLocatorInfo = pathToLocatorInfo;
+exports.registerLoader = registerLoader;
 exports.removeFileNameExtension = removeFileNameExtension;
 exports.toArray = toArray;
 //# sourceMappingURL=index.cjs.map