@plasmicapp/cli 0.1.162

package/dist/tsconfig-transform.json

@@ -0,0 +1,68 @@
+{
+  "compilerOptions": {
+    /* Basic Options */
+    // "incremental": true,                   /* Enable incremental compilation */
+    "target": "ESNext" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
+    "module": "es2015" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
+    // "lib": [],                             /* Specify library files to be included in the compilation. */
+    // "allowJs": true,                       /* Allow javascript files to be compiled. */
+    // "checkJs": true,                       /* Report errors in .js files. */
+    "jsx": "preserve" /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */,
+    // "declaration": true,                   /* Generates corresponding '.d.ts' file. */
+    // "declarationMap": true,                /* Generates a sourcemap for each corresponding '.d.ts' file. */
+    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
+    // "outFile": "./",                       /* Concatenate and emit output to single file. */
+    // "outDir": "./dist",                        /* Redirect output structure to the directory. */
+    // "rootDir": "./",                       /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */
+    // "composite": true,                     /* Enable project compilation */
+    // "tsBuildInfoFile": "./",               /* Specify file to store incremental compilation information */
+    "removeComments": false /* Do not emit comments to output. */
+    // "noEmit": true,                        /* Do not emit outputs. */
+    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
+    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
+    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
+
+    //"importsNotUsedAsValues": "preserve",
+
+    /* Strict Type-Checking Options */
+    //"strict": true,                           /* Enable all strict type-checking options. */
+    // "noImplicitAny": true,                 /* Raise error on expressions and declarations with an implied 'any' type. */
+    // "strictNullChecks": true,              /* Enable strict null checks. */
+    // "strictFunctionTypes": true,           /* Enable strict checking of function types. */
+    // "strictBindCallApply": true,           /* Enable strict 'bind', 'call', and 'apply' methods on functions. */
+    // "strictPropertyInitialization": true,  /* Enable strict checking of property initialization in classes. */
+    // "noImplicitThis": true,                /* Raise error on 'this' expressions with an implied 'any' type. */
+    // "alwaysStrict": true,                  /* Parse in strict mode and emit "use strict" for each source file. */
+
+    /* Additional Checks */
+    // "noUnusedLocals": true,                /* Report errors on unused locals. */
+    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
+    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
+    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
+
+    /* Module Resolution Options */
+    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
+    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
+    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
+    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
+    // "typeRoots": [],                       /* List of folders to include type definitions from. */
+    // "types": [],                           /* Type declaration files to be included in compilation. */
+    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
+    //"esModuleInterop": true,                  /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
+    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
+    // "allowUmdGlobalAccess": true,          /* Allow accessing UMD globals from modules. */
+
+    /* Source Map Options */
+    // "sourceRoot": "",                      /* Specify the location where debugger should locate TypeScript files instead of source locations. */
+    // "mapRoot": "",                         /* Specify the location where debugger should locate map files instead of generated locations. */
+    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
+    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
+
+    /* Experimental Options */
+    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
+    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
+
+    /* Advanced Options */
+    //"forceConsistentCasingInFileNames": true  /* Disallow inconsistently-cased references to the same file. */
+  }
+}

package/dist/utils/auth-utils.d.ts

@@ -0,0 +1,31 @@
+import { CommonArgs } from "../index";
+import { AuthConfig } from "./config-utils";
+export declare type AuthData = {
+    user: string;
+    token: string;
+};
+export declare type CancellablePromise<T> = {
+    promise: Promise<T>;
+    cancel: () => void;
+};
+export declare function authByPolling(host: string, initToken: string): CancellablePromise<AuthData>;
+export declare function startAuth(opts: Partial<CommonArgs> & {
+    host: string;
+}): Promise<void>;
+export declare function readAuth(authFile: string): {
+    host: string;
+    user: string;
+    token: string;
+    basicAuthUser?: string | undefined;
+    basicAuthPassword?: string | undefined;
+};
+export declare function getEnvAuth(): AuthConfig | undefined;
+export declare function getCurrentAuth(authPath?: string): Promise<AuthConfig | undefined>;
+export declare function getOrStartAuth(opts: CommonArgs & {
+    host: string;
+    enableSkipAuth?: boolean;
+}): Promise<AuthConfig | undefined>;
+export declare function findAuthFile(dir: string, opts: {
+    traverseParents?: boolean;
+}): string | undefined;
+export declare function writeAuth(authFile: string, config: AuthConfig): Promise<void>;

package/dist/utils/auth-utils.js

@@ -0,0 +1,236 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    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) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeAuth = exports.findAuthFile = exports.getOrStartAuth = exports.getCurrentAuth = exports.getEnvAuth = exports.readAuth = exports.startAuth = exports.authByPolling = void 0;
+const fs_1 = __importDefault(require("fs"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const open_1 = __importDefault(require("open"));
+const os_1 = __importDefault(require("os"));
+const socket_io_client_1 = __importDefault(require("socket.io-client"));
+const upath_1 = __importDefault(require("upath"));
+const uuid_1 = require("uuid");
+const api_1 = require("../api");
+const deps_1 = require("../deps");
+const error_1 = require("../utils/error");
+const config_utils_1 = require("./config-utils");
+const file_utils_1 = require("./file-utils");
+function authByPolling(host, initToken) {
+    const socket = socket_io_client_1.default.connect(host, {
+        path: `/api/v1/init-token`,
+        transportOptions: {
+            polling: {
+                extraHeaders: {
+                    "x-plasmic-init-token": initToken,
+                },
+            },
+        },
+    });
+    const promise = new Promise((resolve, reject) => {
+        socket.on("connect", (reason) => {
+            deps_1.logger.info("Waiting for token...");
+        });
+        socket.on("token", (data) => {
+            resolve(data);
+            socket.close();
+        });
+        socket.on("error", (error) => {
+            deps_1.logger.warn(error);
+            reject(error);
+        });
+    });
+    const cancel = () => {
+        socket.close();
+    };
+    return { promise, cancel };
+}
+exports.authByPolling = authByPolling;
+function authByPrompt(host) {
+    const promise = inquirer_1.default.prompt([
+        {
+            name: "user",
+            message: "Your Plasmic user email",
+        },
+        {
+            name: "token",
+            message: `Your personal access token (create one at ${host}/self/settings)`,
+        },
+    ]);
+    const cancel = () => {
+        deps_1.logger.info("Cancelling prompt...");
+        process.stdin.pause();
+    };
+    return { promise, cancel };
+}
+function startAuth(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (opts.yes) {
+            throw new error_1.HandledError("Plasmic credentials could not be found.");
+        }
+        const auth = yield new Promise((resolve, reject) => {
+            let prompt;
+            const initToken = uuid_1.v4();
+            const url = `${opts.host}/auth/plasmic-init/${initToken}`;
+            open_1.default(url);
+            deps_1.logger.info(`\nIf your browser doesn't automatically open, enter the following URL:\n${url}\n`);
+            deps_1.logger.info(`Please log in and authorize Plasmic CLI.`);
+            const polling = authByPolling(opts.host, initToken);
+            polling.promise.then((auth) => {
+                if (prompt) {
+                    prompt.cancel();
+                }
+                else {
+                    clearTimeout(timeout);
+                }
+                resolve(auth);
+            });
+            // Default to 1 minute.
+            const authPollTimeout = Number(process.env.PLASMIC_AUTH_POLL_TIMEOUT) || 60 * 1000;
+            if (authPollTimeout === -1) {
+                return;
+            }
+            const timeout = setTimeout(() => {
+                deps_1.logger.info(`We haven't received an auth token from Plasmic yet.`);
+                prompt = authByPrompt(opts.host);
+                prompt.promise
+                    .then((auth) => {
+                    polling.cancel();
+                    resolve(auth);
+                })
+                    .catch(reject);
+            }, authPollTimeout);
+        });
+        if (!auth.user || !auth.token) {
+            deps_1.logger.error(`Could not get auth token.`);
+            return;
+        }
+        const newAuthFile = opts.auth || upath_1.default.join(os_1.default.homedir(), config_utils_1.AUTH_FILE_NAME);
+        yield writeAuth(newAuthFile, {
+            host: opts.host,
+            user: auth.user,
+            token: auth.token,
+        });
+        deps_1.logger.info(`Successfully created Plasmic credentials file at ${newAuthFile}`);
+    });
+}
+exports.startAuth = startAuth;
+function readAuth(authFile) {
+    if (!file_utils_1.existsBuffered(authFile)) {
+        throw new error_1.HandledError(`No Plasmic auth file found at ${authFile}`);
+    }
+    try {
+        const parsed = JSON.parse(file_utils_1.readFileText(authFile));
+        // Strip trailing slashes.
+        return Object.assign(Object.assign({}, parsed), { host: parsed.host.replace(/\/+$/, "") });
+    }
+    catch (e) {
+        deps_1.logger.error(`Error encountered reading plasmic credentials at ${authFile}: ${e}`);
+        throw e;
+    }
+}
+exports.readAuth = readAuth;
+function getEnvAuth() {
+    const host = process.env[config_utils_1.ENV_AUTH_HOST];
+    const user = process.env[config_utils_1.ENV_AUTH_USER];
+    const token = process.env[config_utils_1.ENV_AUTH_TOKEN];
+    // both user and token are required
+    if (!user || !token) {
+        // Try to give a hint if they partially entered a credential
+        if (user || token) {
+            deps_1.logger.warn(`Your Plasmic credentials were only partially set via environment variables. Try both ${config_utils_1.ENV_AUTH_USER} and ${config_utils_1.ENV_AUTH_TOKEN}`);
+        }
+        return;
+    }
+    return {
+        host: host !== null && host !== void 0 ? host : config_utils_1.DEFAULT_HOST,
+        user,
+        token,
+    };
+}
+exports.getEnvAuth = getEnvAuth;
+function readCurrentAuth(authPath) {
+    const authFromEnv = getEnvAuth();
+    if (authFromEnv)
+        return authFromEnv;
+    if (!authPath && !process.env.PLASMIC_DISABLE_AUTH_SEARCH) {
+        authPath = findAuthFile(process.cwd(), { traverseParents: true });
+    }
+    if (!authPath) {
+        return undefined;
+    }
+    return readAuth(authPath);
+}
+function getCurrentAuth(authPath) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        const auth = readCurrentAuth(authPath);
+        if (!auth) {
+            return undefined;
+        }
+        const api = new api_1.PlasmicApi(auth);
+        try {
+            yield api.getCurrentUser();
+            return auth;
+        }
+        catch (e) {
+            if (((_a = e.response) === null || _a === void 0 ? void 0 : _a.status) === 401) {
+                deps_1.logger.error(`The current credentials expired or are not valid.`);
+                return undefined;
+            }
+            throw e;
+        }
+    });
+}
+exports.getCurrentAuth = getCurrentAuth;
+function failAuth() {
+    throw new error_1.HandledError(`Unable to authenticate Plasmic. Please run 'plasmic auth'.`);
+}
+function getOrStartAuth(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let auth = yield getCurrentAuth(opts.auth);
+        if (!auth && opts.enableSkipAuth) {
+            return;
+        }
+        if (!auth && opts.yes) {
+            failAuth();
+        }
+        if (!auth) {
+            yield startAuth(opts);
+            auth = yield getCurrentAuth(opts.auth);
+        }
+        if (!auth) {
+            failAuth();
+        }
+        return auth;
+    });
+}
+exports.getOrStartAuth = getOrStartAuth;
+function findAuthFile(dir, opts) {
+    let file = file_utils_1.findFile(dir, (f) => f === config_utils_1.AUTH_FILE_NAME, opts);
+    if (!file) {
+        file = file_utils_1.findFile(os_1.default.homedir(), (f) => f === config_utils_1.AUTH_FILE_NAME, {
+            traverseParents: false,
+        });
+    }
+    return file;
+}
+exports.findAuthFile = findAuthFile;
+function writeAuth(authFile, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield file_utils_1.writeFileContentRaw(authFile, JSON.stringify(config, undefined, 2), {
+            force: true,
+        });
+        fs_1.default.chmodSync(authFile, "600");
+    });
+}
+exports.writeAuth = writeAuth;

package/dist/utils/checksum.d.ts

@@ -0,0 +1,4 @@
+import { SyncArgs } from "../actions/sync";
+import { ChecksumBundle } from "../api";
+import { PlasmicContext } from "./config-utils";
+export declare function getChecksums(context: PlasmicContext, opts: SyncArgs, projectId: string, componentIds: string[]): ChecksumBundle;

package/dist/utils/checksum.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChecksums = void 0;
+const lang_utils_1 = require("./lang-utils");
+function getChecksums(context, opts, projectId, componentIds) {
+    const projectConfig = context.config.projects.find((p) => p.projectId === projectId);
+    const projectLock = context.lock.projects.find((projectLock) => projectLock.projectId === projectId);
+    if (!projectConfig || !projectLock || opts.allFiles) {
+        return {
+            imageChecksums: [],
+            iconChecksums: [],
+            renderModuleChecksums: [],
+            cssRulesChecksums: [],
+            globalVariantChecksums: [],
+            projectCssChecksum: "",
+        };
+    }
+    const fileLocks = projectLock.fileLocks;
+    const knownImages = new Set(projectConfig.images.map((i) => i.id));
+    const knownIcons = new Set(projectConfig.icons.map((i) => i.id));
+    const knownComponents = new Set(projectConfig.components.map((c) => c.id));
+    const knownGlobalVariants = new Set(context.config.globalVariants.variantGroups
+        .filter((vg) => vg.projectId === projectId)
+        .map((vg) => vg.id));
+    const knownThemes = new Set((projectConfig.jsBundleThemes || []).map((theme) => theme.bundleName));
+    const toBeSyncedComponents = new Set(componentIds);
+    const imageChecksums = fileLocks
+        .filter((fileLock) => fileLock.type === "image" && knownImages.has(fileLock.assetId))
+        .map((fileLock) => [fileLock.assetId, fileLock.checksum]);
+    const iconChecksums = fileLocks
+        .filter((fileLock) => projectLock.lang === context.config.code.lang &&
+        fileLock.type === "icon" &&
+        knownIcons.has(fileLock.assetId))
+        .map((fileLock) => [fileLock.assetId, fileLock.checksum]);
+    const renderModuleChecksums = fileLocks
+        .filter((fileLock) => projectLock.lang === context.config.code.lang &&
+        fileLock.type === "renderModule" &&
+        toBeSyncedComponents.has(fileLock.assetId) &&
+        knownComponents.has(fileLock.assetId))
+        .map((fileLock) => [fileLock.assetId, fileLock.checksum]);
+    const cssRulesChecksums = fileLocks
+        .filter((fileLock) => fileLock.type === "cssRules" &&
+        toBeSyncedComponents.has(fileLock.assetId) &&
+        knownComponents.has(fileLock.assetId))
+        .map((fileLock) => [fileLock.assetId, fileLock.checksum]);
+    const globalVariantChecksums = fileLocks
+        .filter((fileLock) => projectLock.lang === context.config.code.lang &&
+        fileLock.type === "globalVariant" &&
+        knownGlobalVariants.has(fileLock.assetId))
+        .map((fileLock) => [fileLock.assetId, fileLock.checksum]);
+    const projectCssChecksums = fileLocks.filter((fileLock) => fileLock.type === "projectCss");
+    lang_utils_1.assert(projectCssChecksums.length < 2);
+    const projectCssChecksum = projectCssChecksums.length > 0 ? projectCssChecksums[0].checksum : "";
+    return {
+        imageChecksums,
+        iconChecksums,
+        renderModuleChecksums,
+        cssRulesChecksums,
+        globalVariantChecksums,
+        projectCssChecksum,
+    };
+}
+exports.getChecksums = getChecksums;

package/dist/utils/code-utils.d.ts

@@ -0,0 +1,46 @@
+import { ImportDeclaration } from "@babel/types";
+import L from "lodash";
+import { Options } from "prettier";
+import { CodeComponentConfig, ComponentConfig, GlobalVariantGroupConfig, IconConfig, ImageConfig, PlasmicConfig, PlasmicContext, ProjectConfig } from "./config-utils";
+export declare const formatAsLocal: (content: string, filePath: string, baseDir: string, defaultOpts?: Options) => string;
+export declare function ensureImportSpecifierWithAlias(decl: ImportDeclaration, imported: string, alias: string): void;
+export declare function ensureImportDefaultSpecifier(decl: ImportDeclaration, defaultExport: string): void;
+/**
+ * Given the argument `code` string, for module at `fromPath`, replaces all Plasmic imports
+ * for modules found in `compConfigsMap`.
+ */
+export declare function replaceImports(context: PlasmicContext, code: string, fromPath: string, fixImportContext: FixImportContext, removeImportDirective: boolean, baseDir: string, changed?: boolean): string;
+/**
+ * Returns true if the argument ComponentConfig.importSpec.modulePath is referencing
+ * a local file
+ */
+export declare function isLocalModulePath(modulePath: string): boolean;
+export interface ComponentUpdateSummary {
+    skeletonModuleModified: boolean;
+}
+export interface FixImportContext {
+    config: PlasmicConfig;
+    components: Record<string, ComponentConfig>;
+    codeComponentMetas: Record<string, CodeComponentConfig>;
+    globalVariants: Record<string, GlobalVariantGroupConfig>;
+    icons: Record<string, IconConfig>;
+    images: Record<string, ImageConfig>;
+    projects: Record<string, ProjectConfig>;
+}
+export declare const mkFixImportContext: (config: PlasmicConfig) => {
+    config: PlasmicConfig;
+    components: L.Dictionary<ComponentConfig>;
+    codeComponentMetas: L.Dictionary<CodeComponentConfig>;
+    globalVariants: L.Dictionary<GlobalVariantGroupConfig>;
+    icons: L.Dictionary<IconConfig>;
+    images: L.Dictionary<ImageConfig>;
+    projects: L.Dictionary<ProjectConfig>;
+};
+/**
+ * Assuming that all the files referenced in PlasmicConfig are correct, fixes import statements using PlasmicConfig
+ * file locations as the source of truth.
+ */
+export declare function fixAllImportStatements(context: PlasmicContext, baseDir: string, summary?: Map<string, ComponentUpdateSummary>): Promise<void>;
+export declare const tsxToJsx: (code: string) => string;
+export declare function maybeConvertTsxToJsx(fileName: string, content: string, baseDir: string): string[];
+export declare const formatScript: (code: string, baseDir: string) => string;