@plasmicapp/cli 0.1.162

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

@@ -0,0 +1,271 @@
+import { DeepPartial } from "utility-types";
+import { PlasmicApi, ProjectIdAndToken } from "../api";
+export declare const DEFAULT_HOST: string;
+export declare const AUTH_FILE_NAME = ".plasmic.auth";
+export declare const CONFIG_FILE_NAME = "plasmic.json";
+export declare const LOCK_FILE_NAME = "plasmic.lock";
+export declare const LOADER_CONFIG_FILE_NAME = "plasmic-loader.json";
+export declare const CONFIG_SCHEMA_FILE_NAME = "plasmic.schema.json";
+export declare const ENV_AUTH_HOST = "PLASMIC_AUTH_HOST";
+export declare const ENV_AUTH_USER = "PLASMIC_AUTH_USER";
+export declare const ENV_AUTH_TOKEN = "PLASMIC_AUTH_TOKEN";
+export interface PlasmicLoaderConfig {
+    projects: ProjectIdAndToken[];
+    aboutThisFile: string;
+    dir: string;
+    plasmicDir: string;
+    pageDir: string;
+    initArgs: Record<string, string>;
+    substitutions?: Record<string, any>;
+}
+export interface PlasmicConfig {
+    /** Target platform to generate code for */
+    platform: "react" | "nextjs" | "gatsby";
+    /**
+     * The folder containing the component source files; this is the default place where
+     * all files are generated and stored.
+     */
+    srcDir: string;
+    /**
+     * The default folder where Plasmic-managed files will be stored. These include
+     * blackbox component files, svg component files, style files, etc.  The path
+     * is relative to the srcDir.
+     */
+    defaultPlasmicDir: string;
+    /**
+     * Next.js specific config
+     */
+    nextjsConfig?: {
+        /** The folder containing page components source files. */
+        pagesDir?: string;
+    };
+    /** Gatsby-specific config */
+    gatsbyConfig?: {
+        /** The folder containing page components source files. */
+        pagesDir?: string;
+    };
+    /** Config for code generation */
+    code: CodeConfig;
+    /** Config for pictures */
+    images: ImagesConfig;
+    /** Config for style generation */
+    style: StyleConfig;
+    /** Config for style tokens */
+    tokens: TokensConfig;
+    /** Metadata for global variant groups */
+    globalVariants: GlobalVariantsConfig;
+    /** Metadata for each project that has been synced */
+    projects: ProjectConfig[];
+    /** The version of cli when this file was written */
+    cliVersion?: string;
+    /** Arbitrary command to run after `plasmic sync` has run; useful for linting and code formatting synced files */
+    postSyncCommands?: string[];
+}
+export interface CodeConfig {
+    /** Language to generate code in */
+    lang: "ts" | "js";
+    /** The default code generation scheme. Each component can override the scheme. */
+    scheme: "blackbox" | "direct";
+    reactRuntime: "classic" | "automatic";
+}
+export interface StyleConfig {
+    /** Styling framework to use */
+    scheme: "css" | "css-modules";
+    /** File location for global css styles shared by all components. Relative to srcDir */
+    defaultStyleCssFilePath: string;
+}
+export interface ImagesConfig {
+    /**
+     * How image files should be referenced from generated React components. The choices are:
+     * * "files" - imported as relative files, like "import img from './image.png'". Not all bundlers support this.
+     * * "public-files" - images are stored in a public folder, and referenced from some url prefix, like `<img src="/static/image.png"/>`.
+     * * "inlined" - inlined directly into React files and css files as base64-encoded data-URIs.
+     * * "cdn" - images are served from Plasmic's CDN.  Allows for dynamic resizing of images for
+     *   serving the optimal file size given browser viewport.
+     */
+    scheme: "inlined" | "files" | "public-files" | "cdn";
+    /**
+     * The folder where "public" static files are stored. Plasmic-managed image files will be stored as "plasmic/project-name/image-name" under this folder.  Relative to srcDir; for example, "../public"
+     */
+    publicDir?: string;
+    /**
+     * The url prefix where "public" static files are stored.  For example, if publicDir is "public", publicUrlPrefix is "/static", then a file at public/test.png will be served at /static/test.png.
+     */
+    publicUrlPrefix?: string;
+}
+export interface JsBundleThemeConfig {
+    themeFilePath: string;
+    bundleName: string;
+}
+export interface CodeComponentConfig {
+    id: string;
+    name: string;
+    componentImportPath: string;
+}
+export interface ProjectConfig {
+    /** Project ID */
+    projectId: string;
+    /** Project API token. Grants read-only sync access to just this specific project and its dependencies. */
+    projectApiToken?: string;
+    /** Project name synced down from Studio */
+    projectName: string;
+    /**
+     * A version range for syncing this project. Can be:
+     * * "latest" - always syncs down whatever has been saved in the project.
+     * * ">0" - always syncs down the latest published version of the project.
+     * * any other semver string you'd like
+     */
+    version: string;
+    /** File location for the project-wide css styles. Relative to srcDir */
+    cssFilePath: string;
+    jsBundleThemes?: JsBundleThemeConfig[];
+    codeComponents?: CodeComponentConfig[];
+    /** Metadata for each synced component in this project. */
+    components: ComponentConfig[];
+    /** Metadata for each synced icon in this project */
+    icons: IconConfig[];
+    /** Metadata for each synced image in this project */
+    images: ImageConfig[];
+}
+export declare function createProjectConfig(base: {
+    projectId: string;
+    projectApiToken: string;
+    projectName: string;
+    version: string;
+    cssFilePath: string;
+}): ProjectConfig;
+export interface TokensConfig {
+    scheme: "theo";
+    tokensFilePath: string;
+}
+/**
+ * Describes how to import a Component
+ */
+export interface ImportSpec {
+    /**
+     * The import path to use to instantiate this Component.  The modulePath can be:
+     * * An external npm module, like "antd/lib/button"
+     * * A local file, like "components/Button.tsx" (path is relative to srcDir, and file extension is fully specified).  If local file is specified, then the module is imported via relative path.
+     *
+     * For this to be an external npm module, the ComponentConfig.type must be "mapped".
+     */
+    modulePath: string;
+    /**
+     * If the Component is a named export of the module, then this is the name.  If the Component
+     * is the default export, then this is undefined.
+     */
+    exportName?: string;
+}
+export interface ComponentConfig {
+    /** Component ID */
+    id: string;
+    /** Javascript name of component */
+    name: string;
+    /** Plasmic project that this component belongs in */
+    projectId: string;
+    /** Whether this component is managed by Plasmic -- with Plasmic* files generated -- or mapped to an external library */
+    type: "managed" | "mapped";
+    /** How to import this Component from another component file */
+    importSpec: ImportSpec;
+    /** The file path for the blackbox render module, relative to srcDir. */
+    renderModuleFilePath: string;
+    /** The file path for the component css file, relative to srcDir. */
+    cssFilePath: string;
+    /** Code generation scheme used for this component */
+    scheme: "blackbox" | "direct";
+    componentType: "page" | "component";
+    /** Plume type if component is a Plume component */
+    plumeType?: string;
+}
+export interface IconConfig {
+    /** ID of icon */
+    id: string;
+    /** Javascript name of the React component for this icon */
+    name: string;
+    /** The file path for the React component file for this icon, relative to srcDir. */
+    moduleFilePath: string;
+}
+export interface ImageConfig {
+    /** ID of image */
+    id: string;
+    /** name of image */
+    name: string;
+    /** File path for the image file, relative to srcDir */
+    filePath: string;
+}
+export interface GlobalVariantsConfig {
+    variantGroups: GlobalVariantGroupConfig[];
+}
+export interface GlobalVariantGroupConfig {
+    /** ID of the global variant group */
+    id: string;
+    /** Javascript name of the global variant group */
+    name: string;
+    /** Plasmic project this global variant group belongs to */
+    projectId: string;
+    /** File path for the global variant group React context definition, relative to srcDir */
+    contextFilePath: string;
+}
+export interface FileLock {
+    type: "renderModule" | "cssRules" | "icon" | "image" | "projectCss" | "globalVariant";
+    checksum: string;
+    assetId: string;
+}
+export interface ProjectLock {
+    projectId: string;
+    version: string;
+    dependencies: {
+        [projectId: string]: string;
+    };
+    lang: "ts" | "js";
+    fileLocks: FileLock[];
+}
+export interface PlasmicLock {
+    projects: ProjectLock[];
+    cliVersion?: string;
+}
+/**
+ * PlasmicContext is the PlasmicConfig plus context in which the PlasmicConfig was
+ * created.
+ */
+export interface PlasmicContext {
+    configFile: string;
+    lockFile: string;
+    rootDir: string;
+    absoluteSrcDir: string;
+    config: PlasmicConfig;
+    lock: PlasmicLock;
+    auth: AuthConfig;
+    api: PlasmicApi;
+    cliArgs: any;
+}
+export interface AuthConfig {
+    host: string;
+    user: string;
+    token: string;
+    basicAuthUser?: string;
+    basicAuthPassword?: string;
+}
+export declare const DEFAULT_CONFIG: PlasmicConfig;
+export declare const DEFAULT_PUBLIC_FILES_CONFIG: ImagesConfig;
+/**
+ * Finds the full path to the plasmic.json file in `dir`.  If
+ * `opts.traverseParents` is set to true, then will also look in ancestor
+ * directories until the plasmic.json file is found.  If none is found,
+ * returns undefined.
+ */
+export declare function findConfigFile(dir: string, opts: {
+    traverseParents?: boolean;
+}): string | undefined;
+/**
+ * Given some partial configs for PlasmicConfig, fills in all required fields
+ * with default values.
+ */
+export declare function fillDefaults(config: DeepPartial<PlasmicConfig>): PlasmicConfig;
+export declare function readConfig(configFile: string, autoFillDefaults: boolean): PlasmicConfig;
+export declare function writeConfig(configFile: string, config: PlasmicConfig, baseDir: string): Promise<void>;
+export declare function writeLock(lockFile: string, lock: PlasmicLock, baseDir: string): Promise<void>;
+export declare function updateConfig(context: PlasmicContext, newConfig: PlasmicConfig, baseDir: string): Promise<void>;
+export declare function getOrAddProjectConfig(context: PlasmicContext, projectId: string, base?: ProjectConfig): ProjectConfig;
+export declare function getOrAddProjectLock(context: PlasmicContext, projectId: string, base?: ProjectLock): ProjectLock;
+export declare function isPageAwarePlatform(platform: string): boolean;

package/dist/utils/config-utils.js

@@ -0,0 +1,178 @@
+"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.isPageAwarePlatform = exports.getOrAddProjectLock = exports.getOrAddProjectConfig = exports.updateConfig = exports.writeLock = exports.writeConfig = exports.readConfig = exports.fillDefaults = exports.findConfigFile = exports.DEFAULT_PUBLIC_FILES_CONFIG = exports.DEFAULT_CONFIG = exports.createProjectConfig = exports.ENV_AUTH_TOKEN = exports.ENV_AUTH_USER = exports.ENV_AUTH_HOST = exports.CONFIG_SCHEMA_FILE_NAME = exports.LOADER_CONFIG_FILE_NAME = exports.LOCK_FILE_NAME = exports.CONFIG_FILE_NAME = exports.AUTH_FILE_NAME = exports.DEFAULT_HOST = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const deps_1 = require("../deps");
+const error_1 = require("../utils/error");
+const code_utils_1 = require("./code-utils");
+const file_utils_1 = require("./file-utils");
+exports.DEFAULT_HOST = process.env.PLASMIC_DEFAULT_HOST || "https://studio.plasmic.app";
+// Default filenames
+exports.AUTH_FILE_NAME = ".plasmic.auth";
+exports.CONFIG_FILE_NAME = "plasmic.json";
+exports.LOCK_FILE_NAME = "plasmic.lock";
+exports.LOADER_CONFIG_FILE_NAME = "plasmic-loader.json";
+exports.CONFIG_SCHEMA_FILE_NAME = "plasmic.schema.json";
+// Default environment variable names
+exports.ENV_AUTH_HOST = "PLASMIC_AUTH_HOST";
+exports.ENV_AUTH_USER = "PLASMIC_AUTH_USER";
+exports.ENV_AUTH_TOKEN = "PLASMIC_AUTH_TOKEN";
+function createProjectConfig(base) {
+    return {
+        projectId: base.projectId,
+        projectApiToken: base.projectApiToken,
+        projectName: base.projectName,
+        version: base.version,
+        cssFilePath: base.cssFilePath,
+        components: [],
+        icons: [],
+        images: [],
+    };
+}
+exports.createProjectConfig = createProjectConfig;
+exports.DEFAULT_CONFIG = {
+    platform: "react",
+    code: {
+        lang: "ts",
+        scheme: "blackbox",
+        reactRuntime: "classic",
+    },
+    style: {
+        scheme: "css-modules",
+        // We set it to empty to compile. In reality, it will be provided the by
+        // the server.
+        defaultStyleCssFilePath: "",
+    },
+    images: {
+        scheme: "inlined",
+    },
+    tokens: {
+        scheme: "theo",
+        tokensFilePath: "plasmic-tokens.theo.json",
+    },
+    srcDir: "./src/components",
+    defaultPlasmicDir: "./plasmic",
+    projects: [],
+    globalVariants: {
+        variantGroups: [],
+    },
+};
+exports.DEFAULT_PUBLIC_FILES_CONFIG = {
+    scheme: "public-files",
+    publicDir: "../public",
+    publicUrlPrefix: "/static/",
+};
+/**
+ * Finds the full path to the plasmic.json file in `dir`.  If
+ * `opts.traverseParents` is set to true, then will also look in ancestor
+ * directories until the plasmic.json file is found.  If none is found,
+ * returns undefined.
+ */
+function findConfigFile(dir, opts) {
+    return file_utils_1.findFile(dir, (f) => f === exports.CONFIG_FILE_NAME, opts);
+}
+exports.findConfigFile = findConfigFile;
+/**
+ * Given some partial configs for PlasmicConfig, fills in all required fields
+ * with default values.
+ */
+function fillDefaults(config) {
+    return lodash_1.default.merge({}, exports.DEFAULT_CONFIG, config);
+}
+exports.fillDefaults = fillDefaults;
+function readConfig(configFile, autoFillDefaults) {
+    if (!file_utils_1.existsBuffered(configFile)) {
+        const err = new error_1.HandledError(`No Plasmic config file found at ${configFile}`);
+        throw err;
+    }
+    try {
+        const result = JSON.parse(file_utils_1.readFileText(configFile));
+        return autoFillDefaults ? fillDefaults(result) : result;
+    }
+    catch (e) {
+        deps_1.logger.error(`Error encountered reading ${exports.CONFIG_FILE_NAME} at ${configFile}: ${e}`);
+        throw e;
+    }
+}
+exports.readConfig = readConfig;
+function writeConfig(configFile, config, baseDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield file_utils_1.writeFileContentRaw(configFile, code_utils_1.formatAsLocal(JSON.stringify(Object.assign(Object.assign({}, config), { $schema: `https://unpkg.com/@plasmicapp/cli@${config.cliVersion}/dist/plasmic.schema.json` }), undefined, 2), configFile, baseDir), {
+            force: true,
+        });
+    });
+}
+exports.writeConfig = writeConfig;
+function writeLock(lockFile, lock, baseDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield file_utils_1.writeFileContentRaw(lockFile, code_utils_1.formatAsLocal(JSON.stringify(lock, undefined, 2), "/tmp/x.json", baseDir), {
+            force: true,
+        });
+    });
+}
+exports.writeLock = writeLock;
+function updateConfig(context, newConfig, baseDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        // plasmic.json
+        yield writeConfig(context.configFile, newConfig, baseDir);
+        context.config = newConfig;
+        // plasmic.lock
+        yield writeLock(context.lockFile, context.lock, baseDir);
+    });
+}
+exports.updateConfig = updateConfig;
+function getOrAddProjectConfig(context, projectId, base // if one doesn't exist, start with this
+) {
+    let project = context.config.projects.find((p) => p.projectId === projectId);
+    if (!project) {
+        project = !!base
+            ? lodash_1.default.cloneDeep(base)
+            : {
+                projectId,
+                projectName: "",
+                version: "latest",
+                cssFilePath: "",
+                components: [],
+                icons: [],
+                images: [],
+                jsBundleThemes: [],
+            };
+        context.config.projects.push(project);
+    }
+    return project;
+}
+exports.getOrAddProjectConfig = getOrAddProjectConfig;
+function getOrAddProjectLock(context, projectId, base // if one doesn't exist, start with this
+) {
+    let project = context.lock.projects.find((p) => p.projectId === projectId);
+    if (!project) {
+        project = !!base
+            ? lodash_1.default.cloneDeep(base)
+            : {
+                projectId,
+                version: "",
+                dependencies: {},
+                lang: context.config.code.lang,
+                fileLocks: [],
+            };
+        context.lock.projects.push(project);
+    }
+    return project;
+}
+exports.getOrAddProjectLock = getOrAddProjectLock;
+function isPageAwarePlatform(platform) {
+    return platform === "nextjs" || platform === "gatsby";
+}
+exports.isPageAwarePlatform = isPageAwarePlatform;

package/dist/utils/envdetect.d.ts

@@ -0,0 +1,4 @@
+export declare function detectTypescript(): string | null;
+export declare function detectNextJs(): boolean;
+export declare function detectGatsby(): string | null;
+export declare function detectCreateReactApp(): boolean;

package/dist/utils/envdetect.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectCreateReactApp = exports.detectGatsby = exports.detectNextJs = exports.detectTypescript = void 0;
+const findup_sync_1 = __importDefault(require("findup-sync"));
+const npm_utils_1 = require("./npm-utils");
+function detectTypescript() {
+    return findup_sync_1.default("tsconfig.json");
+}
+exports.detectTypescript = detectTypescript;
+function detectNextJs() {
+    if (findup_sync_1.default("next.config.js") ||
+        findup_sync_1.default(".next") ||
+        findup_sync_1.default("next-env.d.ts")) {
+        return true;
+    }
+    try {
+        const packageJsonContent = npm_utils_1.getParsedPackageJson();
+        return (packageJsonContent.scripts.build === "next build" ||
+            "next" in packageJsonContent.dependencies);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.detectNextJs = detectNextJs;
+function detectGatsby() {
+    return findup_sync_1.default("gatsby-config.js");
+}
+exports.detectGatsby = detectGatsby;
+function detectCreateReactApp() {
+    try {
+        const packageJsonContent = npm_utils_1.getParsedPackageJson();
+        return "react-scripts" in packageJsonContent.dependencies;
+    }
+    catch (_a) {
+        return false;
+    }
+}
+exports.detectCreateReactApp = detectCreateReactApp;

package/dist/utils/error.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Represents an error that doesn't need to be forwarded to Sentry.
+ * These are errors that are user-fault, for example:
+ * - Using an old version of CLI
+ */
+export declare class HandledError extends Error {
+}
+/**
+ * Catches HandledErrors and just exits
+ * Forwards all other errors along.
+ * @param p
+ * @returns
+ */
+export declare const handleError: <T>(p: Promise<T>) => Promise<T>;

package/dist/utils/error.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleError = exports.HandledError = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const deps_1 = require("../deps");
+const npm_utils_1 = require("./npm-utils");
+/**
+ * Represents an error that doesn't need to be forwarded to Sentry.
+ * These are errors that are user-fault, for example:
+ * - Using an old version of CLI
+ */
+class HandledError extends Error {
+}
+exports.HandledError = HandledError;
+/**
+ * Catches HandledErrors and just exits
+ * Forwards all other errors along.
+ * @param p
+ * @returns
+ */
+exports.handleError = (p) => {
+    return p.catch((e) => {
+        if (e.message) {
+            deps_1.logger.error(chalk_1.default.bold(chalk_1.default.redBright("\nPlasmic error: ")) + e.message);
+        }
+        // Check if we satisfy the engine policy first
+        if (npm_utils_1.checkEngineStrict()) {
+            // eslint-disable-next-line
+            process.exit(1);
+        }
+        else if (e instanceof HandledError) {
+            // eslint-disable-next-line
+            process.exit(1);
+        }
+        else {
+            throw e;
+        }
+    });
+};

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

@@ -0,0 +1,71 @@
+/// <reference types="node" />
+import { ProjectMetaBundle } from "../api";
+import { PlasmicContext, ProjectConfig } from "./config-utils";
+export declare function stripExtension(filename: string, removeComposedPath?: boolean): string;
+export declare function writeFileContentRaw(filePath: string, content: string | Buffer, opts?: {
+    force?: boolean;
+    yes?: boolean;
+}): Promise<void>;
+export declare function defaultResourcePath(context: PlasmicContext, project: ProjectConfig | ProjectMetaBundle | string, ...subpaths: string[]): string;
+export declare function defaultPublicResourcePath(context: PlasmicContext, project: ProjectConfig, ...subpaths: string[]): string;
+export declare function defaultPagePath(context: PlasmicContext, fileName: string): string;
+export declare function writeFileContent(context: PlasmicContext, srcDirFilePath: string, content: string | Buffer, opts?: {
+    force?: boolean;
+}): Promise<void>;
+export declare function readFileContent(context: PlasmicContext, srcDirFilePath: string): string;
+export declare function deleteFile(context: PlasmicContext, srcDirFilePath: string): void;
+export declare function fileExists(context: PlasmicContext, srcDirFilePath: string): boolean;
+export declare function makeFilePath(context: PlasmicContext, filePath: string): string;
+export declare function renameFile(context: PlasmicContext, oldPath: string, newPath: string): void;
+/**
+ * Returns absolute paths of all Plasmic managed files found, grouped by each basename
+ * for example:
+ * {
+ * "file.txt": [ "/path1/file.txt", "/path2.txt" ]
+ * ...
+ * }
+ * @param {PlasmicContext} context
+ * @returns {Record<string, string[]>}
+ **/
+export declare function buildBaseNameToFiles(context: PlasmicContext): Record<string, string[]>;
+/**
+ * Tries to find the file at `srcDir/expectedPath`.  If it's not there, tries to detect if it has
+ * been moved to a different location.  Returns the found location relative to the `srcDir`.
+ *
+ * If `expectedPath` doesn't exist, but there's more than one file of that name in `baseNameToFiles`, then
+ * error and quit.  If no file of that name can be found, `expectedPath` is returned.
+ */
+export declare function findSrcDirPath(absoluteSrcDir: string, expectedPath: string, baseNameToFiles: Record<string, string[]>): string;
+/**
+ * Finds the full path to the first file satisfying `pred` in `dir`.  If
+ * `opts.traverseParents` is set to true, then will also look in ancestor
+ * directories until the plasmic.json file is found.  If none is found,
+ * returns undefined.
+ */
+export declare function findFile(dir: string, pred: (name: string) => boolean, opts: {
+    traverseParents?: boolean;
+}): string | undefined;
+/**
+ * Fixes all src-relative file paths in PlasmicConfig by detecting file
+ * movement on disk.
+ */
+export declare function fixAllFilePaths(context: PlasmicContext, baseDir: string): Promise<void>;
+/**
+ * Throws an error if some file in PlasmicConfig is not inside the root
+ * directory (i.e., the directory containing plasmic.json).
+ */
+export declare function assertAllPathsInRootDir(context: PlasmicContext): void;
+/**
+ * This turns on buffering of file writes/reads.
+ *
+ * This is useful for reducing the extent to which our file updates are scattered over time, which can cause webpack
+ * dev server to trip up.
+ *
+ * This also has the side benefit of making our CLI commands more atomic, in case of failure partway through a sync.
+ */
+export declare function withBufferedFs(f: () => Promise<void>): Promise<void>;
+export declare function writeFileText(path: string, content: string | Buffer): void;
+export declare function readFileText(path: string): string;
+export declare function renameFileBuffered(oldPath: string, newPath: string): void;
+export declare function deleteFileBuffered(path: string): void;
+export declare function existsBuffered(path: string): boolean;