@gadgetinc/ggt 0.3.2 → 0.4.0

package/lib/services/filesync/directory.js

@@ -0,0 +1,253 @@
+/**
+ * DO NOT MODIFY
+ *
+ * Everything in this file also exists in ggt to ensure that this logic
+ * is the same between the two projects.
+ */ import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import fs from "fs-extra";
+import ignore from "ignore";
+import assert from "node:assert";
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { Transform } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import normalizePath from "normalize-path";
+/**
+ * Paths that are always ignored, regardless of the contents of the `.ignore` file.
+ */ export const ALWAYS_IGNORE_PATHS = [
+    ".DS_Store",
+    "node_modules",
+    ".git"
+];
+/**
+ * Paths that are ignored when hashing the directory.
+ *
+ * NOTE: This is the _only_ thing that is allowed to be different between gadget and ggt.
+ */ export const HASHING_IGNORE_PATHS = [
+    ".gadget/sync.json",
+    ".gadget/backup"
+];
+/**
+ * Represents a directory that is being synced.
+ */ export class Directory {
+    /**
+   * Initializes a directory to be synced.
+   *
+   * If the directory does not exist, it is created.
+   *
+   * @param dir - The directory to initialize.
+   * @returns A Promise that resolves to a Directory instance.
+   */ static async init(dir) {
+        const directory = new Directory(dir);
+        await directory.loadIgnoreFile();
+        return directory;
+    }
+    /**
+   * Returns the relative path from this directory to the specified path.
+   *
+   * @param to - The path to which the relative path is calculated.
+   * @returns The relative path from this directory to the specified path.
+   */ relative(to) {
+        if (!path.isAbsolute(to)) {
+            // the filepath is already relative
+            return to;
+        }
+        return path.relative(this.path, to);
+    }
+    /**
+   * Returns the absolute path by resolving the given path segments
+   * relative to the directory path.
+   *
+   * @param pathSegments The path segments to resolve.
+   * @returns The absolute path.
+   */ absolute(...pathSegments) {
+        const result = path.resolve(this.path, ...pathSegments);
+        assert(result.startsWith(this.path), `expected ${result} to be within ${this.path}`);
+        return result;
+    }
+    /**
+   * Similar to {@linkcode relative} in that it converts an absolute
+   * path into a relative one from {@linkcode path}. However, it also
+   * changes any slashes to be posix/unix-like forward slashes,
+   * condenses repeated slashes into a single slash, and adds a trailing
+   * slash if the path is a directory.
+   *
+   * This is used when sending files to Gadget to ensure that the paths
+   * are consistent across platforms.
+   *
+   * @see https://www.npmjs.com/package/normalize-path
+   */ normalize(filepath, isDirectory) {
+        if (path.isAbsolute(filepath)) {
+            filepath = this.relative(filepath);
+        }
+        // true = trim trailing slashes
+        filepath = normalizePath(filepath, true);
+        if (isDirectory) {
+            filepath += "/";
+        }
+        return filepath;
+    }
+    /**
+   * Loads the `.ignore` file in the directory. If the file does not
+   * exist, it is silently ignored.
+   */ async loadIgnoreFile() {
+        this._ignorer = ignore.default();
+        this._ignorer.add(ALWAYS_IGNORE_PATHS);
+        try {
+            const content = await fs.readFile(this.absolute(".ignore"), "utf8");
+            this._ignorer.add(content);
+        } catch (error) {
+            swallowEnoent(error);
+        }
+    }
+    /**
+   * Determines if a file should be ignored based on its filepath.
+   *
+   * @param filepath - The filepath of the file to check.
+   * @returns True if the file should be ignored, false otherwise.
+   */ ignores(filepath) {
+        filepath = this.relative(filepath);
+        if (filepath === "") {
+            // don't ignore the root dir
+            return false;
+        }
+        if (filepath.startsWith("..")) {
+            // anything above the root dir is ignored
+            return true;
+        }
+        // false = don't trim trailing slashes
+        filepath = normalizePath(filepath, false);
+        if (this._isHashing && HASHING_IGNORE_PATHS.some((ignored)=>filepath.startsWith(ignored))) {
+            // special case for hashing
+            return true;
+        }
+        return this._ignorer.ignores(filepath);
+    }
+    /**
+   * Recursively walks through the directory and yields all non-ignored
+   * files and directories within it.
+   *
+   * @yields - The normalized path of each file and directory.
+   */ async *walk({ dir = this.path } = {}) {
+        // don't yield the root directory
+        if (dir !== this.path) {
+            yield this.normalize(dir, true);
+        }
+        for await (const entry of (await fs.opendir(dir))){
+            const filepath = path.join(dir, entry.name);
+            if (this.ignores(filepath)) {
+                continue;
+            }
+            if (entry.isDirectory()) {
+                yield* this.walk({
+                    dir: filepath
+                });
+            } else if (entry.isFile()) {
+                yield this.normalize(filepath, false);
+            }
+        }
+    }
+    /**
+   * Calculates the hash of each file and directory and returns an
+   * object containing the hashes keyed by the normalized file path.
+   *
+   * @returns A Promise that resolves to an object containing the hashes
+   * of each file.
+   */ async hashes() {
+        try {
+            this._isHashing = true;
+            const files = {};
+            for await (const normalizedPath of this.walk()){
+                const absolutePath = this.absolute(normalizedPath);
+                files[normalizedPath] = await hash(absolutePath);
+            }
+            return files;
+        } finally{
+            this._isHashing = false;
+        }
+    }
+    constructor(/**
+     * An absolute path to the directory that is being synced.
+     */ path){
+        _define_property(this, "path", void 0);
+        /**
+   * A gitignore-style file parser used to determine which files to
+   * ignore while syncing.
+   *
+   * @see https://www.npmjs.com/package/ignore
+   */ _define_property(this, "_ignorer", void 0);
+        /**
+   * Whether the directory is currently being hashed.
+   */ _define_property(this, "_isHashing", void 0);
+        this.path = path;
+        this._isHashing = false;
+    }
+}
+/**
+ * Whether the current platform supports Unix-style file permissions.
+ *
+ * Windows doesn't support Unix-style file permissions and all file
+ * permissions retrieved via `node:fs` on Windows are translated to 666
+ * or 444.
+ */ export const supportsPermissions = process.platform === "linux" || process.platform === "darwin";
+/**
+ * Calculates the {@linkcode Hash} of the file or directory at the
+ * specified absolute path.
+ *
+ * @param absolutePath The absolute path to the file or directory.
+ * @returns A Promise that resolves to the {@linkcode Hash} of the file
+ * or directory.
+ */ const hash = async (absolutePath)=>{
+    const sha1 = createHash("sha1");
+    sha1.update(path.basename(absolutePath));
+    const stats = await fs.stat(absolutePath);
+    let permissions;
+    if (supportsPermissions) {
+        // strip everything but the permissions
+        permissions = stats.mode & 0o777;
+    }
+    if (stats.isDirectory()) {
+        return {
+            sha1: sha1.digest("hex"),
+            permissions
+        };
+    }
+    // windows uses CRLF line endings whereas unix uses LF line endings so
+    // we always strip out CR bytes (0x0d) when hashing files. this does
+    // make us blind to files that only differ by CR bytes, but that's a
+    // tradeoff we're willing to make.
+    const removeCR = new Transform({
+        transform (chunk, _encoding, callback) {
+            if (!chunk.includes(0x0d)) {
+                callback(undefined, chunk);
+                return;
+            }
+            const filteredChunk = Buffer.alloc(chunk.length);
+            let i = 0;
+            for (const byte of chunk){
+                if (byte !== 0x0d) {
+                    filteredChunk[i++] = byte;
+                }
+            }
+            callback(undefined, filteredChunk.slice(0, i));
+        }
+    });
+    await pipeline(fs.createReadStream(absolutePath), removeCR, sha1);
+    return {
+        sha1: sha1.digest("hex"),
+        permissions
+    };
+};
+/**
+ * Swallows ENOENT errors and throws any other errors.
+ *
+ * @param error - The error to handle.
+ * @throws The original error if it is not an ENOENT error.
+ */ export const swallowEnoent = (error)=>{
+    if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+        return;
+    }
+    throw error;
+};
+
+//# sourceMappingURL=directory.js.map

package/lib/services/filesync/directory.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/filesync/directory.ts"],"sourcesContent":["/**\n * DO NOT MODIFY\n *\n * Everything in this file also exists in ggt to ensure that this logic\n * is the same between the two projects.\n */\nimport fs from \"fs-extra\";\nimport type { Ignore } from \"ignore\";\nimport ignore from \"ignore\";\nimport assert from \"node:assert\";\nimport { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport { Transform } from \"node:stream\";\nimport { pipeline } from \"node:stream/promises\";\nimport normalizePath from \"normalize-path\";\n\n/**\n * Paths that are always ignored, regardless of the contents of the `.ignore` file.\n */\nexport const ALWAYS_IGNORE_PATHS = [\".DS_Store\", \"node_modules\", \".git\"] as const;\n\n/**\n * Paths that are ignored when hashing the directory.\n *\n * NOTE: This is the _only_ thing that is allowed to be different between gadget and ggt.\n */\nexport const HASHING_IGNORE_PATHS = [\".gadget/sync.json\", \".gadget/backup\"] as const;\n\n/**\n * Represents a directory that is being synced.\n */\nexport class Directory {\n  /**\n   * A gitignore-style file parser used to determine which files to\n   * ignore while syncing.\n   *\n   * @see https://www.npmjs.com/package/ignore\n   */\n  private _ignorer!: Ignore;\n\n  /**\n   * Whether the directory is currently being hashed.\n   */\n  private _isHashing = false;\n\n  private constructor(\n    /**\n     * An absolute path to the directory that is being synced.\n     */\n    readonly path: string,\n  ) {}\n\n  /**\n   * Initializes a directory to be synced.\n   *\n   * If the directory does not exist, it is created.\n   *\n   * @param dir - The directory to initialize.\n   * @returns A Promise that resolves to a Directory instance.\n   */\n  static async init(dir: string): Promise<Directory> {\n    const directory = new Directory(dir);\n    await directory.loadIgnoreFile();\n    return directory;\n  }\n\n  /**\n   * Returns the relative path from this directory to the specified path.\n   *\n   * @param to - The path to which the relative path is calculated.\n   * @returns The relative path from this directory to the specified path.\n   */\n  relative(to: string): string {\n    if (!path.isAbsolute(to)) {\n      // the filepath is already relative\n      return to;\n    }\n\n    return path.relative(this.path, to);\n  }\n\n  /**\n   * Returns the absolute path by resolving the given path segments\n   * relative to the directory path.\n   *\n   * @param pathSegments The path segments to resolve.\n   * @returns The absolute path.\n   */\n  absolute(...pathSegments: string[]): string {\n    const result = path.resolve(this.path, ...pathSegments);\n    assert(result.startsWith(this.path), `expected ${result} to be within ${this.path}`);\n    return result;\n  }\n\n  /**\n   * Similar to {@linkcode relative} in that it converts an absolute\n   * path into a relative one from {@linkcode path}. However, it also\n   * changes any slashes to be posix/unix-like forward slashes,\n   * condenses repeated slashes into a single slash, and adds a trailing\n   * slash if the path is a directory.\n   *\n   * This is used when sending files to Gadget to ensure that the paths\n   * are consistent across platforms.\n   *\n   * @see https://www.npmjs.com/package/normalize-path\n   */\n  normalize(filepath: string, isDirectory: boolean): string {\n    if (path.isAbsolute(filepath)) {\n      filepath = this.relative(filepath);\n    }\n\n    // true = trim trailing slashes\n    filepath = normalizePath(filepath, true);\n\n    if (isDirectory) {\n      filepath += \"/\";\n    }\n\n    return filepath;\n  }\n\n  /**\n   * Loads the `.ignore` file in the directory. If the file does not\n   * exist, it is silently ignored.\n   */\n  async loadIgnoreFile(): Promise<void> {\n    this._ignorer = ignore.default();\n    this._ignorer.add(ALWAYS_IGNORE_PATHS);\n\n    try {\n      const content = await fs.readFile(this.absolute(\".ignore\"), \"utf8\");\n      this._ignorer.add(content);\n    } catch (error) {\n      swallowEnoent(error);\n    }\n  }\n\n  /**\n   * Determines if a file should be ignored based on its filepath.\n   *\n   * @param filepath - The filepath of the file to check.\n   * @returns True if the file should be ignored, false otherwise.\n   */\n  ignores(filepath: string): boolean {\n    filepath = this.relative(filepath);\n    if (filepath === \"\") {\n      // don't ignore the root dir\n      return false;\n    }\n\n    if (filepath.startsWith(\"..\")) {\n      // anything above the root dir is ignored\n      return true;\n    }\n\n    // false = don't trim trailing slashes\n    filepath = normalizePath(filepath, false);\n    if (this._isHashing && HASHING_IGNORE_PATHS.some((ignored) => filepath.startsWith(ignored))) {\n      // special case for hashing\n      return true;\n    }\n\n    return this._ignorer.ignores(filepath);\n  }\n\n  /**\n   * Recursively walks through the directory and yields all non-ignored\n   * files and directories within it.\n   *\n   * @yields - The normalized path of each file and directory.\n   */\n  async *walk({ dir = this.path } = {}): AsyncGenerator<string> {\n    // don't yield the root directory\n    if (dir !== this.path) {\n      yield this.normalize(dir, true);\n    }\n\n    for await (const entry of await fs.opendir(dir)) {\n      const filepath = path.join(dir, entry.name);\n      if (this.ignores(filepath)) {\n        continue;\n      }\n\n      if (entry.isDirectory()) {\n        yield* this.walk({ dir: filepath });\n      } else if (entry.isFile()) {\n        yield this.normalize(filepath, false);\n      }\n    }\n  }\n\n  /**\n   * Calculates the hash of each file and directory and returns an\n   * object containing the hashes keyed by the normalized file path.\n   *\n   * @returns A Promise that resolves to an object containing the hashes\n   * of each file.\n   */\n  async hashes(): Promise<Hashes> {\n    try {\n      this._isHashing = true;\n      const files = {} as Hashes;\n\n      for await (const normalizedPath of this.walk()) {\n        const absolutePath = this.absolute(normalizedPath);\n        files[normalizedPath] = await hash(absolutePath);\n      }\n\n      return files;\n    } finally {\n      this._isHashing = false;\n    }\n  }\n}\n\n/**\n * Key/value pairs where the key is the normalized path and the value is\n * the result of {@linkcode hash} for that path.\n */\nexport type Hashes = Record<string, Hash>;\n\nexport type Hash = {\n  /**\n   * The SHA-1 hash of the file or directory.\n   *\n   * If the path points to a directory, the hash is calculated based on\n   * the directory's basename. If the path points to a file, the hash is\n   * calculated based on the file's basename and contents.\n   */\n  sha1: string;\n\n  /**\n   * The Unix-style file permissions of the file or directory, or\n   * undefined if the platform that generated this hash doesn't support\n   * them.\n   *\n   * @example 0o644\n   * @see supportsPermissions\n   */\n  permissions?: number;\n};\n\n/**\n * Whether the current platform supports Unix-style file permissions.\n *\n * Windows doesn't support Unix-style file permissions and all file\n * permissions retrieved via `node:fs` on Windows are translated to 666\n * or 444.\n */\nexport const supportsPermissions = process.platform === \"linux\" || process.platform === \"darwin\";\n\n/**\n * Calculates the {@linkcode Hash} of the file or directory at the\n * specified absolute path.\n *\n * @param absolutePath The absolute path to the file or directory.\n * @returns A Promise that resolves to the {@linkcode Hash} of the file\n * or directory.\n */\nconst hash = async (absolutePath: string): Promise<Hash> => {\n  const sha1 = createHash(\"sha1\");\n  sha1.update(path.basename(absolutePath));\n\n  const stats = await fs.stat(absolutePath);\n\n  let permissions;\n  if (supportsPermissions) {\n    // strip everything but the permissions\n    permissions = stats.mode & 0o777;\n  }\n\n  if (stats.isDirectory()) {\n    return { sha1: sha1.digest(\"hex\"), permissions };\n  }\n\n  // windows uses CRLF line endings whereas unix uses LF line endings so\n  // we always strip out CR bytes (0x0d) when hashing files. this does\n  // make us blind to files that only differ by CR bytes, but that's a\n  // tradeoff we're willing to make.\n  const removeCR = new Transform({\n    transform(chunk: Buffer, _encoding, callback) {\n      if (!chunk.includes(0x0d)) {\n        callback(undefined, chunk);\n        return;\n      }\n\n      const filteredChunk = Buffer.alloc(chunk.length);\n      let i = 0;\n      for (const byte of chunk) {\n        if (byte !== 0x0d) {\n          filteredChunk[i++] = byte;\n        }\n      }\n\n      callback(undefined, filteredChunk.slice(0, i));\n    },\n  });\n\n  await pipeline(fs.createReadStream(absolutePath), removeCR, sha1);\n\n  return { sha1: sha1.digest(\"hex\"), permissions };\n};\n\n/**\n * Swallows ENOENT errors and throws any other errors.\n *\n * @param error - The error to handle.\n * @throws The original error if it is not an ENOENT error.\n */\nexport const swallowEnoent = (error: unknown): void => {\n  if (error && typeof error === \"object\" && \"code\" in error && error.code === \"ENOENT\") {\n    return;\n  }\n  throw error;\n};\n"],"names":["fs","ignore","assert","createHash","path","Transform","pipeline","normalizePath","ALWAYS_IGNORE_PATHS","HASHING_IGNORE_PATHS","Directory","init","dir","directory","loadIgnoreFile","relative","to","isAbsolute","absolute","pathSegments","result","resolve","startsWith","normalize","filepath","isDirectory","_ignorer","default","add","content","readFile","error","swallowEnoent","ignores","_isHashing","some","ignored","walk","entry","opendir","join","name","isFile","hashes","files","normalizedPath","absolutePath","hash","supportsPermissions","process","platform","sha1","update","basename","stats","stat","permissions","mode","digest","removeCR","transform","chunk","_encoding","callback","includes","undefined","filteredChunk","Buffer","alloc","length","i","byte","slice","createReadStream","code"],"mappings":"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"}

package/lib/services/filesync/error.js

@@ -0,0 +1,67 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { CLIError, IsBug } from "../output/report.js";
+import { sprint } from "../output/sprint.js";
+export class YarnNotFoundError extends CLIError {
+    render() {
+        return sprint`
+      Yarn must be installed to sync your application. You can install it by running:
+
+        $ npm install --global yarn
+
+      For more information, see: https://classic.yarnpkg.com/en/docs/install
+    `;
+    }
+    constructor(){
+        super("Yarn not found");
+        _define_property(this, "isBug", IsBug.NO);
+    }
+}
+export class InvalidSyncFileError extends CLIError {
+    render() {
+        return sprint`
+      We failed to find a ".gadget/sync.json" file in this directory:
+
+        ${this.dir}
+
+      If you're running 'ggt sync' for the first time, we recommend
+      using a gadget specific directory like this:
+
+        ggt sync ~/gadget/${this.app} --app ${this.app}
+
+      If you're certain you want to sync the contents of that directory
+      to Gadget, run 'ggt sync' again with the {bold --force} flag:
+
+        ggt sync ${this.dir} --app ${this.app} --force
+    `;
+    }
+    constructor(dir, app){
+        super("The .gadget/sync.json file was invalid or not found");
+        _define_property(this, "dir", void 0);
+        _define_property(this, "app", void 0);
+        _define_property(this, "isBug", void 0);
+        this.dir = dir;
+        this.app = app;
+        this.isBug = IsBug.NO;
+        this.app ??= "<name of app>";
+    }
+}
+export class TooManySyncAttemptsError extends CLIError {
+    render() {
+        return sprint`
+        We synced your local files with Gadget ${this.attempts} times, but
+        your local filesystem is still out of sync.
+
+        Make sure no one else is editing files in the Gadget editor
+        and try again.
+    `;
+    }
+    constructor(attempts){
+        super(`Failed to sync files after ${attempts} attempts.`);
+        _define_property(this, "attempts", void 0);
+        _define_property(this, "isBug", void 0);
+        this.attempts = attempts;
+        this.isBug = IsBug.MAYBE;
+    }
+}
+
+//# sourceMappingURL=error.js.map

package/lib/services/filesync/error.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/filesync/error.ts"],"sourcesContent":["import { CLIError, IsBug } from \"../output/report.js\";\nimport { sprint } from \"../output/sprint.js\";\n\nexport class YarnNotFoundError extends CLIError {\n  isBug = IsBug.NO;\n\n  constructor() {\n    super(\"Yarn not found\");\n  }\n\n  protected render(): string {\n    return sprint`\n      Yarn must be installed to sync your application. You can install it by running:\n\n        $ npm install --global yarn\n\n      For more information, see: https://classic.yarnpkg.com/en/docs/install\n    `;\n  }\n}\n\nexport class InvalidSyncFileError extends CLIError {\n  isBug = IsBug.NO;\n\n  constructor(\n    readonly dir: string,\n    readonly app: string | undefined,\n  ) {\n    super(\"The .gadget/sync.json file was invalid or not found\");\n    this.app ??= \"<name of app>\";\n  }\n\n  protected render(): string {\n    return sprint`\n      We failed to find a \".gadget/sync.json\" file in this directory:\n\n        ${this.dir}\n\n      If you're running 'ggt sync' for the first time, we recommend\n      using a gadget specific directory like this:\n\n        ggt sync ~/gadget/${this.app} --app ${this.app}\n\n      If you're certain you want to sync the contents of that directory\n      to Gadget, run 'ggt sync' again with the {bold --force} flag:\n\n        ggt sync ${this.dir} --app ${this.app} --force\n    `;\n  }\n}\n\nexport class TooManySyncAttemptsError extends CLIError {\n  isBug = IsBug.MAYBE;\n\n  constructor(readonly attempts: number) {\n    super(`Failed to sync files after ${attempts} attempts.`);\n  }\n\n  protected render(): string {\n    return sprint`\n        We synced your local files with Gadget ${this.attempts} times, but\n        your local filesystem is still out of sync.\n\n        Make sure no one else is editing files in the Gadget editor\n        and try again.\n    `;\n  }\n}\n"],"names":["CLIError","IsBug","sprint","YarnNotFoundError","render","constructor","isBug","NO","InvalidSyncFileError","dir","app","TooManySyncAttemptsError","attempts","MAYBE"],"mappings":";AAAA,SAASA,QAAQ,EAAEC,KAAK,QAAQ,sBAAsB;AACtD,SAASC,MAAM,QAAQ,sBAAsB;AAE7C,OAAO,MAAMC,0BAA0BH;IAO3BI,SAAiB;QACzB,OAAOF,MAAM,CAAC;;;;;;IAMd,CAAC;IACH;IAZAG,aAAc;QACZ,KAAK,CAAC;QAHRC,uBAAAA,SAAQL,MAAMM,EAAE;IAIhB;AAWF;AAEA,OAAO,MAAMC,6BAA6BR;IAW9BI,SAAiB;QACzB,OAAOF,MAAM,CAAC;;;QAGV,EAAE,IAAI,CAACO,GAAG,CAAC;;;;;0BAKO,EAAE,IAAI,CAACC,GAAG,CAAC,OAAO,EAAE,IAAI,CAACA,GAAG,CAAC;;;;;iBAKtC,EAAE,IAAI,CAACD,GAAG,CAAC,OAAO,EAAE,IAAI,CAACC,GAAG,CAAC;IAC1C,CAAC;IACH;IAxBAL,YACE,AAASI,GAAW,EACpB,AAASC,GAAuB,CAChC;QACA,KAAK,CAAC;;;QANRJ,uBAAAA,SAAAA,KAAAA;aAGWG,MAAAA;aACAC,MAAAA;aAJXJ,QAAQL,MAAMM,EAAE;QAOd,IAAI,CAACG,GAAG,KAAK;IACf;AAmBF;AAEA,OAAO,MAAMC,iCAAiCX;IAOlCI,SAAiB;QACzB,OAAOF,MAAM,CAAC;+CAC6B,EAAE,IAAI,CAACU,QAAQ,CAAC;;;;;IAK3D,CAAC;IACH;IAZAP,YAAY,AAASO,QAAgB,CAAE;QACrC,KAAK,CAAC,CAAC,2BAA2B,EAAEA,SAAS,UAAU,CAAC;;QAH1DN,uBAAAA,SAAAA,KAAAA;aAEqBM,WAAAA;aAFrBN,QAAQL,MAAMY,KAAK;IAInB;AAWF"}

package/lib/services/filesync/file.js

@@ -0,0 +1,3 @@
+export { };
+
+//# sourceMappingURL=file.js.map

package/lib/services/filesync/file.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/services/filesync/file.ts"],"sourcesContent":["import type { FileSyncEncoding } from \"../../__generated__/graphql.js\";\n\nexport type File = {\n  path: string;\n  oldPath?: string | null;\n  mode: number;\n  content: string;\n  encoding: FileSyncEncoding;\n};\n"],"names":[],"mappings":"AAEA,WAME"}