@atlaspack/watcher-watchman-js 2.14.5-canary.138 → 2.14.5-canary.139

package/lib/index.d.ts

@@ -0,0 +1,4 @@
+export declare const writeSnapshot: (dir: string, snapshot: string, opts?: import("@parcel/watcher").Options) => Promise<string>;
+export declare const getEventsSince: (dir: string, snapshot: string, opts?: import("@parcel/watcher").Options) => Promise<Array<import("@parcel/watcher").Event>>;
+export declare const subscribe: (dir: string, fn: import("@parcel/watcher").SubscribeCallback, opts?: import("@parcel/watcher").Options) => Promise<import("@parcel/watcher").AsyncSubscription>;
+export declare const unsubscribe: (dir: string, fn: import("@parcel/watcher").SubscribeCallback, opts?: import("@parcel/watcher").Options) => Promise<void>;

package/lib/wrapper.d.ts

@@ -0,0 +1,27 @@
+import * as watchman from 'fb-watchman';
+import type { Options, Event, SubscribeCallback, AsyncSubscription } from '@parcel/watcher';
+type WatchmanArgs = any;
+type FilePath = string;
+type GlobPattern = string;
+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 declare class AtlaspackWatcherWatchmanJS implements Watcher {
+    subscriptionName: string;
+    client: watchman.Client;
+    initPromise: Promise<void> | undefined;
+    constructor();
+    commandAsync(args: WatchmanArgs): Promise<any>;
+    capabilityCheckAsync(args: any): Promise<any>;
+    _init(watchDir: string): Promise<void>;
+    init(watchDir: string): Promise<void>;
+    writeSnapshot(dir: string, snapshot: FilePath): Promise<string>;
+    getEventsSince(dir: string, snapshot: FilePath, opts?: Options): Promise<Event[]>;
+    _createExpression(dir: string, ignore?: Array<FilePath | GlobPattern>): WatchmanArgs;
+    subscribe(dir: string, fn: SubscribeCallback, opts?: Options): Promise<AsyncSubscription>;
+    unsubscribe(dir: string): Promise<void>;
+}
+export {};

package/lib/wrapper.js

@@ -42,7 +42,10 @@ function _logger() {
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 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; }
+// @ts-expect-error TS7016
+
 // Matches the Watcher API from "@parcel/watcher"
+
 class AtlaspackWatcherWatchmanJS {
   constructor() {
     this.subscriptionName = 'parcel-watcher-subscription-' + Date.now();
@@ -51,9 +54,7 @@ class AtlaspackWatcherWatchmanJS {
   commandAsync(args) {
     return new Promise((resolve, reject) => {
       const client = this.client;
-      client.command(args,
-      // $FlowFixMe
-      (err, response) => {
+      client.command(args, (err, response) => {
         if (err) reject(err);else resolve(response);
       });
     });
@@ -61,9 +62,7 @@ class AtlaspackWatcherWatchmanJS {
   capabilityCheckAsync(args) {
     return new Promise((resolve, reject) => {
       const client = this.client;
-      client.capabilityCheck(args,
-      // $FlowFixMe
-      (err, response) => {
+      client.capabilityCheck(args, (err, response) => {
         if (err) reject(err);else resolve(response);
       });
     });

package/package.json

@@ -1,18 +1,22 @@
 {
   "name": "@atlaspack/watcher-watchman-js",
-  "version": "2.14.5-canary.138+eda07caaf",
+  "version": "2.14.5-canary.139+d2fd84977",
   "license": "(MIT OR Apache-2.0)",
-  "main": "lib/index.js",
-  "source": "src/index.js",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@atlaspack/logger": "2.14.5-canary.138+eda07caaf",
-    "@atlaspack/utils": "2.14.5-canary.138+eda07caaf",
+    "@atlaspack/logger": "2.14.5-canary.139+d2fd84977",
+    "@atlaspack/utils": "2.14.5-canary.139+d2fd84977",
     "@parcel/watcher": "^2.4.1",
     "fb-watchman": "^2.0.2"
   },
   "type": "commonjs",
-  "gitHead": "eda07caafd2ebb814bbdbfd0ec12fa63124e213f"
-}
+  "scripts": {
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
+  },
+  "gitHead": "d2fd849770fe6305e9c694bd97b1bd905abd9d94"
+}

package/src/{index.js → index.ts}

@@ -1,6 +1,7 @@
 import {AtlaspackWatcherWatchmanJS} from './wrapper';
+import type {Watcher} from './wrapper';
 
-const wrapper = new AtlaspackWatcherWatchmanJS();
+const wrapper: Watcher = new AtlaspackWatcherWatchmanJS();
 
 export const writeSnapshot = wrapper.writeSnapshot.bind(wrapper);
 export const getEventsSince = wrapper.getEventsSince.bind(wrapper);

package/src/{wrapper.js → wrapper.ts}

@@ -1,6 +1,6 @@
-// @flow
 import * as fs from 'fs';
 import * as path from 'path';
+// @ts-expect-error TS7016
 import * as watchman from 'fb-watchman';
 import {isGlob} from '@atlaspack/utils';
 import logger from '@atlaspack/logger';
@@ -42,39 +42,44 @@ export interface Watcher {
 export class AtlaspackWatcherWatchmanJS implements Watcher {
   subscriptionName: string;
   client: watchman.Client;
-  initPromise: Promise<void> | void;
+  initPromise: Promise<void> | undefined;
 
   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;
-      client.command(
-        args,
-        // $FlowFixMe
-        (err: Error | null | undefined, response: any) => {
+  commandAsync(args: WatchmanArgs): Promise<any> {
+    return new Promise(
+      (
+        resolve: (result: Promise<never>) => void,
+        reject: (error?: any) => void,
+      ) => {
+        const client = this.client;
+        client.command(args, (err: Error | null | undefined, response: any) => {
           if (err) reject(err);
           else resolve(response);
-        },
-      );
-    });
+        });
+      },
+    );
   }
 
   capabilityCheckAsync(args: any): Promise<any> {
-    return new Promise((resolve, reject) => {
-      const client = this.client;
-      client.capabilityCheck(
-        args,
-        // $FlowFixMe
-        (err: Error | null | undefined, response: any) => {
-          if (err) reject(err);
-          else resolve(response);
-        },
-      );
-    });
+    return new Promise(
+      (
+        resolve: (result: Promise<never>) => void,
+        reject: (error?: any) => void,
+      ) => {
+        const client = this.client;
+        client.capabilityCheck(
+          args,
+          (err: Error | null | undefined, response: any) => {
+            if (err) reject(err);
+            else resolve(response);
+          },
+        );
+      },
+    );
   }
   async _init(watchDir: string): Promise<void> {
     await this.capabilityCheckAsync({optional: [], required: []});
@@ -146,17 +151,19 @@ export class AtlaspackWatcherWatchmanJS implements Watcher {
     ];
 
     if (ignore) {
-      const customIgnores = ignore?.map((filePathOrGlob) => {
-        const relative = path.relative(dir, filePathOrGlob);
+      const customIgnores = ignore?.map(
+        (filePathOrGlob: FilePath | GlobPattern) => {
+          const relative = path.relative(dir, filePathOrGlob);
 
-        if (isGlob(filePathOrGlob)) {
-          return ['match', relative, 'wholename'];
-        }
+          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];
-      });
+          // 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);
     }
@@ -190,7 +197,7 @@ export class AtlaspackWatcherWatchmanJS implements Watcher {
       },
     ]);
 
-    this.client.on('subscription', function (resp) {
+    this.client.on('subscription', function (resp: any) {
       if (!resp.files || resp.subscription !== subscriptionName) {
         return;
       }

package/tsconfig.json

@@ -0,0 +1,4 @@
+{
+  "extends": "../../../tsconfig.json",
+  "include": ["src"]
+}