From 6613a9a5e1246f8bbb59d217a04bfe0735608d7f Mon Sep 17 00:00:00 2001 From: Matthias Wright Date: Mon, 13 May 2024 17:45:19 +0800 Subject: [PATCH] feat(js-poc): node:path polyfill --- services/js-poc/src/runtime/js/node_path.js | 653 +++++++++++++++++++ services/js-poc/src/runtime/module_loader.rs | 2 + 2 files changed, 655 insertions(+) create mode 100644 services/js-poc/src/runtime/js/node_path.js diff --git a/services/js-poc/src/runtime/js/node_path.js b/services/js-poc/src/runtime/js/node_path.js new file mode 100644 index 000000000..c49954b95 --- /dev/null +++ b/services/js-poc/src/runtime/js/node_path.js @@ -0,0 +1,653 @@ +// ../../node_modules/@jspm/core/nodelibs/browser/chunk-2eac56ff.js +var exports = {}; +var _dewExec = false; +var _global = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : globalThis; +function dew() { + if (_dewExec) + return exports; + _dewExec = true; + var process2 = exports = {}; + var cachedSetTimeout; + var cachedClearTimeout; + function defaultSetTimout() { + throw new Error("setTimeout has not been defined"); + } + function defaultClearTimeout() { + throw new Error("clearTimeout has not been defined"); + } + (function() { + try { + if (typeof setTimeout === "function") { + cachedSetTimeout = setTimeout; + } else { + cachedSetTimeout = defaultSetTimout; + } + } catch (e) { + cachedSetTimeout = defaultSetTimout; + } + try { + if (typeof clearTimeout === "function") { + cachedClearTimeout = clearTimeout; + } else { + cachedClearTimeout = defaultClearTimeout; + } + } catch (e) { + cachedClearTimeout = defaultClearTimeout; + } + })(); + function runTimeout(fun) { + if (cachedSetTimeout === setTimeout) { + return setTimeout(fun, 0); + } + if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) { + cachedSetTimeout = setTimeout; + return setTimeout(fun, 0); + } + try { + return cachedSetTimeout(fun, 0); + } catch (e) { + try { + return cachedSetTimeout.call(null, fun, 0); + } catch (e2) { + return cachedSetTimeout.call(this || _global, fun, 0); + } + } + } + function runClearTimeout(marker) { + if (cachedClearTimeout === clearTimeout) { + return clearTimeout(marker); + } + if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) { + cachedClearTimeout = clearTimeout; + return clearTimeout(marker); + } + try { + return cachedClearTimeout(marker); + } catch (e) { + try { + return cachedClearTimeout.call(null, marker); + } catch (e2) { + return cachedClearTimeout.call(this || _global, marker); + } + } + } + var queue = []; + var draining = false; + var currentQueue; + var queueIndex = -1; + function cleanUpNextTick() { + if (!draining || !currentQueue) { + return; + } + draining = false; + if (currentQueue.length) { + queue = currentQueue.concat(queue); + } else { + queueIndex = -1; + } + if (queue.length) { + drainQueue(); + } + } + function drainQueue() { + if (draining) { + return; + } + var timeout = runTimeout(cleanUpNextTick); + draining = true; + var len = queue.length; + while (len) { + currentQueue = queue; + queue = []; + while (++queueIndex < len) { + if (currentQueue) { + currentQueue[queueIndex].run(); + } + } + queueIndex = -1; + len = queue.length; + } + currentQueue = null; + draining = false; + runClearTimeout(timeout); + } + process2.nextTick = function(fun) { + var args = new Array(arguments.length - 1); + if (arguments.length > 1) { + for (var i = 1; i < arguments.length; i++) { + args[i - 1] = arguments[i]; + } + } + queue.push(new Item(fun, args)); + if (queue.length === 1 && !draining) { + runTimeout(drainQueue); + } + }; + function Item(fun, array) { + (this || _global).fun = fun; + (this || _global).array = array; + } + Item.prototype.run = function() { + (this || _global).fun.apply(null, (this || _global).array); + }; + process2.title = "browser"; + process2.browser = true; + process2.env = {}; + process2.argv = []; + process2.version = ""; + process2.versions = {}; + function noop() { + } + process2.on = noop; + process2.addListener = noop; + process2.once = noop; + process2.off = noop; + process2.removeListener = noop; + process2.removeAllListeners = noop; + process2.emit = noop; + process2.prependListener = noop; + process2.prependOnceListener = noop; + process2.listeners = function(name) { + return []; + }; + process2.binding = function(name) { + throw new Error("process.binding is not supported"); + }; + process2.cwd = function() { + return "/"; + }; + process2.chdir = function(dir) { + throw new Error("process.chdir is not supported"); + }; + process2.umask = function() { + return 0; + }; + return exports; +} +var process = dew(); +process.platform = "browser"; +process.addListener; +process.argv; +process.binding; +process.browser; +process.chdir; +process.cwd; +process.emit; +process.env; +process.listeners; +process.nextTick; +process.off; +process.on; +process.once; +process.prependListener; +process.prependOnceListener; +process.removeAllListeners; +process.removeListener; +process.title; +process.umask; +process.version; +process.versions; + +// ../../node_modules/@jspm/core/nodelibs/browser/chunk-23dbec7b.js +var exports$1 = {}; +var _dewExec2 = false; +function dew2() { + if (_dewExec2) + return exports$1; + _dewExec2 = true; + var process$1 = process; + function assertPath(path) { + if (typeof path !== "string") { + throw new TypeError("Path must be a string. Received " + JSON.stringify(path)); + } + } + function normalizeStringPosix(path, allowAboveRoot) { + var res = ""; + var lastSegmentLength = 0; + var lastSlash = -1; + var dots = 0; + var code; + for (var i = 0; i <= path.length; ++i) { + if (i < path.length) + code = path.charCodeAt(i); + else if (code === 47) + break; + else + code = 47; + if (code === 47) { + if (lastSlash === i - 1 || dots === 1) + ; + else if (lastSlash !== i - 1 && dots === 2) { + if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) { + if (res.length > 2) { + var lastSlashIndex = res.lastIndexOf("/"); + if (lastSlashIndex !== res.length - 1) { + if (lastSlashIndex === -1) { + res = ""; + lastSegmentLength = 0; + } else { + res = res.slice(0, lastSlashIndex); + lastSegmentLength = res.length - 1 - res.lastIndexOf("/"); + } + lastSlash = i; + dots = 0; + continue; + } + } else if (res.length === 2 || res.length === 1) { + res = ""; + lastSegmentLength = 0; + lastSlash = i; + dots = 0; + continue; + } + } + if (allowAboveRoot) { + if (res.length > 0) + res += "/.."; + else + res = ".."; + lastSegmentLength = 2; + } + } else { + if (res.length > 0) + res += "/" + path.slice(lastSlash + 1, i); + else + res = path.slice(lastSlash + 1, i); + lastSegmentLength = i - lastSlash - 1; + } + lastSlash = i; + dots = 0; + } else if (code === 46 && dots !== -1) { + ++dots; + } else { + dots = -1; + } + } + return res; + } + function _format(sep2, pathObject) { + var dir = pathObject.dir || pathObject.root; + var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || ""); + if (!dir) { + return base; + } + if (dir === pathObject.root) { + return dir + base; + } + return dir + sep2 + base; + } + var posix2 = { + // path.resolve([from ...], to) + resolve: function resolve2() { + var resolvedPath = ""; + var resolvedAbsolute = false; + var cwd; + for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) { + var path; + if (i >= 0) + path = arguments[i]; + else { + if (cwd === void 0) + cwd = process$1.cwd(); + path = cwd; + } + assertPath(path); + if (path.length === 0) { + continue; + } + resolvedPath = path + "/" + resolvedPath; + resolvedAbsolute = path.charCodeAt(0) === 47; + } + resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute); + if (resolvedAbsolute) { + if (resolvedPath.length > 0) + return "/" + resolvedPath; + else + return "/"; + } else if (resolvedPath.length > 0) { + return resolvedPath; + } else { + return "."; + } + }, + normalize: function normalize2(path) { + assertPath(path); + if (path.length === 0) + return "."; + var isAbsolute2 = path.charCodeAt(0) === 47; + var trailingSeparator = path.charCodeAt(path.length - 1) === 47; + path = normalizeStringPosix(path, !isAbsolute2); + if (path.length === 0 && !isAbsolute2) + path = "."; + if (path.length > 0 && trailingSeparator) + path += "/"; + if (isAbsolute2) + return "/" + path; + return path; + }, + isAbsolute: function isAbsolute2(path) { + assertPath(path); + return path.length > 0 && path.charCodeAt(0) === 47; + }, + join: function join2() { + if (arguments.length === 0) + return "."; + var joined; + for (var i = 0; i < arguments.length; ++i) { + var arg = arguments[i]; + assertPath(arg); + if (arg.length > 0) { + if (joined === void 0) + joined = arg; + else + joined += "/" + arg; + } + } + if (joined === void 0) + return "."; + return posix2.normalize(joined); + }, + relative: function relative2(from, to) { + assertPath(from); + assertPath(to); + if (from === to) + return ""; + from = posix2.resolve(from); + to = posix2.resolve(to); + if (from === to) + return ""; + var fromStart = 1; + for (; fromStart < from.length; ++fromStart) { + if (from.charCodeAt(fromStart) !== 47) + break; + } + var fromEnd = from.length; + var fromLen = fromEnd - fromStart; + var toStart = 1; + for (; toStart < to.length; ++toStart) { + if (to.charCodeAt(toStart) !== 47) + break; + } + var toEnd = to.length; + var toLen = toEnd - toStart; + var length = fromLen < toLen ? fromLen : toLen; + var lastCommonSep = -1; + var i = 0; + for (; i <= length; ++i) { + if (i === length) { + if (toLen > length) { + if (to.charCodeAt(toStart + i) === 47) { + return to.slice(toStart + i + 1); + } else if (i === 0) { + return to.slice(toStart + i); + } + } else if (fromLen > length) { + if (from.charCodeAt(fromStart + i) === 47) { + lastCommonSep = i; + } else if (i === 0) { + lastCommonSep = 0; + } + } + break; + } + var fromCode = from.charCodeAt(fromStart + i); + var toCode = to.charCodeAt(toStart + i); + if (fromCode !== toCode) + break; + else if (fromCode === 47) + lastCommonSep = i; + } + var out = ""; + for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) { + if (i === fromEnd || from.charCodeAt(i) === 47) { + if (out.length === 0) + out += ".."; + else + out += "/.."; + } + } + if (out.length > 0) + return out + to.slice(toStart + lastCommonSep); + else { + toStart += lastCommonSep; + if (to.charCodeAt(toStart) === 47) + ++toStart; + return to.slice(toStart); + } + }, + _makeLong: function _makeLong2(path) { + return path; + }, + dirname: function dirname2(path) { + assertPath(path); + if (path.length === 0) + return "."; + var code = path.charCodeAt(0); + var hasRoot = code === 47; + var end = -1; + var matchedSlash = true; + for (var i = path.length - 1; i >= 1; --i) { + code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + end = i; + break; + } + } else { + matchedSlash = false; + } + } + if (end === -1) + return hasRoot ? "/" : "."; + if (hasRoot && end === 1) + return "//"; + return path.slice(0, end); + }, + basename: function basename2(path, ext) { + if (ext !== void 0 && typeof ext !== "string") + throw new TypeError('"ext" argument must be a string'); + assertPath(path); + var start = 0; + var end = -1; + var matchedSlash = true; + var i; + if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) { + if (ext.length === path.length && ext === path) + return ""; + var extIdx = ext.length - 1; + var firstNonSlashEnd = -1; + for (i = path.length - 1; i >= 0; --i) { + var code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else { + if (firstNonSlashEnd === -1) { + matchedSlash = false; + firstNonSlashEnd = i + 1; + } + if (extIdx >= 0) { + if (code === ext.charCodeAt(extIdx)) { + if (--extIdx === -1) { + end = i; + } + } else { + extIdx = -1; + end = firstNonSlashEnd; + } + } + } + } + if (start === end) + end = firstNonSlashEnd; + else if (end === -1) + end = path.length; + return path.slice(start, end); + } else { + for (i = path.length - 1; i >= 0; --i) { + if (path.charCodeAt(i) === 47) { + if (!matchedSlash) { + start = i + 1; + break; + } + } else if (end === -1) { + matchedSlash = false; + end = i + 1; + } + } + if (end === -1) + return ""; + return path.slice(start, end); + } + }, + extname: function extname2(path) { + assertPath(path); + var startDot = -1; + var startPart = 0; + var end = -1; + var matchedSlash = true; + var preDotState = 0; + for (var i = path.length - 1; i >= 0; --i) { + var code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) + startDot = i; + else if (preDotState !== 1) + preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + return ""; + } + return path.slice(startDot, end); + }, + format: function format2(pathObject) { + if (pathObject === null || typeof pathObject !== "object") { + throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject); + } + return _format("/", pathObject); + }, + parse: function parse2(path) { + assertPath(path); + var ret = { + root: "", + dir: "", + base: "", + ext: "", + name: "" + }; + if (path.length === 0) + return ret; + var code = path.charCodeAt(0); + var isAbsolute2 = code === 47; + var start; + if (isAbsolute2) { + ret.root = "/"; + start = 1; + } else { + start = 0; + } + var startDot = -1; + var startPart = 0; + var end = -1; + var matchedSlash = true; + var i = path.length - 1; + var preDotState = 0; + for (; i >= start; --i) { + code = path.charCodeAt(i); + if (code === 47) { + if (!matchedSlash) { + startPart = i + 1; + break; + } + continue; + } + if (end === -1) { + matchedSlash = false; + end = i + 1; + } + if (code === 46) { + if (startDot === -1) + startDot = i; + else if (preDotState !== 1) + preDotState = 1; + } else if (startDot !== -1) { + preDotState = -1; + } + } + if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot + preDotState === 0 || // The (right-most) trimmed path component is exactly '..' + preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) { + if (end !== -1) { + if (startPart === 0 && isAbsolute2) + ret.base = ret.name = path.slice(1, end); + else + ret.base = ret.name = path.slice(startPart, end); + } + } else { + if (startPart === 0 && isAbsolute2) { + ret.name = path.slice(1, startDot); + ret.base = path.slice(1, end); + } else { + ret.name = path.slice(startPart, startDot); + ret.base = path.slice(startPart, end); + } + ret.ext = path.slice(startDot, end); + } + if (startPart > 0) + ret.dir = path.slice(0, startPart - 1); + else if (isAbsolute2) + ret.dir = "/"; + return ret; + }, + sep: "/", + delimiter: ":", + win32: null, + posix: null + }; + posix2.posix = posix2; + exports$1 = posix2; + return exports$1; +} +var exports2 = dew2(); + +// node-modules-polyfills:node:path +var _makeLong = exports2._makeLong; +var basename = exports2.basename; +var delimiter = exports2.delimiter; +var dirname = exports2.dirname; +var extname = exports2.extname; +var format = exports2.format; +var isAbsolute = exports2.isAbsolute; +var join = exports2.join; +var normalize = exports2.normalize; +var parse = exports2.parse; +var posix = exports2.posix; +var relative = exports2.relative; +var resolve = exports2.resolve; +var sep = exports2.sep; +var win32 = exports2.win32; + +// src/index.ts +var src_default = exports2; +export { + src_default as default +}; +//# sourceMappingURL=main.js.map diff --git a/services/js-poc/src/runtime/module_loader.rs b/services/js-poc/src/runtime/module_loader.rs index b1b26058d..c156180a6 100644 --- a/services/js-poc/src/runtime/module_loader.rs +++ b/services/js-poc/src/runtime/module_loader.rs @@ -5,6 +5,7 @@ pub fn node_modules() -> StaticModuleLoader { let zlib_source = include_str!("js/node_zlib.js"); let https_source = include_str!("js/node_https.js"); let stream_source = include_str!("js/node_stream.js"); + let path_source = include_str!("js/node_path.js"); let modules = vec![ ( ModuleSpecifier::parse("node:crypto").unwrap(), @@ -16,6 +17,7 @@ pub fn node_modules() -> StaticModuleLoader { ModuleSpecifier::parse("node:stream").unwrap(), stream_source, ), + (ModuleSpecifier::parse("node:path").unwrap(), path_source), ]; StaticModuleLoader::new(modules) }