lbundle/dist/utils/resolve.js

Small zero-configuration bundler build on top of Rollup.js and SWC for NPM libraries

'use strict';

var resolve = require('../_virtual/resolve.js');
var require$$0$1 = require('resolve');
var require$$1 = require('resolve.exports');
require('./array-fmt.js');
var require$$0 = require('path');
var require$$4 = require('url');
var arrayFmt = require('../_virtual/array-fmt.js');

(function (exports) {
	Object.defineProperty(exports, "__esModule", {
	    value: true
	});
	function _export(target, all) {
	    for(var name in all)Object.defineProperty(target, name, {
	        enumerable: true,
	        get: all[name]
	    });
	}
	_export(exports, {
	    packageFilterBuilder: function() {
	        return packageFilterBuilder;
	    },
	    resolveSync: function() {
	        return resolveSync;
	    }
	});
	const _resolve = /*#__PURE__*/ _interop_require_default(require$$0$1);
	const _resolveexports = require$$1;
	const _arrayfmt = arrayFmt.__exports;
	const _path = /*#__PURE__*/ _interop_require_default(require$$0);
	const _url = require$$4;
	function _interop_require_default(obj) {
	    return obj && obj.__esModule ? obj : {
	        default: obj
	    };
	}
	const baseDir = _path.default.dirname((0, _url.fileURLToPath)(require$$4.pathToFileURL(__filename).toString()));
	const packageFilterBuilder = function() {
	    let path = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : '.', opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
	    const conditions = opts.conditions ?? [
	        'style',
	        'import',
	        'require'
	    ];
	    const fields = opts.fields ?? [
	        'style',
	        'module',
	        'main'
	    ];
	    return (pkg)=>{
	        // Check `exports` fields
	        try {
	            const resolvedExport = (0, _resolveexports.resolve)(pkg, path, {
	                conditions,
	                unsafe: true
	            });
	            if (typeof resolvedExport === 'string') {
	                pkg.main = resolvedExport;
	                return pkg;
	            }
	        } catch  {
	        /* noop */ }
	        // Check independent fields
	        try {
	            const resolvedField = (0, _resolveexports.legacy)(pkg, {
	                fields,
	                browser: false
	            });
	            if (typeof resolvedField === 'string') {
	                pkg.main = resolvedField;
	                return pkg;
	            }
	        } catch  {
	        /* noop */ }
	        return pkg;
	    };
	};
	const defaultOpts = {
	    caller: 'Resolver',
	    basedirs: [
	        baseDir
	    ],
	    extensions: [
	        '.mjs',
	        '.js',
	        '.cjs',
	        '.json'
	    ],
	    preserveSymlinks: true,
	    packageFilter: packageFilterBuilder()
	};
	const resolverSync = function(id) {
	    let options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
	    try {
	        return _resolve.default.sync(id, {
	            ...options,
	            pathFilter: (pkg, _path, relativePath)=>{
	                const result = (0, _resolveexports.resolve)(pkg, relativePath);
	                if (result) return result[0];
	                return '';
	            }
	        });
	    } catch  {
	        return;
	    }
	};
	function resolveSync(ids, userOpts) {
	    const options = {
	        ...defaultOpts,
	        ...userOpts
	    };
	    for (const basedir of options.basedirs){
	        const opts = {
	            ...options,
	            basedir,
	            basedirs: undefined,
	            caller: undefined
	        };
	        for (const id of ids){
	            const resolved = resolverSync(id, opts);
	            if (resolved) return resolved;
	        }
	    }
	    throw new Error(`${options.caller} could not resolve ${(0, _arrayfmt.arrayFmt)(ids)}`);
	} 
} (resolve.__exports));
//# sourceMappingURL=resolve.js.map