syncodemayo 1.0.9 → 2.0.0

package/lib/Client.js

@@ -1,85 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Log = require("./Log");
-const path_1 = require("path");
-const Config_1 = require("./Config");
-const TargetServer_1 = require("./TargetServer");
-const ConfigSchema_1 = require("./ConfigSchema");
-const Filelist_1 = require("./Filelist");
-class Client {
-    constructor(preferredPath) {
-        this.hasConfig = null;
-        this.DEFAULT_CONFIG = "syncodemayo.json";
-        this._path = preferredPath;
-        this.whenReady = new Promise((resolve) => {
-            Config_1.loadConfigFile(preferredPath)
-                .then((config) => {
-                this.config = config;
-                this._path = this.config._path;
-                this.hasConfig = true;
-                resolve(this);
-            })
-                .catch((err) => {
-                if (err.message.indexOf('Schema Error'))
-                    this.loadError = err;
-                if (err.message.indexOf('JSON'))
-                    this.parseError = err;
-                this.hasConfig = false;
-                resolve(this);
-            });
-        });
-    }
-    get hasError() {
-        return !!this.loadError || !!this.parseError;
-    }
-    setVerbosity(level) {
-        Log.setLogLevel(level);
-    }
-    createConfig(preferredPath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const path = path_1.resolve(preferredPath || this._path || this.DEFAULT_CONFIG);
-            const alreadyExists = yield Filelist_1.localFileExists(path);
-            if (alreadyExists) {
-                throw new Error("Config already exists at " + path);
-            }
-            Filelist_1.writeLocalFile(path, JSON.stringify(ConfigSchema_1.DefaultConfig, null, 2));
-            return true;
-        });
-    }
-    getTargetNames() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.hasConfig === null)
-                throw new Error("Config not loaded yet.");
-            if (this.hasConfig === false) {
-                if (this.hasError) {
-                    const error = this.loadError || this.parseError;
-                    throw error;
-                }
-                else {
-                    throw new Error("This directory has no SyncoDeMayo config.");
-                }
-            }
-            return Object.keys(this.config.targets).filter(name => this.config.targets[name].enabled);
-        });
-    }
-    getTargetConfig(name) {
-        return Config_1.resolveTarget(this.config, name);
-    }
-    getTargetServer(name) {
-        return TargetServer_1.TargetServer.create(this.config, name);
-    }
-    static create(configPath) {
-        const client = new Client(configPath);
-        return client.whenReady;
-    }
-}
-exports.Client = Client;
-//# sourceMappingURL=Client.js.map

package/lib/Config.d.ts

@@ -1,32 +0,0 @@
-export interface IConfig {
-    local: ILocalConfig;
-    targets: {
-        [name: string]: ITargetConfig;
-    };
-    _path?: string;
-}
-export interface ILocalConfig {
-    path: string;
-    files: string;
-    exclude: string[];
-    defaultTarget: string;
-    deleteRemoteFiles: boolean;
-}
-export interface ITargetConfig {
-    host: string;
-    user: string;
-    pass?: string;
-    path: string;
-    port: number;
-    cache: string;
-    prompt?: boolean | string;
-    _name: string;
-    enabled?: boolean;
-    type?: string;
-}
-/**
- * Sending nulll as the preferred path will result in scan for the config
- */
-export declare function loadConfigFile(preferredPath?: string): Promise<IConfig>;
-export declare function resolvePassword(targetConfig: ITargetConfig): string;
-export declare function resolveTarget(config: IConfig, name: string | ITargetConfig | undefined): ITargetConfig;

package/lib/Config.js

@@ -1,114 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path_1 = require("path");
-const ConfigSchema_1 = require("./ConfigSchema");
-const Filelist_1 = require("./Filelist");
-const stripJsonComments = require("strip-json-comments");
-function evalConfigFromFile(pathname) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof pathname !== 'string')
-            throw new Error(`Path must be a string. Got a ${typeof pathname}`);
-        const fullpath = path_1.resolve("./" + pathname);
-        if (!Filelist_1.localFileExists(fullpath))
-            throw new Error("SKIP");
-        const source = yield Filelist_1.readLocalFile(fullpath, false);
-        const data = JSON.parse(stripJsonComments(source));
-        // const data = require(fullpath) as IConfig
-        if (typeof data === 'object')
-            data._path = fullpath;
-        return data;
-    });
-}
-/**
- * Sending nulll as the preferred path will result in scan for the config
- */
-function loadConfigFile(preferredPath) {
-    const loadingPromise = new Promise((resolve, reject) => {
-        const potentialConfigs = (!!preferredPath)
-            ? [preferredPath]
-            : [
-                'syncodemayo.json',
-                '.syncodemayo.json',
-                'syncodemayo.js',
-                '.syncodemayo.js',
-                '.syncodemayo',
-                'sync-config.json',
-                'sync-config.js',
-                '.sync-config',
-            ];
-        const tryLoading = (path) => {
-            if (!!path) {
-                evalConfigFromFile(path)
-                    .then(resolve)
-                    .catch(err => {
-                    if (err.message === "SKIP")
-                        tryLoading(potentialConfigs.shift());
-                    else
-                        reject(err);
-                });
-            }
-            else {
-                reject(new Error("Local config not found."));
-            }
-        };
-        // Kick off config loading...
-        tryLoading(potentialConfigs.shift());
-    });
-    return loadingPromise
-        .then(ConfigSchema_1.validateConfig)
-        .then(massageConfigData);
-}
-exports.loadConfigFile = loadConfigFile;
-function massageConfigData(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        config.local.files = config.local.files || '**/**';
-        config.local.exclude = config.local.exclude || [];
-        config.local.defaultTarget = config.local.defaultTarget || "staging";
-        config.local.deleteRemoteFiles = config.local.deleteRemoteFiles === true;
-        Object.keys(config.targets).forEach(name => {
-            const target = config.targets[name];
-            target._name = name;
-            target.port = target.port || 21;
-            target.cache = target.cache || ".synco-filelist";
-            target.enabled = target.enabled !== false;
-            target.type = target.type || 'ftp'; // Will support more eventually
-            if (typeof target.prompt === 'undefined')
-                target.prompt = true;
-        });
-        return config;
-    });
-}
-function resolvePassword(targetConfig) {
-    const password = targetConfig.pass || process.env[`${targetConfig._name.toUpperCase()}_PWD`];
-    if (typeof password === 'undefined') {
-        throw new Error("Cannot find password for target: " + targetConfig._name);
-    }
-    return password;
-}
-exports.resolvePassword = resolvePassword;
-function resolveTarget(config, name) {
-    if (typeof name === 'undefined')
-        name = config.local.defaultTarget;
-    if (typeof name === 'object')
-        return name;
-    const lookingFor = name;
-    const targetName = Object.keys(config.targets).find(namedTarget => (lookingFor.toUpperCase() === config.targets[namedTarget]._name.toUpperCase()));
-    if (!targetName) {
-        throw new Error("Target '" + name + "' not found.");
-    }
-    const target = config.targets[targetName];
-    if (!target.enabled) {
-        throw new Error("Target '" + name + "' not enabled.");
-    }
-    return target;
-}
-exports.resolveTarget = resolveTarget;
-//# sourceMappingURL=Config.js.map

package/lib/ConfigSchema.d.ts

@@ -1,7 +0,0 @@
-import { IConfig } from './Config';
-import * as joi from 'joi';
-export declare const localSchema: joi.ObjectSchema;
-export declare const targetSchema: joi.ObjectSchema;
-export declare const configSchema: joi.ObjectSchema;
-export declare function validateConfig(config: IConfig): Promise<IConfig>;
-export declare const DefaultConfig: any;

package/lib/ConfigSchema.js

@@ -1,65 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const joi = require("joi");
-exports.localSchema = joi.object({
-    path: joi.string().required(),
-    files: joi.string(),
-    exclude: joi.array().items(joi.string()),
-    defaultTarget: joi.string(),
-    deleteRemoteFiles: joi.bool(),
-});
-exports.targetSchema = joi.object({
-    host: joi.string().required(),
-    user: joi.string().required(),
-    path: joi.string().required(),
-    pass: joi.string(),
-    port: joi.number(),
-    cache: joi.string(),
-    prompt: joi.alternatives([joi.bool(), joi.string()]),
-    enabled: joi.bool(),
-    // For future use...
-    type: joi.string(),
-});
-exports.configSchema = joi.object({
-    local: exports.localSchema.required(),
-    targets: joi.object().pattern(/.*/, exports.targetSchema).required()
-}).unknown(true);
-function validateConfig(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const result = exports.configSchema.validate(config);
-        if (!!result.error)
-            throw new Error("Config Schema Error: " + result.error.message);
-        return config;
-    });
-}
-exports.validateConfig = validateConfig;
-exports.DefaultConfig = {
-    local: {
-        path: "public",
-        files: "**/**",
-        exclude: ["**/*.map", "**/.DS_Store", "**/.git*"],
-        defaultTarget: "staging"
-    },
-    targets: {
-        staging: {
-            path: "Example/www/stage",
-            host: "www.example.com",
-            user: "USERNAME"
-        },
-        production: {
-            path: "Example/www",
-            host: "www.example.com",
-            user: "USERNAME",
-            prompt: "This will upload to PRODUCTION! Are you sure?"
-        }
-    }
-};
-//# sourceMappingURL=ConfigSchema.js.map

package/lib/Connection.d.ts

@@ -1,14 +0,0 @@
-import { ITargetConfig } from './Config';
-export declare class Connection {
-    private _ftpConn;
-    constructor(host: string, port: number, user: string, pass: string);
-    getRemoteFile(filename: string): Promise<string>;
-    remoteDirectoryExists(pathname: string): Promise<boolean>;
-    remoteFileExists(remotePath: string): Promise<boolean>;
-    putBuffer(buff: any, remotePath: string): Promise<boolean>;
-    putContent(content: string, remotePath: string): Promise<boolean>;
-    putFile(filename: string, remotePath: string): Promise<string>;
-    deleteRemoteFile(remotePath: string): Promise<boolean>;
-    close(): void;
-    static create(target: ITargetConfig): Connection;
-}

package/lib/Connection.js

@@ -1,112 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const JsFtp = require("jsftp");
-const JsFtpMkDirP = require("jsftp-mkdirp");
-const Log = require("./Log");
-const Config_1 = require("./Config");
-const Filelist_1 = require("./Filelist");
-const Ftp = JsFtpMkDirP(JsFtp);
-/*
-  TODO: Extract FTP from the connection to allow other connection types.. File/SFTP/S3/whatever
-*/
-// interface IRemoteConnection {
-//   get(filepath): Promise<string>
-//   put(filepath): Promise<boolean>
-// }
-class Connection {
-    constructor(host, port, user, pass) {
-        // log("Connecting to FTP:", { host, port, user, pass: `(${pass.length} chars)` })
-        this._ftpConn = new Ftp({ host, port, user, pass });
-        process.on('beforeExit', () => {
-            this.close(); // Ensure all connections are close when the app exits
-        });
-    }
-    getRemoteFile(filename) {
-        return new Promise((resolve, reject) => {
-            let content = "";
-            Log.log(" <-", filename);
-            this._ftpConn.get(filename, function (err, socket) {
-                if (err != null) {
-                    return reject(err);
-                }
-                socket.on("data", (d) => content += d.toString());
-                socket.on('error', (err) => {
-                    Log.urgent("Retrieval error.", err);
-                    reject(err);
-                });
-                socket.on("close", (connErr) => {
-                    if (connErr)
-                        reject(connErr);
-                    else
-                        resolve(content);
-                });
-                socket.resume();
-            });
-        });
-    }
-    remoteDirectoryExists(pathname) {
-        return new Promise((resolve, reject) => {
-            this._ftpConn.mkdirp(pathname, (err) => resolve(!err));
-        });
-    }
-    remoteFileExists(remotePath) {
-        return new Promise((resolve, reject) => {
-            this._ftpConn.raw.size(remotePath, (err, size) => resolve(!err));
-        });
-    }
-    putBuffer(buff, remotePath) {
-        return new Promise((resolve, reject) => {
-            Log.log(" ->", remotePath);
-            this._ftpConn.put(buff, remotePath, (err) => {
-                if (err)
-                    reject(err);
-                else
-                    resolve(true);
-            });
-        });
-    }
-    putContent(content, remotePath) {
-        return this.putBuffer(new Buffer(content), remotePath);
-    }
-    putFile(filename, remotePath) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const buffer = yield Filelist_1.readLocalFile(filename, true);
-            yield this.putBuffer(buffer, remotePath);
-            return remotePath;
-        });
-    }
-    deleteRemoteFile(remotePath) {
-        return new Promise((resolve, reject) => {
-            Log.log("  x", remotePath);
-            this._ftpConn.raw('dele', remotePath, function (err, data) {
-                if (err)
-                    Log.log("Error removing", remotePath, err.message);
-                if (err)
-                    resolve(false);
-                else
-                    resolve(true);
-            });
-        });
-    }
-    close() {
-        const conn = this._ftpConn;
-        conn && conn.raw && conn.raw.quit && conn.raw.quit((err, data) => {
-            if (err != null)
-                Log.urgent(err);
-        });
-    }
-    static create(target) {
-        const pass = Config_1.resolvePassword(target);
-        return new Connection(target.host, target.port, target.user, pass);
-    }
-}
-exports.Connection = Connection;
-//# sourceMappingURL=Connection.js.map

package/lib/Filelist.d.ts

@@ -1,11 +0,0 @@
-/// <reference types="node" />
-import { ILocalConfig, ITargetConfig } from './Config';
-import { Connection } from './Connection';
-export interface IFilelist {
-    [filename: string]: number;
-}
-export declare function localFileExists(path: string): Promise<boolean>;
-export declare function readLocalFile(path: string, asBuffer?: boolean): Promise<string | Buffer>;
-export declare function writeLocalFile(path: string, content: string): Promise<any>;
-export declare function getRemoteFilelist(target: ITargetConfig, conn: Connection): Promise<IFilelist>;
-export declare function buildLocalFilelist(config: ILocalConfig): Promise<IFilelist>;

package/lib/Filelist.js

@@ -1,59 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const glob = require("glob");
-const minimatch = require("minimatch");
-const crc = require("crc");
-const fs = require("fs");
-const Log = require("./Log");
-function localFileExists(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fs.existsSync(path);
-    });
-}
-exports.localFileExists = localFileExists;
-function readLocalFile(path, asBuffer = false) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const buff = fs.readFileSync(path);
-        return asBuffer ? buff : buff.toString();
-    });
-}
-exports.readLocalFile = readLocalFile;
-function writeLocalFile(path, content) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return fs.writeFileSync(path, content);
-    });
-}
-exports.writeLocalFile = writeLocalFile;
-function getRemoteFilelist(target, conn) {
-    const path = `${target.path}/${target.cache}`;
-    return conn.getRemoteFile(path)
-        .then(JSON.parse)
-        .catch((err) => {
-        Log.info("Missing or error parsing remote file list.", err);
-        Log.log("\n   Run sync:init to setup SyncoDeMayo on the server.\n");
-        process.exit(1);
-    });
-}
-exports.getRemoteFilelist = getRemoteFilelist;
-function buildLocalFilelist(config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Create the CRCs...
-        const excludeDirectories = (path) => !fs.statSync(path).isDirectory();
-        const excludeBlacklistedFiles = (path) => !config.exclude.some(pattern => minimatch(path, pattern, { dot: true }));
-        return glob
-            .sync(`${config.path}/${config.files}`)
-            .filter(excludeDirectories)
-            .filter(excludeBlacklistedFiles)
-            .reduce((hash, filepath) => (hash[filepath] = crc.crc32(fs.readFileSync(filepath)), hash), {});
-    });
-}
-exports.buildLocalFilelist = buildLocalFilelist;
-//# sourceMappingURL=Filelist.js.map

package/lib/Sync.d.ts

@@ -1,18 +0,0 @@
-import { IConfig, ITargetConfig } from './Config';
-import { Connection } from './Connection';
-export interface IChangeset {
-    added: string[];
-    changed: string[];
-    removed: string[];
-}
-export declare class Sync {
-    private _conn;
-    private _config;
-    private _target;
-    constructor(conn: Connection, config: IConfig, target: string | ITargetConfig);
-    run(isDryRun?: boolean, forceConfirmation?: boolean): Promise<IChangeset | null>;
-    private _confirmUpload(target, fileCount);
-    private _getFilelists(local, target, conn);
-    private _buildChangeset(localFiles, remoteFiles);
-    static create(conn: Connection, config: IConfig, target: string | ITargetConfig): Sync;
-}

package/lib/Sync.js

@@ -1,140 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const yesno = require("yesno");
-const Log = require("./Log");
-const Config_1 = require("./Config");
-const Filelist_1 = require("./Filelist");
-class Sync {
-    constructor(conn, config, target) {
-        this._conn = conn;
-        this._config = config;
-        this._target = Config_1.resolveTarget(config, target);
-    }
-    run(isDryRun = false, forceConfirmation = false) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { localFiles, remoteFiles } = yield this._getFilelists(this._config.local, this._target, this._conn);
-            const changeset = this._buildChangeset(localFiles, remoteFiles);
-            const filesToUpload = [...changeset.added, ...changeset.changed];
-            if (isDryRun || (filesToUpload.length === 0 && changeset.removed.length === 0)) {
-                return changeset;
-            }
-            const _verifiedDirs = new Map();
-            const verifyDirExists = (remoteDir) => __awaiter(this, void 0, void 0, function* () {
-                if (!_verifiedDirs.has(remoteDir)) {
-                    const isVerified = yield this._conn.remoteDirectoryExists(remoteDir);
-                    _verifiedDirs.set(remoteDir, isVerified);
-                }
-                return true;
-            });
-            Log.info("\n%s files to upload...", filesToUpload.length);
-            Log.info("%s files to remove...\n", changeset.removed.length);
-            const confirmed = forceConfirmation === true
-                ? true
-                : yield this._confirmUpload(this._target, filesToUpload.length);
-            if (!confirmed) {
-                Log.info("Canceled upload.");
-                return null;
-            }
-            Log.log("Uploading %s files...", filesToUpload.length);
-            let sequentialUploader = Promise.resolve(true);
-            filesToUpload.forEach((filePath) => {
-                sequentialUploader = sequentialUploader.then(() => __awaiter(this, void 0, void 0, function* () {
-                    const remotePath = `${this._target.path}${filePath.replace(this._config.local.path, '')}`;
-                    const remoteDir = path.dirname(remotePath);
-                    const localPath = path.resolve(filePath);
-                    yield verifyDirExists(remoteDir);
-                    yield this._conn.putFile(localPath, remotePath);
-                    return true;
-                }));
-            });
-            if (this._config.local.deleteRemoteFiles && changeset.removed.length > 0) {
-                changeset.removed.forEach((filePath) => {
-                    sequentialUploader = sequentialUploader.then(() => __awaiter(this, void 0, void 0, function* () {
-                        const remotePath = `${this._target.path}${filePath.replace(this._config.local.path, '')}`;
-                        const didDelete = yield this._conn.deleteRemoteFile(remotePath);
-                        if (!didDelete)
-                            Log.urgent("   -> Error deleting file");
-                        return true;
-                    }));
-                });
-            }
-            yield sequentialUploader;
-            // await Promise.all(
-            //   filesToUpload.map(async (filePath: string) => {
-            //     const remotePath = `${this._target.path}${filePath.replace(this._config.local.path, '')}`
-            //     const remoteDir = path.dirname(remotePath)
-            //     await verifyDirExists(remoteDir)
-            //     await this._conn.putFile(filePath, remotePath)
-            //     return filePath
-            //   })
-            // )
-            const remoteCachePath = `${this._target.path}/${this._target.cache}`;
-            yield verifyDirExists(path.dirname(remoteCachePath));
-            yield this._conn.putContent(JSON.stringify(localFiles, null, 2), remoteCachePath);
-            return changeset;
-        });
-    }
-    _confirmUpload(target, fileCount) {
-        // If no prompt is specified, auto-confirm upload!
-        return new Promise(resolve => {
-            if (!target.prompt)
-                return resolve(true);
-            const message = typeof target.prompt === 'string'
-                ? target.prompt
-                : "Confirm upload?";
-            yesno.ask(`${message} - (Yes will upload)`, null, resolve);
-        });
-    }
-    _getFilelists(local, target, conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Load/build Filesets in parralel.
-            const remoteFilesLoader = Filelist_1.getRemoteFilelist(target, conn);
-            const localFilesBuilder = Filelist_1.buildLocalFilelist(local);
-            return {
-                localFiles: yield localFilesBuilder,
-                remoteFiles: yield remoteFilesLoader
-            };
-        });
-    }
-    _buildChangeset(localFiles, remoteFiles) {
-        const changeset = {
-            added: [],
-            removed: [],
-            changed: []
-        };
-        // Build list of files that need to be uploaded...
-        Object.keys(localFiles).forEach((localFilename) => {
-            const localHash = localFiles[localFilename];
-            const remoteHash = remoteFiles[localFilename];
-            // Local hash not in remote cache
-            if (!(localFilename in remoteFiles)) {
-                changeset.added.push(localFilename);
-            }
-            else if (remoteHash != localHash) {
-                changeset.changed.push(localFilename);
-            }
-            // Local hash and remote hash are equal!
-        });
-        // Build list of files to be removed from the server...
-        Object.keys(remoteFiles).forEach((remoteFilename) => {
-            if (!(remoteFilename in localFiles)) {
-                changeset.removed.push(remoteFilename);
-            }
-        });
-        return changeset;
-    }
-    static create(conn, config, target) {
-        return new Sync(conn, config, target);
-    }
-}
-exports.Sync = Sync;
-//# sourceMappingURL=Sync.js.map