@atlaspack/reporter-dev-server 2.14.31 → 2.14.32-dev-ts-project-refs-d30e9754f.0

package/dist/Server.js

@@ -0,0 +1,408 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SOURCES_ENDPOINT = void 0;
+exports.setHeaders = setHeaders;
+const assert_1 = __importDefault(require("assert"));
+const path_1 = __importDefault(require("path"));
+const url_1 = __importDefault(require("url"));
+const utils_1 = require("@atlaspack/utils");
+const serverErrors_1 = __importDefault(require("./serverErrors"));
+const fs_1 = __importDefault(require("fs"));
+const ejs_1 = __importDefault(require("ejs"));
+const connect_1 = __importDefault(require("connect"));
+const serve_handler_1 = __importDefault(require("serve-handler"));
+const http_proxy_middleware_1 = require("http-proxy-middleware");
+const url_2 = require("url");
+const launch_editor_1 = __importDefault(require("launch-editor"));
+const fresh_1 = __importDefault(require("fresh"));
+function setHeaders(res) {
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'GET, HEAD, PUT, PATCH, POST, DELETE');
+    res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Content-Type');
+    res.setHeader('Cache-Control', 'max-age=0, must-revalidate');
+}
+const SLASH_REGEX = /\//g;
+exports.SOURCES_ENDPOINT = '/__parcel_source_root';
+const EDITOR_ENDPOINT = '/__parcel_launch_editor';
+const TEMPLATE_404 = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'templates/404.html'), 'utf8');
+const TEMPLATE_500 = fs_1.default.readFileSync(path_1.default.join(__dirname, '..', 'templates/500.html'), 'utf8');
+class Server {
+    constructor(options) {
+        this.options = options;
+        try {
+            this.rootPath = new url_2.URL(options.publicUrl).pathname;
+        }
+        catch (e) {
+            this.rootPath = options.publicUrl;
+        }
+        this.pending = true;
+        this.pendingRequests = [];
+        this.middleware = [];
+        this.bundleGraph = null;
+        this.requestBundle = null;
+        this.errors = null;
+    }
+    buildStart() {
+        this.pending = true;
+    }
+    buildSuccess(bundleGraph, requestBundle) {
+        this.bundleGraph = bundleGraph;
+        this.requestBundle = requestBundle;
+        this.errors = null;
+        this.pending = false;
+        if (this.pendingRequests.length > 0) {
+            let pendingRequests = this.pendingRequests;
+            this.pendingRequests = [];
+            for (let [req, res] of pendingRequests) {
+                this.respond(req, res);
+            }
+        }
+    }
+    async buildError(options, diagnostics) {
+        this.pending = false;
+        this.errors = await Promise.all(diagnostics.map(async (d) => {
+            let ansiDiagnostic = await (0, utils_1.prettyDiagnostic)(d, options);
+            return {
+                message: (0, utils_1.ansiHtml)(ansiDiagnostic.message),
+                stack: ansiDiagnostic.stack ? (0, utils_1.ansiHtml)(ansiDiagnostic.stack) : null,
+                frames: ansiDiagnostic.frames.map((f) => ({
+                    location: f.location,
+                    code: (0, utils_1.ansiHtml)(f.code),
+                })),
+                hints: ansiDiagnostic.hints.map((hint) => (0, utils_1.ansiHtml)(hint)),
+                documentation: d.documentationURL ?? '',
+            };
+        }));
+    }
+    respond(req, res) {
+        if (this.middleware.some((handler) => handler(req, res)))
+            return;
+        let { pathname, search } = url_1.default.parse(req.originalUrl || req.url);
+        if (pathname == null) {
+            pathname = '/';
+        }
+        if (pathname.startsWith(EDITOR_ENDPOINT) && search) {
+            let query = new url_2.URLSearchParams(search);
+            let file = query.get('file');
+            if (file) {
+                // File location might start with /__parcel_source_root if it came from a source map.
+                if (file.startsWith(exports.SOURCES_ENDPOINT)) {
+                    file = file.slice(exports.SOURCES_ENDPOINT.length + 1);
+                }
+                (0, launch_editor_1.default)(file);
+            }
+            res.end();
+        }
+        else if (this.errors) {
+            return this.send500(req, res);
+        }
+        else if (path_1.default.extname(pathname) === '') {
+            // If the URL doesn't start with the public path, or the URL doesn't
+            // have a file extension, send the main HTML bundle.
+            return this.sendIndex(req, res);
+        }
+        else if (pathname.startsWith(exports.SOURCES_ENDPOINT)) {
+            req.url = pathname.slice(exports.SOURCES_ENDPOINT.length);
+            return this.serve(this.options.inputFS, this.options.projectRoot, req, res, () => this.send404(req, res));
+        }
+        else if (pathname.startsWith(this.rootPath)) {
+            // Otherwise, serve the file from the dist folder
+            req.url =
+                this.rootPath === '/' ? pathname : pathname.slice(this.rootPath.length);
+            if (req.url[0] !== '/') {
+                req.url = '/' + req.url;
+            }
+            return this.serveBundle(req, res, () => this.sendIndex(req, res));
+        }
+        else {
+            return this.send404(req, res);
+        }
+    }
+    sendIndex(req, res) {
+        if (this.bundleGraph) {
+            // If the main asset is an HTML file, serve it
+            let htmlBundleFilePaths = this.bundleGraph
+                .getBundles()
+                .filter((bundle) => path_1.default.posix.extname(bundle.name) === '.html')
+                .map((bundle) => {
+                return `/${(0, utils_1.relativePath)(this.options.distDir, bundle.filePath, false)}`;
+            });
+            let indexFilePath = null;
+            let { pathname: reqURL } = url_1.default.parse(req.originalUrl || req.url);
+            if (!reqURL) {
+                reqURL = '/';
+            }
+            if (htmlBundleFilePaths.length === 1) {
+                indexFilePath = htmlBundleFilePaths[0];
+            }
+            else {
+                let bestMatch = null;
+                for (let bundle of htmlBundleFilePaths) {
+                    let bundleDir = path_1.default.posix.dirname(bundle);
+                    let bundleDirSubdir = bundleDir === '/' ? bundleDir : bundleDir + '/';
+                    let withoutExtension = path_1.default.posix.basename(bundle, path_1.default.posix.extname(bundle));
+                    let isIndex = withoutExtension === 'index';
+                    let matchesIsIndex = null;
+                    if (isIndex &&
+                        (reqURL.startsWith(bundleDirSubdir) || reqURL === bundleDir)) {
+                        // bundle is /bar/index.html and (/bar or something inside of /bar/** was requested was requested)
+                        matchesIsIndex = true;
+                    }
+                    else if (reqURL == path_1.default.posix.join(bundleDir, withoutExtension)) {
+                        // bundle is /bar/foo.html and /bar/foo was requested
+                        matchesIsIndex = false;
+                    }
+                    if (matchesIsIndex != null) {
+                        let depth = bundle.match(SLASH_REGEX)?.length ?? 0;
+                        if (bestMatch == null ||
+                            // This one is more specific (deeper)
+                            bestMatch.depth < depth ||
+                            // This one is just as deep, but the bundle name matches and not just index.html
+                            (bestMatch.depth === depth && bestMatch.isIndex)) {
+                            bestMatch = { bundle, depth, isIndex: matchesIsIndex };
+                        }
+                    }
+                }
+                indexFilePath = bestMatch?.['bundle'] ?? htmlBundleFilePaths[0];
+            }
+            if (indexFilePath) {
+                req.url = indexFilePath;
+                this.serveBundle(req, res, () => this.send404(req, res));
+            }
+            else {
+                this.send404(req, res);
+            }
+        }
+        else {
+            this.send404(req, res);
+        }
+    }
+    async serveBundle(req, res, next) {
+        let bundleGraph = this.bundleGraph;
+        if (bundleGraph) {
+            let { pathname } = url_1.default.parse(req.url);
+            if (!pathname) {
+                this.send500(req, res);
+                return;
+            }
+            let requestedPath = path_1.default.normalize(pathname.slice(1));
+            let bundle = bundleGraph
+                .getBundles()
+                .find((b) => path_1.default.relative(this.options.distDir, b.filePath) === requestedPath);
+            if (!bundle) {
+                this.serveDist(req, res, next);
+                return;
+            }
+            (0, assert_1.default)(this.requestBundle != null);
+            try {
+                await this.requestBundle(bundle);
+            }
+            catch (err) {
+                this.send500(req, res);
+                return;
+            }
+            this.serveDist(req, res, next);
+        }
+        else {
+            this.send404(req, res);
+        }
+    }
+    serveDist(req, res, next) {
+        return this.serve(this.options.outputFS, this.options.distDir, req, res, next);
+    }
+    async serve(fs, root, req, res, next) {
+        if (req.method !== 'GET' && req.method !== 'HEAD') {
+            // method not allowed
+            res.statusCode = 405;
+            res.setHeader('Allow', 'GET, HEAD');
+            res.setHeader('Content-Length', '0');
+            res.end();
+            return;
+        }
+        try {
+            var filePath = url_1.default.parse(req.url).pathname || '';
+            filePath = decodeURIComponent(filePath);
+        }
+        catch (err) {
+            return this.sendError(res, 400);
+        }
+        filePath = path_1.default.normalize('.' + path_1.default.sep + filePath);
+        // malicious path
+        if (filePath.includes(path_1.default.sep + '..' + path_1.default.sep)) {
+            return this.sendError(res, 403);
+        }
+        // join / normalize from the root dir
+        if (!path_1.default.isAbsolute(filePath)) {
+            filePath = path_1.default.normalize(path_1.default.join(root, filePath));
+        }
+        try {
+            var stat = await fs.stat(filePath);
+        }
+        catch (err) {
+            if (err.code === 'ENOENT') {
+                return next(req, res);
+            }
+            return this.sendError(res, 500);
+        }
+        // Fall back to next handler if not a file
+        if (!stat || !stat.isFile()) {
+            return next(req, res);
+        }
+        if ((0, fresh_1.default)(req.headers, { 'last-modified': stat.mtime.toUTCString() })) {
+            res.statusCode = 304;
+            res.end();
+            return;
+        }
+        return (0, serve_handler_1.default)(req, res, {
+            public: root,
+            cleanUrls: false,
+        }, {
+            // @ts-expect-error TS7006
+            lstat: (path) => fs.stat(path),
+            // @ts-expect-error TS7006
+            realpath: (path) => fs.realpath(path),
+            // @ts-expect-error TS7006
+            createReadStream: (path, options) => fs.createReadStream(path, options),
+            // @ts-expect-error TS7006
+            readdir: (path) => fs.readdir(path),
+        });
+    }
+    sendError(res, statusCode) {
+        res.statusCode = statusCode;
+        res.end();
+    }
+    send404(req, res) {
+        res.statusCode = 404;
+        res.end(TEMPLATE_404);
+    }
+    send500(req, res) {
+        res.setHeader('Content-Type', 'text/html; charset=utf-8');
+        res.writeHead(500);
+        if (this.errors) {
+            return res.end(ejs_1.default.render(TEMPLATE_500, {
+                errors: this.errors,
+                hmrOptions: this.options.hmrOptions,
+            }));
+        }
+    }
+    logAccessIfVerbose(req) {
+        this.options.logger.verbose({
+            message: `Request: ${req.headers.host}${req.originalUrl || req.url}`,
+        });
+    }
+    /**
+     * Load proxy table from package.json and apply them.
+     */
+    async applyProxyTable(app) {
+        // avoid skipping project root
+        const fileInRoot = path_1.default.join(this.options.projectRoot, 'index');
+        const configFilePath = await (0, utils_1.resolveConfig)(this.options.inputFS, fileInRoot, [
+            '.proxyrc.cts',
+            '.proxyrc.mts',
+            '.proxyrc.ts',
+            '.proxyrc.cjs',
+            '.proxyrc.mjs',
+            '.proxyrc.js',
+            '.proxyrc',
+            '.proxyrc.json',
+        ], this.options.projectRoot);
+        if (!configFilePath) {
+            return this;
+        }
+        const filename = path_1.default.basename(configFilePath);
+        if (filename === '.proxyrc' || filename === '.proxyrc.json') {
+            let conf = await (0, utils_1.readConfig)(this.options.inputFS, configFilePath);
+            if (!conf) {
+                return this;
+            }
+            let cfg = conf.config;
+            if (typeof cfg !== 'object') {
+                this.options.logger.warn({
+                    message: "Proxy table in '.proxyrc' should be of object type. Skipping...",
+                });
+                return this;
+            }
+            for (const [context, options] of Object.entries(cfg)) {
+                // each key is interpreted as context, and value as middleware options
+                // @ts-expect-error TS2345
+                app.use((0, http_proxy_middleware_1.createProxyMiddleware)(context, options));
+            }
+        }
+        else {
+            let cfg = await this.options.packageManager.require(configFilePath, fileInRoot);
+            if (Object.prototype.toString.call(cfg) === '[object Module]') {
+                cfg = cfg.default;
+            }
+            if (typeof cfg !== 'function') {
+                this.options.logger.warn({
+                    message: `Proxy configuration file '${filename}' should export a function. Skipping...`,
+                });
+                return this;
+            }
+            cfg(app);
+        }
+        return this;
+    }
+    async start() {
+        const finalHandler = (req, res) => {
+            this.logAccessIfVerbose(req);
+            // Wait for the parcelInstance to finish bundling if needed
+            if (this.pending) {
+                this.pendingRequests.push([req, res]);
+            }
+            else {
+                this.respond(req, res);
+            }
+        };
+        const app = (0, connect_1.default)();
+        app.use((req, res, next) => {
+            setHeaders(res);
+            next();
+        });
+        app.use((req, res, next) => {
+            if (req.url === '/__parcel_healthcheck') {
+                res.statusCode = 200;
+                res.write(`${Date.now()}`);
+                res.end();
+            }
+            else {
+                next();
+            }
+        });
+        await this.applyProxyTable(app);
+        app.use(finalHandler);
+        let { server, stop } = await (0, utils_1.createHTTPServer)({
+            cacheDir: this.options.cacheDir,
+            https: this.options.https,
+            inputFS: this.options.inputFS,
+            listener: app,
+            outputFS: this.options.outputFS,
+            host: this.options.host,
+        });
+        this.stopServer = stop;
+        server.listen(this.options.port, this.options.host);
+        // @ts-expect-error TS2322
+        return new Promise((resolve, reject) => {
+            server.once('error', (err) => {
+                this.options.logger.error({
+                    // @ts-expect-error TS2345
+                    message: (0, serverErrors_1.default)(err, this.options.port),
+                });
+                reject(err);
+            });
+            server.once('listening', () => {
+                // @ts-expect-error TS2345
+                resolve(server);
+            });
+        });
+    }
+    async stop() {
+        (0, assert_1.default)(this.stopServer != null);
+        await this.stopServer();
+        this.stopServer = null;
+    }
+}
+exports.default = Server;

package/dist/ServerDataProvider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ServerReporter.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const plugin_1 = require("@atlaspack/plugin");
+const HMRServer_1 = __importDefault(require("./HMRServer"));
+const Server_1 = __importDefault(require("./Server"));
+let servers = new Map();
+let hmrServers = new Map();
+exports.default = new plugin_1.Reporter({
+    async report({ event, options, logger }) {
+        let { serveOptions, hmrOptions } = options;
+        let server = serveOptions ? servers.get(serveOptions.port) : undefined;
+        let hmrPort = (hmrOptions && hmrOptions.port) || (serveOptions && serveOptions.port);
+        let hmrServer = hmrPort ? hmrServers.get(hmrPort) : undefined;
+        switch (event.type) {
+            case 'watchStart': {
+                if (serveOptions) {
+                    // If there's already a server when watching has just started, something
+                    // is wrong.
+                    if (server) {
+                        return logger.warn({
+                            message: 'Trying to create the devserver but it already exists.',
+                        });
+                    }
+                    let serverOptions = {
+                        ...serveOptions,
+                        projectRoot: options.projectRoot,
+                        cacheDir: options.cacheDir,
+                        // Override the target's publicUrl as that is likely meant for production.
+                        // This could be configurable in the future.
+                        publicUrl: serveOptions.publicUrl ?? '/',
+                        inputFS: options.inputFS,
+                        outputFS: options.outputFS,
+                        packageManager: options.packageManager,
+                        logger,
+                        hmrOptions,
+                    };
+                    server = new Server_1.default(serverOptions);
+                    servers.set(serveOptions.port, server);
+                    const devServer = await server.start();
+                    if (hmrOptions && hmrOptions.port === serveOptions.port) {
+                        let hmrServerOptions = {
+                            port: serveOptions.port,
+                            host: hmrOptions.host,
+                            devServer,
+                            // @ts-expect-error TS7006
+                            addMiddleware: (handler) => {
+                                server?.middleware.push(handler);
+                            },
+                            logger,
+                            https: options.serveOptions ? options.serveOptions.https : false,
+                            cacheDir: options.cacheDir,
+                            inputFS: options.inputFS,
+                            outputFS: options.outputFS,
+                        };
+                        hmrServer = new HMRServer_1.default(hmrServerOptions);
+                        hmrServers.set(serveOptions.port, hmrServer);
+                        await hmrServer.start();
+                        return;
+                    }
+                }
+                let port = hmrOptions?.port;
+                if (typeof port === 'number') {
+                    let hmrServerOptions = {
+                        port,
+                        host: hmrOptions?.host,
+                        logger,
+                        https: options.serveOptions ? options.serveOptions.https : false,
+                        cacheDir: options.cacheDir,
+                        inputFS: options.inputFS,
+                        outputFS: options.outputFS,
+                    };
+                    hmrServer = new HMRServer_1.default(hmrServerOptions);
+                    hmrServers.set(port, hmrServer);
+                    await hmrServer.start();
+                }
+                break;
+            }
+            case 'watchEnd':
+                if (serveOptions) {
+                    if (!server) {
+                        return logger.warn({
+                            message: 'Could not shutdown devserver because it does not exist.',
+                        });
+                    }
+                    await server.stop();
+                    servers.delete(server.options.port);
+                }
+                if (hmrOptions && hmrServer) {
+                    await hmrServer.stop();
+                    hmrServers.delete(hmrServer.wss.options.port);
+                }
+                break;
+            case 'buildStart':
+                if (server) {
+                    server.buildStart();
+                }
+                break;
+            case 'buildProgress':
+                if (event.phase === 'bundled' &&
+                    hmrServer &&
+                    // Only send HMR updates before packaging if the built in dev server is used to ensure that
+                    // no stale bundles are served. Otherwise emit it for 'buildSuccess'.
+                    options.serveOptions !== false) {
+                    await hmrServer.emitUpdate(event);
+                }
+                break;
+            case 'buildSuccess':
+                if (serveOptions) {
+                    if (!server) {
+                        return logger.warn({
+                            message: 'Could not send success event to devserver because it does not exist.',
+                        });
+                    }
+                    server.buildSuccess(event.bundleGraph, event.requestBundle);
+                }
+                if (hmrServer && options.serveOptions === false) {
+                    await hmrServer.emitUpdate(event);
+                }
+                break;
+            case 'buildFailure':
+                // On buildFailure watchStart sometimes has not been called yet
+                // do not throw an additional warning here
+                if (server) {
+                    await server.buildError(options, event.diagnostics);
+                }
+                if (hmrServer) {
+                    await hmrServer.emitError(options, event.diagnostics);
+                }
+                break;
+        }
+    },
+});

package/dist/StaticServerDataProvider.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticServerDataProvider = void 0;
+const path_1 = __importDefault(require("path"));
+/**
+ * An implementation of ServerDataProvider provides data from a direct `bundleGraph`
+ * and `requestBundle` function.
+ */
+class StaticServerDataProvider {
+    constructor(distDir) {
+        this.bundleGraph = null;
+        this.requestBundleFn = null;
+        this.distDir = distDir;
+    }
+    getHTMLBundleFilePaths() {
+        return (this.bundleGraph
+            ?.getBundles()
+            .filter((b) => path_1.default.posix.extname(b.name) === '.html')
+            .map((b) => path_1.default.relative(this.distDir, b.filePath)) ?? []);
+    }
+    async requestBundle(requestedPath) {
+        const bundle = this.bundleGraph?.getBundles().find((b) => {
+            const relativePath = path_1.default.relative(this.distDir, b.filePath);
+            return relativePath === requestedPath;
+        });
+        if (!bundle) {
+            return 'not-found';
+        }
+        if (!this.requestBundleFn) {
+            return 'not-found';
+        }
+        await this.requestBundleFn(bundle);
+        return 'requested';
+    }
+    /**
+     * Update the provider with the latest bundle graph and request function.
+     *
+     * This should be called after every successful build so that subsequent requests operate on fresh data.
+     *
+     * @param bundleGraph The most recent bundle graph representing the output of a build.
+     * @param requestBundleFn Function that will be called to (re)build a specific bundle on demand.
+     */
+    update(bundleGraph, requestBundleFn) {
+        this.bundleGraph = bundleGraph;
+        this.requestBundleFn = requestBundleFn;
+    }
+}
+exports.StaticServerDataProvider = StaticServerDataProvider;

package/dist/serverErrors.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = serverErrors;
+const serverErrorList = {
+    EACCES: "You don't have access to bind the server to port {port}.",
+    EADDRINUSE: 'There is already a process listening on port {port}.',
+};
+function serverErrors(err, port) {
+    let desc = `Error: ${err.code} occurred while setting up server on port ${port.toString()}.`;
+    // @ts-expect-error TS7053
+    if (serverErrorList[err.code]) {
+        // @ts-expect-error TS7053
+        desc = serverErrorList[err.code].replace(/{port}/g, port);
+    }
+    return desc;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/reporter-dev-server",
-  "version": "2.14.31",
+  "version": "2.14.32-dev-ts-project-refs-d30e9754f.0",
   "description": "Blazing fast, zero configuration web application bundler",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
@@ -13,7 +13,7 @@
   },
   "main": "./lib/ServerReporter.js",
   "source": "./src/ServerReporter.ts",
-  "types": "./lib/types/ServerReporter.d.ts",
+  "types": "./lib/types/src/ServerReporter.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
@@ -26,9 +26,9 @@
     }
   },
   "dependencies": {
-    "@atlaspack/plugin": "2.14.31",
-    "@atlaspack/utils": "2.19.3",
-    "@atlaspack/types": "2.15.21",
+    "@atlaspack/plugin": "2.14.32-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/types": "2.15.22-dev-ts-project-refs-d30e9754f.0",
+    "@atlaspack/utils": "2.19.4-dev-ts-project-refs-d30e9754f.0",
     "connect": "^3.7.0",
     "ejs": "^3.1.6",
     "fresh": "^0.5.2",
@@ -40,14 +40,14 @@
     "ws": "^7.0.0"
   },
   "devDependencies": {
-    "@atlaspack/babel-preset": "2.14.4",
+    "@atlaspack/babel-preset": "2.14.5-dev-ts-project-refs-d30e9754f.0",
     "@types/connect": "^3.4.38",
     "@types/ejs": "^3.1.5",
     "@types/fresh": "^0.5.3",
     "@types/serve-handler": "^6.1.4"
   },
   "scripts": {
-    "check-ts": "tsc --emitDeclarationOnly --rootDir src",
     "build:lib": "gulp build --gulpfile ../../../gulpfile.js --cwd ."
-  }
+  },
+  "gitHead": "d30e9754f8d423d53261ec54ec87e6fa1299578a"
 }

package/tsconfig.json

@@ -1,4 +1,18 @@
 {
-  "extends": "../../../tsconfig.json",
-  "include": ["src"]
+  "extends": "../../../tsconfig.base.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "composite": true
+  },
+  "references": [
+    {
+      "path": "../../core/plugin/tsconfig.json"
+    },
+    {
+      "path": "../../core/types/tsconfig.json"
+    },
+    {
+      "path": "../../core/utils/tsconfig.json"
+    }
+  ]
 }