@utoo/web 0.0.1 → 1.0.1

package/esm/webpackLoaders/loaders/lessLoader/index.d.ts

@@ -0,0 +1,3 @@
+export const __esModule: boolean;
+export default lessLoader;
+declare function lessLoader(source: any): Promise<void>;

package/esm/webpackLoaders/loaders/lessLoader/index.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.default = void 0;
+var _path = _interopRequireDefault(require("path"));
+var _options = _interopRequireDefault(require("./options.json"));
+var _utils = require("./utils");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function lessLoader(source) {
+    const options = this.getOptions(_options.default);
+    const callback = this.async();
+    let implementation;
+    try {
+        implementation = (0, _utils.getLessImplementation)(this, options.implementation);
+    }
+    catch (error) {
+        callback(error);
+        return;
+    }
+    if (!implementation) {
+        callback(new Error(`The Less implementation "${options.implementation}" not found`));
+        return;
+    }
+    const lessOptions = (0, _utils.getLessOptions)(this, options, implementation);
+    const useSourceMap = typeof options.sourceMap === "boolean" ? options.sourceMap : this.sourceMap;
+    if (useSourceMap) {
+        lessOptions.sourceMap = {
+            outputSourceFiles: true
+        };
+    }
+    let data = source;
+    if (typeof options.additionalData !== "undefined") {
+        data = typeof options.additionalData === "function" ? `${await options.additionalData(data, this)}` : `${options.additionalData}\n${data}`;
+    }
+    const logger = this.getLogger("less-loader");
+    const loaderContext = this;
+    const loggerListener = {
+        error(message) {
+            // TODO enable by default in the next major release
+            if (options.lessLogAsWarnOrErr) {
+                loaderContext.emitError(new Error(message));
+            }
+            else {
+                logger.error(message);
+            }
+        },
+        warn(message) {
+            // TODO enable by default in the next major release
+            if (options.lessLogAsWarnOrErr) {
+                loaderContext.emitWarning(new Error(message));
+            }
+            else {
+                logger.warn(message);
+            }
+        },
+        info(message) {
+            logger.log(message);
+        },
+        debug(message) {
+            logger.debug(message);
+        }
+    };
+    implementation.logger.addListener(loggerListener);
+    let result;
+    try {
+        result = await implementation.render(data, lessOptions);
+    }
+    catch (error) {
+        if (error.filename) {
+            // `less` returns forward slashes on windows when `webpack` resolver return an absolute windows path in `WebpackFileManager`
+            // Ref: https://github.com/webpack-contrib/less-loader/issues/357
+            this.addDependency(_path.default.normalize(error.filename));
+        }
+        callback((0, _utils.errorFactory)(error));
+        return;
+    }
+    finally {
+        // Fix memory leaks in `less`
+        implementation.logger.removeListener(loggerListener);
+        delete lessOptions.pluginManager.webpackLoaderContext;
+        delete lessOptions.pluginManager;
+    }
+    const { css, imports } = result;
+    imports.forEach(item => {
+        if ((0, _utils.isUnsupportedUrl)(item)) {
+            return;
+        }
+        // `less` return forward slashes on windows when `webpack` resolver return an absolute windows path in `WebpackFileManager`
+        // Ref: https://github.com/webpack-contrib/less-loader/issues/357
+        const normalizedItem = _path.default.normalize(item);
+        // Custom `importer` can return only `contents` so item will be relative
+        if (_path.default.isAbsolute(normalizedItem)) {
+            this.addDependency(normalizedItem);
+        }
+    });
+    let map = typeof result.map === "string" ? JSON.parse(result.map) : result.map;
+    if (map && useSourceMap) {
+        map = (0, _utils.normalizeSourceMap)(map, this.rootContext);
+    }
+    callback(null, css, map);
+}
+var _default = exports.default = lessLoader;

package/esm/webpackLoaders/loaders/lessLoader/options.json

@@ -0,0 +1,67 @@
+{
+    "title": "Less Loader options",
+    "type": "object",
+    "properties": {
+        "lessOptions": {
+            "description": "Options to pass through to `Less`.",
+            "link": "https://github.com/webpack-contrib/less-loader#lessoptions",
+            "anyOf": [
+                {
+                    "type": "object",
+                    "additionalProperties": true
+                },
+                {
+                    "instanceof": "Function"
+                }
+            ]
+        },
+        "additionalData": {
+            "description": "Prepends/Appends `Less` code to the actual entry file.",
+            "link": "https://github.com/webpack-contrib/less-loader#additionalData",
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "instanceof": "Function"
+                }
+            ]
+        },
+        "sourceMap": {
+            "description": "Enables/Disables generation of source maps.",
+            "link": "https://github.com/webpack-contrib/less-loader#sourcemap",
+            "type": "boolean"
+        },
+        "webpackImporter": {
+            "description": "Enables/Disables default `webpack` importer.",
+            "link": "https://github.com/webpack-contrib/less-loader#webpackimporter",
+            "anyOf": [
+                {
+                    "type": "boolean"
+                },
+                {
+                    "type": "string",
+                    "enum": ["only"]
+                }
+            ]
+        },
+        "implementation": {
+            "description": "The implementation of the `Less` to be used.",
+            "link": "https://github.com/webpack-contrib/less-loader#implementation",
+            "anyOf": [
+                {
+                    "type": "string"
+                },
+                {
+                    "type": "object"
+                }
+            ]
+        },
+        "lessLogAsWarnOrErr": {
+            "description": "Less warnings and errors will be webpack warnings or errors.",
+            "link": "https://github.com/webpack-contrib/less-loader#lesslogaswarnorerr",
+            "type": "boolean"
+        }
+    },
+    "additionalProperties": false
+}

package/esm/webpackLoaders/loaders/lessLoader/utils.d.ts

@@ -0,0 +1,14 @@
+export const __esModule: boolean;
+export function errorFactory(error: any): Error;
+export function getLessImplementation(loaderContext: any, implementation: any): any;
+/**
+ * Get the `less` options from the loader context and normalizes its values
+ *
+ * @param {object} loaderContext
+ * @param {object} loaderOptions
+ * @param {object} implementation
+ * @returns {Object}
+ */
+export function getLessOptions(loaderContext: object, loaderOptions: object, implementation: object): Object;
+export function isUnsupportedUrl(url: any): boolean;
+export function normalizeSourceMap(map: any): any;

package/esm/webpackLoaders/loaders/lessLoader/utils.js

@@ -0,0 +1,217 @@
+"use strict";
+const { type } = require("os");
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+exports.errorFactory = errorFactory;
+exports.getLessImplementation = getLessImplementation;
+exports.getLessOptions = getLessOptions;
+exports.isUnsupportedUrl = isUnsupportedUrl;
+exports.normalizeSourceMap = normalizeSourceMap;
+var _path = _interopRequireDefault(require("path"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/* eslint-disable class-methods-use-this */
+const trailingSlash = /[/\\]$/;
+// This somewhat changed in Less 3.x. Now the file name comes without the
+// automatically added extension whereas the extension is passed in as `options.ext`.
+// So, if the file name matches this regexp, we simply ignore the proposed extension.
+const IS_SPECIAL_MODULE_IMPORT = /^~[^/]+$/;
+// `[drive_letter]:\` + `\\[server]\[share_name]\`
+const IS_NATIVE_WIN32_PATH = /^[a-z]:[/\\]|^\\\\/i;
+// Examples:
+// - ~package
+// - ~package/
+// - ~@org
+// - ~@org/
+// - ~@org/package
+// - ~@org/package/
+const IS_MODULE_IMPORT = /^~([^/]+|[^/]+\/|@[^/]+[/][^/]+|@[^/]+\/?|@[^/]+[/][^/]+\/)$/;
+const MODULE_REQUEST_REGEX = /^[^?]*~/;
+/**
+ * Creates a Less plugin that uses webpack's resolving engine that is provided by the loaderContext.
+ *
+ * @param {LoaderContext} loaderContext
+ * @param {object} implementation
+ * @returns {LessPlugin}
+ */
+function createWebpackLessPlugin(loaderContext, implementation) {
+    const lessOptions = loaderContext.getOptions();
+    const resolve = loaderContext.getResolve({
+        dependencyType: "less",
+        conditionNames: ["less", "style", "..."],
+        mainFields: ["less", "style", "main", "..."],
+        mainFiles: ["index", "..."],
+        extensions: [".less", ".css"],
+        preferRelative: true
+    });
+    class WebpackFileManager extends implementation.FileManager {
+        supports(filename) {
+            if (filename[0] === "/" || IS_NATIVE_WIN32_PATH.test(filename)) {
+                return true;
+            }
+            if (this.isPathAbsolute(filename)) {
+                return false;
+            }
+            return true;
+        }
+        // Sync resolving is used at least by the `data-uri` function.
+        // This file manager doesn't know how to do it, so let's delegate it
+        // to the default file manager of Less.
+        // We could probably use loaderContext.resolveSync, but it's deprecated,
+        // see https://webpack.js.org/api/loaders/#this-resolvesync
+        supportsSync() {
+            return false;
+        }
+        async resolveFilename(filename, currentDirectory) {
+            // Less is giving us trailing slashes, but the context should have no trailing slash
+            const context = currentDirectory.replace(trailingSlash, "");
+            let request = filename;
+            // A `~` makes the url an module
+            if (MODULE_REQUEST_REGEX.test(filename)) {
+                request = request.replace(MODULE_REQUEST_REGEX, "");
+            }
+            if (IS_MODULE_IMPORT.test(filename)) {
+                request = request[request.length - 1] === "/" ? request : `${request}/`;
+            }
+            return this.resolveRequests(context, [...new Set([request, filename])]);
+        }
+        async resolveRequests(context, possibleRequests) {
+            if (possibleRequests.length === 0) {
+                return Promise.reject();
+            }
+            let result;
+            try {
+                result = await resolve(context, possibleRequests[0]);
+            }
+            catch (error) {
+                const [, ...tailPossibleRequests] = possibleRequests;
+                if (tailPossibleRequests.length === 0) {
+                    throw error;
+                }
+                result = await this.resolveRequests(context, tailPossibleRequests);
+            }
+            return result;
+        }
+        async loadFile(filename, ...args) {
+            let result;
+            try {
+                if (IS_SPECIAL_MODULE_IMPORT.test(filename) || lessOptions.webpackImporter === "only") {
+                    const error = new Error();
+                    error.type = "Next";
+                    throw error;
+                }
+                result = await super.loadFile(filename, ...args);
+            }
+            catch (error) {
+                if (error.type !== "File" && error.type !== "Next") {
+                    return Promise.reject(error);
+                }
+                try {
+                    result = await this.resolveFilename(filename, ...args);
+                }
+                catch (webpackResolveError) {
+                    error.message = `Less resolver error:\n${error.message}\n\n` + `Webpack resolver error details:\n${webpackResolveError.details}\n\n` + `Webpack resolver error missing:\n${webpackResolveError.missing}\n\n`;
+                    return Promise.reject(error);
+                }
+                loaderContext.addDependency(result);
+                return super.loadFile(result, ...args);
+            }
+            const absoluteFilename = _path.default.isAbsolute(result.filename) ? result.filename : _path.default.resolve(".", result.filename);
+            loaderContext.addDependency(_path.default.normalize(absoluteFilename));
+            return result;
+        }
+    }
+    return {
+        install(lessInstance, pluginManager) {
+            pluginManager.addFileManager(new WebpackFileManager());
+        },
+        minVersion: [3, 0, 0]
+    };
+}
+/**
+ * Get the `less` options from the loader context and normalizes its values
+ *
+ * @param {object} loaderContext
+ * @param {object} loaderOptions
+ * @param {object} implementation
+ * @returns {Object}
+ */
+function getLessOptions(loaderContext, loaderOptions, implementation) {
+    const options = typeof loaderOptions.lessOptions === "function" ? loaderOptions.lessOptions(loaderContext) || {} : loaderOptions.lessOptions || {};
+    const lessOptions = {
+        plugins: [],
+        relativeUrls: true,
+        // We need to set the filename because otherwise our WebpackFileManager will receive an undefined path for the entry
+        filename: loaderContext.resourcePath,
+        ...options
+    };
+    const plugins = lessOptions.plugins.slice();
+    const shouldUseWebpackImporter = typeof loaderOptions.webpackImporter === "boolean" || loaderOptions.webpackImporter === "only" ? loaderOptions.webpackImporter : true;
+    if (shouldUseWebpackImporter) {
+        plugins.unshift(createWebpackLessPlugin(loaderContext, implementation));
+    }
+    plugins.unshift({
+        install(lessProcessor, pluginManager) {
+            // eslint-disable-next-line no-param-reassign
+            pluginManager.webpackLoaderContext = loaderContext;
+            lessOptions.pluginManager = pluginManager;
+        }
+    });
+    lessOptions.plugins = plugins;
+    return lessOptions;
+}
+function isUnsupportedUrl(url) {
+    // Is Windows path
+    if (IS_NATIVE_WIN32_PATH.test(url)) {
+        return false;
+    }
+    // Scheme: https://tools.ietf.org/html/rfc3986#section-3.1
+    // Absolute URL: https://tools.ietf.org/html/rfc3986#section-4.3
+    return /^[a-zA-Z][a-zA-Z\d+\-.]*:/.test(url);
+}
+function normalizeSourceMap(map) {
+    const newMap = map;
+    // map.file is an optional property that provides the output filename.
+    // Since we don't know the final filename in the webpack build chain yet, it makes no sense to have it.
+    // eslint-disable-next-line no-param-reassign
+    delete newMap.file;
+    // eslint-disable-next-line no-param-reassign
+    newMap.sourceRoot = "";
+    // `less` returns POSIX paths, that's why we need to transform them back to native paths.
+    // eslint-disable-next-line no-param-reassign
+    newMap.sources = newMap.sources.map(source => _path.default.normalize(source));
+    return newMap;
+}
+function getLessImplementation(loaderContext, implementation) {
+    let resolvedImplementation = implementation;
+    if (!implementation) {
+        // eslint-disable-next-line import/no-dynamic-require, global-require
+        resolvedImplementation = require("less/lib/less-node/index.js").default;
+    }
+    else if (typeof implementation === "string") {
+        // eslint-disable-next-line import/no-dynamic-require, global-require
+        resolvedImplementation = require(implementation);
+    }
+    // eslint-disable-next-line consistent-return
+    return resolvedImplementation;
+}
+function getFileExcerptIfPossible(error) {
+    if (typeof error.extract === "undefined") {
+        return [];
+    }
+    const excerpt = error.extract.slice(0, 2);
+    const column = Math.max(error.column - 1, 0);
+    if (typeof excerpt[0] === "undefined") {
+        excerpt.shift();
+    }
+    excerpt.push(`${new Array(column).join(" ")}^`);
+    return excerpt;
+}
+function errorFactory(error) {
+    const message = ["\n", ...getFileExcerptIfPossible(error), error.message.charAt(0).toUpperCase() + error.message.slice(1), error.filename ? `      Error in ${_path.default.normalize(error.filename)} (line ${error.line}, column ${error.column})` : ""].join("\n");
+    const obj = new Error(message, {
+        cause: error
+    });
+    obj.stack = null;
+    return obj;
+}

package/esm/webpackLoaders/worker/cjs.d.ts

@@ -0,0 +1,2 @@
+import "systemjs/dist/system.js";
+export declare function cjs(entrypoint: string, importMaps: Record<string, string>): Promise<void>;

package/esm/webpackLoaders/worker/cjs.js

@@ -0,0 +1,77 @@
+import "systemjs/dist/system.js";
+import nodePolyFills from "./nodePolyFills";
+export async function cjs(entrypoint, importMaps) {
+    debugger;
+    await Promise.all(Object.entries(importMaps).map(async ([k, v]) => {
+        if (v.startsWith("http")) {
+            try {
+                const response = await fetch(v);
+                if (response.ok) {
+                    importMaps[k] = await response.text();
+                }
+                else {
+                    console.error(`Failed to fetch loader '${k}' from ${v}: ${response.status} ${response.statusText}`);
+                    delete importMaps[k];
+                }
+            }
+            catch (error) {
+                console.error(`Error fetching loader '${k}' from ${v}:`, error);
+                delete importMaps[k];
+            }
+        }
+    }));
+    Object.assign(importMaps, nodePolyFills);
+    const require = (id) => {
+        let dependency = System.get(id);
+        if (dependency) {
+            return dependency.default;
+        }
+        if (id in nodePolyFills) {
+            // @ts-ignore
+            return nodePolyFills[id];
+        }
+        const moduleCode = importMaps[id];
+        if (!moduleCode) {
+            console.error(`Worker: Dependency ${id} not found in import maps.`);
+            return {};
+        }
+        let finalExports = {};
+        const module = { exports: finalExports };
+        const exports = module.exports;
+        try {
+            new Function('require', 'exports', 'module', moduleCode)(require, exports, module);
+            finalExports = module.exports;
+        }
+        catch (e) {
+            console.error(`Worker: Error executing dependency module ${id}:`, e);
+            throw new Error(`Failed to load CJS dependency ${id}: ${e.message}`);
+        }
+        System.set(id, { default: finalExports });
+        return finalExports;
+    };
+    require.resolve = (request) => request;
+    let entryPointCode;
+    for (const path in importMaps) {
+        const moduleCode = importMaps[path];
+        if (path === entrypoint) {
+            entryPointCode = moduleCode;
+            // FIXME
+            entryPointCode = "self.Buffer = require('buffer').Buffer;" + moduleCode;
+            break;
+        }
+    }
+    if (entryPointCode) {
+        let finalExports = {};
+        const module = { exports: finalExports };
+        const exports = module.exports;
+        try {
+            new Function("require", "exports", "module", entryPointCode)(require, exports, module);
+        }
+        catch (e) {
+            console.error(`Worker: Error executing entry point ${entrypoint}:`, e);
+        }
+    }
+    else {
+        console.warn("Warning: Entry point not found in import maps. No final execution step taken.");
+    }
+}

package/esm/webpackLoaders/worker/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: null;
+export default _default;

package/esm/webpackLoaders/worker/index.js

@@ -0,0 +1,31 @@
+import { cjs } from "./cjs";
+import initWasm, { recvMessageInWorker, recvWorkerRequest, sendTaskMessage, notifyWorkerAck } from "../../utoo";
+const binding = {
+    recvWorkerRequest,
+    recvMessageInWorker,
+    notifyWorkerAck,
+    sendTaskMessage
+};
+self.process = {
+    env: {},
+    cwd: () => self.workerData.cwd
+};
+self.onmessage = async (event) => {
+    let [module, memory, meta] = event.data;
+    await initWasm(module, memory).catch((err) => {
+        console.log(err);
+        throw err;
+    });
+    self.workerData = {
+        poolId: meta.workerData.poolId,
+        workerId: meta.workerData.workerId,
+        cwd: "./",
+        binding,
+        readFile: async (path) => {
+            // TODO: if we want that, just connect to @utoo/web internalProject endpoint port with comlink
+            throw new Error('readFile in loader not supported on browser ');
+        }
+    };
+    cjs(meta.loaderAssets.entrypoint, meta.loaderAssets.importMaps);
+};
+export default null;

package/esm/webpackLoaders/worker/nodePolyFills.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    assert: any;
+    buffer: any;
+    constants: any;
+    fs: {
+        readFile(path: string, options: any, cb: Function): any;
+    };
+    path: any;
+    url: any;
+    util: any;
+    less: any;
+    "less-loader": any;
+};
+export default _default;

package/esm/webpackLoaders/worker/nodePolyFills.js

@@ -0,0 +1,24 @@
+const assert = require('assert');
+const buffer = require('buffer');
+const constants = require('constants');
+const path = require('path');
+const url = require('url');
+const util = require('util');
+const less = require("less/lib/less-node/index.js").default;
+const lessLoader = require("../loaders/lessLoader");
+export default {
+    assert,
+    buffer,
+    constants,
+    fs: {
+        readFile(path, options, cb) {
+            // @ts-ignore
+            return self.workerData.readFile(path, options).then((data) => cb(null, data), (err) => cb(err));
+        },
+    },
+    path,
+    url,
+    util,
+    less,
+    "less-loader": lessLoader
+};

package/esm/webpackLoaders/worker/type.d.ts

@@ -0,0 +1,11 @@
+export interface LoaderRunnerMeta {
+    workerData: {
+        poolId: string;
+        workerId: number;
+        cwd: string;
+    };
+    loaderAssets: {
+        importMaps: Record<string, string>;
+        entrypoint: string;
+    };
+}

package/esm/webpackLoaders/worker/type.js

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