@parcel/watcher-watchman-js 2.12.1-canary.3335

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017-present Devon Govett
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,7 @@
+# @parcel/watcher-watchman-js
+
+This package acts as a drop-in replacements for `@parcel/watcher` but only for
+watchman. It's a temporary workaround for some bugs and feature gaps with the
+C++ watchman client.
+
+It is intended to replace `@parcel/watcher` within node_modules.

package/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.writeSnapshot = exports.unsubscribe = exports.subscribe = exports.getEventsSince = void 0;
+var _wrapper = require("./wrapper");
+const wrapper = new _wrapper.ParcelWatcherWatchmanJS();
+const writeSnapshot = exports.writeSnapshot = wrapper.writeSnapshot.bind(wrapper);
+const getEventsSince = exports.getEventsSince = wrapper.getEventsSince.bind(wrapper);
+const subscribe = exports.subscribe = wrapper.subscribe.bind(wrapper);
+const unsubscribe = exports.unsubscribe = wrapper.unsubscribe.bind(wrapper);

package/lib/index.js.map

@@ -0,0 +1 @@
+{"mappings":"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","sources":["packages/utils/parcel-watcher-watchman-js/src/index.js","packages/utils/parcel-watcher-watchman-js/src/wrapper.js"],"sourcesContent":["import {ParcelWatcherWatchmanJS} from './wrapper';\n\nconst wrapper = new ParcelWatcherWatchmanJS();\n\nexport const writeSnapshot = wrapper.writeSnapshot.bind(wrapper);\nexport const getEventsSince = wrapper.getEventsSince.bind(wrapper);\nexport const subscribe = wrapper.subscribe.bind(wrapper);\nexport const unsubscribe = wrapper.unsubscribe.bind(wrapper);\n","// @flow\nimport * as fs from 'fs';\nimport * as path from 'path';\nimport * as watchman from 'fb-watchman';\nimport {isGlob} from '@parcel/utils';\nimport type {\n  Options,\n  Event,\n  SubscribeCallback,\n  AsyncSubscription,\n} from '@parcel/watcher';\n\ntype WatchmanArgs = any;\ntype FilePath = string;\ntype GlobPattern = string;\n\n// Matches the Watcher API from \"@parcel/watcher\"\nexport interface Watcher {\n  getEventsSince(\n    dir: FilePath,\n    snapshot: FilePath,\n    opts?: Options,\n  ): Promise<Array<Event>>;\n  subscribe(\n    dir: FilePath,\n    fn: SubscribeCallback,\n    opts?: Options,\n  ): Promise<AsyncSubscription>;\n  unsubscribe(\n    dir: FilePath,\n    fn: SubscribeCallback,\n    opts?: Options,\n  ): Promise<void>;\n  writeSnapshot(\n    dir: FilePath,\n    snapshot: FilePath,\n    opts?: Options,\n  ): Promise<FilePath>;\n}\n\nexport class ParcelWatcherWatchmanJS implements Watcher {\n  subscriptionName: string;\n  client: watchman.Client;\n\n  constructor() {\n    this.subscriptionName = 'parcel-watcher-subscription-' + Date.now();\n    this.client = new watchman.Client();\n  }\n\n  commandAsync(args: any[]): Promise<any> {\n    return new Promise((resolve, reject) => {\n      const client = this.client;\n      // $FlowFixMe\n      client.command(args, (err: Error | null | undefined, response: any) => {\n        if (err) reject(err);\n        else resolve(response);\n      });\n    });\n  }\n\n  // Types should match @parcel/watcher/index.js.flow\n  async writeSnapshot(dir: string, snapshot: FilePath): Promise<string> {\n    const response = await this.commandAsync(['clock', dir]);\n    fs.writeFileSync(snapshot, response.clock, {\n      encoding: 'utf-8',\n    });\n    return response.clock;\n  }\n\n  async getEventsSince(\n    dir: string,\n    snapshot: FilePath,\n    opts?: Options,\n  ): Promise<Event[]> {\n    const clock = fs.readFileSync(snapshot, {\n      encoding: 'utf-8',\n    });\n\n    const response = await this.commandAsync([\n      'query',\n      dir,\n      {\n        expression: this._createExpression(dir, opts?.ignore),\n        fields: ['name', 'mode', 'exists', 'new'],\n        since: clock,\n      },\n    ]);\n\n    return (response.files || []).map((file: any) => ({\n      path: file.name,\n      type: file.new ? 'create' : file.exists ? 'update' : 'delete',\n    }));\n  }\n\n  _createExpression(\n    dir: string,\n    ignore?: Array<FilePath | GlobPattern>,\n  ): WatchmanArgs {\n    const ignores = [\n      // Ignore the watchman cookie\n      ['match', '.watchman-cookie-*'],\n      // Ignore directory changes as they are just noise\n      ['type', 'd'],\n    ];\n\n    if (ignore) {\n      const customIgnores = ignore?.map(filePathOrGlob => {\n        const relative = path.relative(dir, filePathOrGlob);\n\n        if (isGlob(filePathOrGlob)) {\n          return ['match', relative, 'wholename'];\n        }\n\n        // If pattern is not a glob, then assume it's a directory.\n        // Ignoring single files is not currently supported\n        return ['dirname', relative];\n      });\n\n      ignores.push(...customIgnores);\n    }\n\n    return ['not', ['anyof', ...ignores]];\n  }\n\n  async subscribe(\n    dir: string,\n    fn: SubscribeCallback,\n    opts?: Options,\n  ): Promise<AsyncSubscription> {\n    const {subscriptionName} = this;\n    const {clock} = await this.commandAsync(['clock', dir]);\n\n    await this.commandAsync([\n      'subscribe',\n      dir,\n      subscriptionName,\n      {\n        // `defer` can be used here if you want to pause the\n        // notification stream until something has finished.\n        //\n        // https://facebook.github.io/watchman/docs/cmd/subscribe#defer\n        // defer: ['my-company-example'],\n        expression: this._createExpression(dir, opts?.ignore),\n        fields: ['name', 'mode', 'exists', 'new'],\n        since: clock,\n      },\n    ]);\n\n    this.client.on('subscription', function (resp) {\n      if (!resp.files || resp.subscription !== subscriptionName) {\n        return;\n      }\n\n      fn(\n        null /* err */,\n        resp.files.map((file: any) => {\n          return {\n            path: path.join(dir, file.name),\n            type: file.new ? 'create' : file.exists ? 'update' : 'delete',\n          };\n        }),\n      );\n    });\n\n    const unsubscribe = async () => {\n      await this.commandAsync(['unsubscribe', dir, subscriptionName]);\n    };\n\n    return {\n      unsubscribe,\n    };\n  }\n\n  async unsubscribe(dir: string): Promise<void> {\n    await this.commandAsync(['unsubscribe', dir, this.subscriptionName]);\n  }\n}\n"],"names":["ParcelWatcherWatchmanJS","wrapper","writeSnapshot","bind","getEventsSince","subscribe","unsubscribe","fs","path","watchman","isGlob","constructor","subscriptionName","Date","now","client","Client","commandAsync","args","Promise","resolve","reject","command","err","response","dir","snapshot","writeFileSync","clock","encoding","opts","readFileSync","expression","_createExpression","ignore","fields","since","files","map","file","name","type","new","exists","ignores","customIgnores","filePathOrGlob","relative","push","fn","on","resp","subscription","join"],"version":3,"file":"index.js.map"}

package/lib/wrapper.js

@@ -0,0 +1,135 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ParcelWatcherWatchmanJS = void 0;
+function fs() {
+  const data = _interopRequireWildcard(require("fs"));
+  fs = function () {
+    return data;
+  };
+  return data;
+}
+function path() {
+  const data = _interopRequireWildcard(require("path"));
+  path = function () {
+    return data;
+  };
+  return data;
+}
+function watchman() {
+  const data = _interopRequireWildcard(require("fb-watchman"));
+  watchman = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@parcel/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+// Matches the Watcher API from "@parcel/watcher"
+class ParcelWatcherWatchmanJS {
+  constructor() {
+    this.subscriptionName = 'parcel-watcher-subscription-' + Date.now();
+    this.client = new (watchman().Client)();
+  }
+  commandAsync(args) {
+    return new Promise((resolve, reject) => {
+      const client = this.client;
+      // $FlowFixMe
+      client.command(args, (err, response) => {
+        if (err) reject(err);else resolve(response);
+      });
+    });
+  }
+
+  // Types should match @parcel/watcher/index.js.flow
+  async writeSnapshot(dir, snapshot) {
+    const response = await this.commandAsync(['clock', dir]);
+    fs().writeFileSync(snapshot, response.clock, {
+      encoding: 'utf-8'
+    });
+    return response.clock;
+  }
+  async getEventsSince(dir, snapshot, opts) {
+    const clock = fs().readFileSync(snapshot, {
+      encoding: 'utf-8'
+    });
+    const response = await this.commandAsync(['query', dir, {
+      expression: this._createExpression(dir, opts === null || opts === void 0 ? void 0 : opts.ignore),
+      fields: ['name', 'mode', 'exists', 'new'],
+      since: clock
+    }]);
+    return (response.files || []).map(file => ({
+      path: file.name,
+      type: file.new ? 'create' : file.exists ? 'update' : 'delete'
+    }));
+  }
+  _createExpression(dir, ignore) {
+    const ignores = [
+    // Ignore the watchman cookie
+    ['match', '.watchman-cookie-*'],
+    // Ignore directory changes as they are just noise
+    ['type', 'd']];
+    if (ignore) {
+      const customIgnores = ignore === null || ignore === void 0 ? void 0 : ignore.map(filePathOrGlob => {
+        const relative = path().relative(dir, filePathOrGlob);
+        if ((0, _utils().isGlob)(filePathOrGlob)) {
+          return ['match', relative, 'wholename'];
+        }
+
+        // If pattern is not a glob, then assume it's a directory.
+        // Ignoring single files is not currently supported
+        return ['dirname', relative];
+      });
+      ignores.push(...customIgnores);
+    }
+    return ['not', ['anyof', ...ignores]];
+  }
+  async subscribe(dir, fn, opts) {
+    const {
+      subscriptionName
+    } = this;
+    const {
+      clock
+    } = await this.commandAsync(['clock', dir]);
+    await this.commandAsync(['subscribe', dir, subscriptionName, {
+      // `defer` can be used here if you want to pause the
+      // notification stream until something has finished.
+      //
+      // https://facebook.github.io/watchman/docs/cmd/subscribe#defer
+      // defer: ['my-company-example'],
+      expression: this._createExpression(dir, opts === null || opts === void 0 ? void 0 : opts.ignore),
+      fields: ['name', 'mode', 'exists', 'new'],
+      since: clock
+    }]);
+    this.client.on('subscription', function (resp) {
+      if (!resp.files || resp.subscription !== subscriptionName) {
+        return;
+      }
+      fn(null /* err */, resp.files.map(file => {
+        return {
+          path: path().join(dir, file.name),
+          type: file.new ? 'create' : file.exists ? 'update' : 'delete'
+        };
+      }));
+    });
+    const unsubscribe = async () => {
+      await this.commandAsync(['unsubscribe', dir, subscriptionName]);
+    };
+    return {
+      unsubscribe
+    };
+  }
+  async unsubscribe(dir) {
+    await this.commandAsync(['unsubscribe', dir, this.subscriptionName]);
+  }
+}
+exports.ParcelWatcherWatchmanJS = ParcelWatcherWatchmanJS;

package/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "@parcel/watcher-watchman-js",
+  "version": "2.12.1-canary.3335+1afd7f7d2",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "source": "src/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@parcel/utils": "2.0.0-canary.1712+1afd7f7d2",
+    "fb-watchman": "^2.0.2"
+  },
+  "devDependencies": {
+    "@parcel/watcher": "^2.4.1"
+  },
+  "gitHead": "1afd7f7d2894679880ff0d2b644a61d8734f3f89"
+}

package/src/index.js

@@ -0,0 +1,8 @@
+import {ParcelWatcherWatchmanJS} from './wrapper';
+
+const wrapper = new ParcelWatcherWatchmanJS();
+
+export const writeSnapshot = wrapper.writeSnapshot.bind(wrapper);
+export const getEventsSince = wrapper.getEventsSince.bind(wrapper);
+export const subscribe = wrapper.subscribe.bind(wrapper);
+export const unsubscribe = wrapper.unsubscribe.bind(wrapper);

package/src/wrapper.js

@@ -0,0 +1,177 @@
+// @flow
+import * as fs from 'fs';
+import * as path from 'path';
+import * as watchman from 'fb-watchman';
+import {isGlob} from '@parcel/utils';
+import type {
+  Options,
+  Event,
+  SubscribeCallback,
+  AsyncSubscription,
+} from '@parcel/watcher';
+
+type WatchmanArgs = any;
+type FilePath = string;
+type GlobPattern = string;
+
+// Matches the Watcher API from "@parcel/watcher"
+export interface Watcher {
+  getEventsSince(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts?: Options,
+  ): Promise<Array<Event>>;
+  subscribe(
+    dir: FilePath,
+    fn: SubscribeCallback,
+    opts?: Options,
+  ): Promise<AsyncSubscription>;
+  unsubscribe(
+    dir: FilePath,
+    fn: SubscribeCallback,
+    opts?: Options,
+  ): Promise<void>;
+  writeSnapshot(
+    dir: FilePath,
+    snapshot: FilePath,
+    opts?: Options,
+  ): Promise<FilePath>;
+}
+
+export class ParcelWatcherWatchmanJS implements Watcher {
+  subscriptionName: string;
+  client: watchman.Client;
+
+  constructor() {
+    this.subscriptionName = 'parcel-watcher-subscription-' + Date.now();
+    this.client = new watchman.Client();
+  }
+
+  commandAsync(args: any[]): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const client = this.client;
+      // $FlowFixMe
+      client.command(args, (err: Error | null | undefined, response: any) => {
+        if (err) reject(err);
+        else resolve(response);
+      });
+    });
+  }
+
+  // Types should match @parcel/watcher/index.js.flow
+  async writeSnapshot(dir: string, snapshot: FilePath): Promise<string> {
+    const response = await this.commandAsync(['clock', dir]);
+    fs.writeFileSync(snapshot, response.clock, {
+      encoding: 'utf-8',
+    });
+    return response.clock;
+  }
+
+  async getEventsSince(
+    dir: string,
+    snapshot: FilePath,
+    opts?: Options,
+  ): Promise<Event[]> {
+    const clock = fs.readFileSync(snapshot, {
+      encoding: 'utf-8',
+    });
+
+    const response = await this.commandAsync([
+      'query',
+      dir,
+      {
+        expression: this._createExpression(dir, opts?.ignore),
+        fields: ['name', 'mode', 'exists', 'new'],
+        since: clock,
+      },
+    ]);
+
+    return (response.files || []).map((file: any) => ({
+      path: file.name,
+      type: file.new ? 'create' : file.exists ? 'update' : 'delete',
+    }));
+  }
+
+  _createExpression(
+    dir: string,
+    ignore?: Array<FilePath | GlobPattern>,
+  ): WatchmanArgs {
+    const ignores = [
+      // Ignore the watchman cookie
+      ['match', '.watchman-cookie-*'],
+      // Ignore directory changes as they are just noise
+      ['type', 'd'],
+    ];
+
+    if (ignore) {
+      const customIgnores = ignore?.map(filePathOrGlob => {
+        const relative = path.relative(dir, filePathOrGlob);
+
+        if (isGlob(filePathOrGlob)) {
+          return ['match', relative, 'wholename'];
+        }
+
+        // If pattern is not a glob, then assume it's a directory.
+        // Ignoring single files is not currently supported
+        return ['dirname', relative];
+      });
+
+      ignores.push(...customIgnores);
+    }
+
+    return ['not', ['anyof', ...ignores]];
+  }
+
+  async subscribe(
+    dir: string,
+    fn: SubscribeCallback,
+    opts?: Options,
+  ): Promise<AsyncSubscription> {
+    const {subscriptionName} = this;
+    const {clock} = await this.commandAsync(['clock', dir]);
+
+    await this.commandAsync([
+      'subscribe',
+      dir,
+      subscriptionName,
+      {
+        // `defer` can be used here if you want to pause the
+        // notification stream until something has finished.
+        //
+        // https://facebook.github.io/watchman/docs/cmd/subscribe#defer
+        // defer: ['my-company-example'],
+        expression: this._createExpression(dir, opts?.ignore),
+        fields: ['name', 'mode', 'exists', 'new'],
+        since: clock,
+      },
+    ]);
+
+    this.client.on('subscription', function (resp) {
+      if (!resp.files || resp.subscription !== subscriptionName) {
+        return;
+      }
+
+      fn(
+        null /* err */,
+        resp.files.map((file: any) => {
+          return {
+            path: path.join(dir, file.name),
+            type: file.new ? 'create' : file.exists ? 'update' : 'delete',
+          };
+        }),
+      );
+    });
+
+    const unsubscribe = async () => {
+      await this.commandAsync(['unsubscribe', dir, subscriptionName]);
+    };
+
+    return {
+      unsubscribe,
+    };
+  }
+
+  async unsubscribe(dir: string): Promise<void> {
+    await this.commandAsync(['unsubscribe', dir, this.subscriptionName]);
+  }
+}