@plasmicapp/cli 0.1.162

package/dist/actions/sync-components.js

@@ -0,0 +1,242 @@
+"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.syncProjectComponents = void 0;
+const code_merger_1 = require("@plasmicapp/code-merger");
+const lodash_1 = __importDefault(require("lodash"));
+const upath_1 = __importDefault(require("upath"));
+const api_1 = require("../api");
+const deps_1 = require("../deps");
+const code_utils_1 = require("../utils/code-utils");
+const config_utils_1 = require("../utils/config-utils");
+const error_1 = require("../utils/error");
+const file_utils_1 = require("../utils/file-utils");
+const lang_utils_1 = require("../utils/lang-utils");
+const user_utils_1 = require("../utils/user-utils");
+const updateDirectSkeleton = (newFileContent, editedFileContent, context, compConfig, forceOverwrite, nameInIdToUuid, appendJsxOnMissingBase) => __awaiter(void 0, void 0, void 0, function* () {
+    // merge code!
+    const componentByUuid = new Map();
+    componentByUuid.set(compConfig.id, {
+        editedFile: editedFileContent,
+        newFile: newFileContent,
+        newNameInIdToUuid: new Map(nameInIdToUuid),
+    });
+    const mergedFiles = yield code_merger_1.mergeFiles(componentByUuid, compConfig.projectId, code_merger_1.makeCachedProjectSyncDataProvider((projectId, revision) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            return yield context.api.projectSyncMetadata(projectId, revision, true);
+        }
+        catch (e) {
+            if (e instanceof api_1.AppServerError &&
+                /revision \d+ not found/.test(e.message)) {
+                throw e;
+            }
+            else {
+                throw new error_1.HandledError(e.messag);
+            }
+        }
+    })), () => { }, appendJsxOnMissingBase);
+    const merged = mergedFiles === null || mergedFiles === void 0 ? void 0 : mergedFiles.get(compConfig.id);
+    if (merged) {
+        yield file_utils_1.writeFileContent(context, compConfig.importSpec.modulePath, merged, {
+            force: true,
+        });
+    }
+    else {
+        if (!forceOverwrite) {
+            throw new error_1.HandledError(`Cannot merge ${compConfig.importSpec.modulePath}. If you just switched the code scheme for the component from blackbox to direct, use --force-overwrite option to force the switch.`);
+        }
+        else {
+            deps_1.logger.warn(`Overwrite ${compConfig.importSpec.modulePath} despite merge failure`);
+            yield file_utils_1.writeFileContent(context, compConfig.importSpec.modulePath, newFileContent, {
+                force: true,
+            });
+        }
+    }
+});
+function syncProjectComponents(context, project, version, componentBundles, forceOverwrite, appendJsxOnMissingBase, summary, pendingMerge, projectLock, checksums, baseDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const componentsFromChecksums = new Set([
+            ...checksums.cssRulesChecksums.map(([id, _]) => id),
+            checksums.renderModuleChecksums.map(([id, _]) => id),
+        ]);
+        const allCompConfigs = lodash_1.default.keyBy(project.components, (c) => c.id);
+        const componentBundleIds = lodash_1.default.keyBy(componentBundles, (i) => i.id);
+        const deletedComponents = lodash_1.default.filter(allCompConfigs, (i) => !componentBundleIds[i.id] && !componentsFromChecksums.has(i.id));
+        const renderModuleFileLocks = lodash_1.default.keyBy(projectLock.fileLocks.filter((fileLock) => fileLock.type === "renderModule"), (fl) => fl.assetId);
+        const cssRulesFileLocks = lodash_1.default.keyBy(projectLock.fileLocks.filter((fileLock) => fileLock.type === "cssRules"), (fl) => fl.assetId);
+        const id2RenderModuleChecksum = new Map(checksums.renderModuleChecksums);
+        const id2CssRulesChecksum = new Map(checksums.cssRulesChecksums);
+        const deletedComponentFiles = new Set();
+        for (const deletedComponent of deletedComponents) {
+            const componentConfig = allCompConfigs[deletedComponent.id];
+            if (file_utils_1.fileExists(context, componentConfig.renderModuleFilePath) &&
+                file_utils_1.fileExists(context, componentConfig.cssFilePath)) {
+                deps_1.logger.info(`Deleting component: ${componentConfig.name}@${version}\t['${project.projectName}' ${project.projectId}/${componentConfig.id} ${project.version}]`);
+                file_utils_1.deleteFile(context, componentConfig.renderModuleFilePath);
+                file_utils_1.deleteFile(context, componentConfig.cssFilePath);
+                deletedComponentFiles.add(deletedComponent.id);
+                const skeletonPath = componentConfig.importSpec.modulePath;
+                if (file_utils_1.fileExists(context, skeletonPath)) {
+                    const deleteSkeleton = yield user_utils_1.confirmWithUser(`Do you want to delete ${skeletonPath}?`, context.cliArgs.yes);
+                    if (deleteSkeleton) {
+                        file_utils_1.deleteFile(context, skeletonPath);
+                    }
+                }
+            }
+        }
+        project.components = project.components.filter((c) => !deletedComponentFiles.has(c.id));
+        const deletedComponentIds = new Set(deletedComponents.map((i) => i.id));
+        projectLock.fileLocks = projectLock.fileLocks.filter((fileLock) => (fileLock.type !== "renderModule" && fileLock.type !== "cssRules") ||
+            !deletedComponentIds.has(fileLock.assetId));
+        for (const bundle of componentBundles) {
+            const { renderModule, skeletonModule, cssRules, renderModuleFileName, skeletonModuleFileName, cssFileName, componentName, id, scheme, nameInIdToUuid, isPage, plumeType, } = bundle;
+            if (context.cliArgs.quiet !== true) {
+                deps_1.logger.info(`Syncing component: ${componentName}@${version}\t['${project.projectName}' ${project.projectId}/${id} ${project.version}]`);
+            }
+            let compConfig = allCompConfigs[id];
+            // A component should be regenerated if it is new or path-related information (like the name)
+            // changed.
+            const shouldRegenerate = (compConfig === null || compConfig === void 0 ? void 0 : compConfig.name) !== componentName;
+            let skeletonModuleModified = shouldRegenerate;
+            const skeletonPath = isPage
+                ? file_utils_1.defaultPagePath(context, skeletonModuleFileName)
+                : skeletonModuleFileName;
+            const defaultRenderModuleFilePath = file_utils_1.defaultResourcePath(context, project, renderModuleFileName);
+            const defaultCssFilePath = file_utils_1.defaultResourcePath(context, project, cssFileName);
+            if (shouldRegenerate) {
+                project.components = project.components.filter((existingComponent) => existingComponent.id !== id);
+                compConfig = {
+                    id,
+                    name: componentName,
+                    type: "managed",
+                    projectId: project.projectId,
+                    renderModuleFilePath: defaultRenderModuleFilePath,
+                    importSpec: { modulePath: skeletonPath },
+                    cssFilePath: defaultCssFilePath,
+                    scheme: scheme,
+                    componentType: isPage ? "page" : "component",
+                    plumeType,
+                };
+                allCompConfigs[id] = compConfig;
+                project.components.push(allCompConfigs[id]);
+                // Because it's the first time, we also generate the skeleton file.
+                yield file_utils_1.writeFileContent(context, skeletonPath, skeletonModule, {
+                    force: false,
+                });
+            }
+            else if (compConfig.type === "mapped") {
+            }
+            else if (compConfig.type === "managed") {
+                // This is an existing component.
+                // We only bother touching files on disk if this component is managed.
+                compConfig.componentType = isPage ? "page" : "component";
+                // Read in the existing file
+                let editedFile;
+                try {
+                    editedFile = file_utils_1.readFileContent(context, compConfig.importSpec.modulePath);
+                }
+                catch (e) {
+                    deps_1.logger.warn(`${compConfig.importSpec.modulePath} is missing. If you deleted this component, remember to remove the component from ${config_utils_1.CONFIG_FILE_NAME}`);
+                    throw e;
+                }
+                const renderModuleFilePath = upath_1.default.join(upath_1.default.dirname(compConfig.renderModuleFilePath), upath_1.default.basename(defaultRenderModuleFilePath));
+                if (compConfig.renderModuleFilePath !== renderModuleFilePath &&
+                    file_utils_1.fileExists(context, compConfig.renderModuleFilePath)) {
+                    if (context.cliArgs.quiet !== true) {
+                        deps_1.logger.info(`Renaming component file: ${compConfig.renderModuleFilePath}@${version}\t['${project.projectName}' ${project.projectId}/${id} ${project.version}]`);
+                    }
+                    file_utils_1.renameFile(context, compConfig.renderModuleFilePath, renderModuleFilePath);
+                    compConfig.renderModuleFilePath = renderModuleFilePath;
+                }
+                const cssFilePath = upath_1.default.join(upath_1.default.dirname(compConfig.cssFilePath), upath_1.default.basename(defaultCssFilePath));
+                if (compConfig.cssFilePath !== cssFilePath &&
+                    file_utils_1.fileExists(context, compConfig.cssFilePath)) {
+                    if (context.cliArgs.quiet !== true) {
+                        deps_1.logger.info(`Renaming component css file: ${compConfig.cssFilePath}@${version}\t['${project.projectName}' ${project.projectId}/${id} ${project.version}]`);
+                    }
+                    file_utils_1.renameFile(context, compConfig.cssFilePath, cssFilePath);
+                    compConfig.cssFilePath = cssFilePath;
+                }
+                if (isPage &&
+                    config_utils_1.isPageAwarePlatform(context.config.platform) &&
+                    skeletonPath !== compConfig.importSpec.modulePath &&
+                    file_utils_1.fileExists(context, compConfig.importSpec.modulePath)) {
+                    if (context.cliArgs.quiet !== true) {
+                        deps_1.logger.info(`Renaming page file: ${compConfig.importSpec.modulePath} -> ${skeletonPath}\t['${project.projectName}' ${project.projectId}/${id} ${project.version}]`);
+                    }
+                    file_utils_1.renameFile(context, compConfig.importSpec.modulePath, skeletonPath);
+                    compConfig.importSpec.modulePath = skeletonPath;
+                }
+                compConfig.plumeType = plumeType;
+                if (scheme === "direct") {
+                    // We cannot merge right now, but wait until all the imports are resolved
+                    pendingMerge.push({
+                        skeletonModulePath: compConfig.importSpec.modulePath,
+                        editedSkeletonFile: editedFile,
+                        newSkeletonFile: skeletonModule,
+                        merge: (resolvedNewFile, resolvedEditedFile) => __awaiter(this, void 0, void 0, function* () {
+                            return updateDirectSkeleton(resolvedNewFile, resolvedEditedFile, context, compConfig, forceOverwrite, nameInIdToUuid, appendJsxOnMissingBase);
+                        }),
+                    });
+                    skeletonModuleModified = true;
+                }
+                else if (/\/\/\s*plasmic-managed-jsx\/\d+/.test(editedFile)) {
+                    if (forceOverwrite) {
+                        skeletonModuleModified = true;
+                        yield file_utils_1.writeFileContent(context, compConfig.importSpec.modulePath, skeletonModule, {
+                            force: true,
+                        });
+                    }
+                    else {
+                        deps_1.logger.warn(`file ${compConfig.importSpec.modulePath} is likely in "direct" scheme. If you intend to switch the code scheme from direct to blackbox, use --force-overwrite option to force the switch.`);
+                    }
+                }
+            }
+            lang_utils_1.assert(lodash_1.default.isArray(projectLock.fileLocks));
+            // Update FileLocks
+            if (renderModuleFileLocks[id]) {
+                renderModuleFileLocks[id].checksum = lang_utils_1.ensure(id2RenderModuleChecksum.get(id));
+            }
+            else {
+                projectLock.fileLocks.push({
+                    type: "renderModule",
+                    assetId: id,
+                    checksum: lang_utils_1.ensure(id2RenderModuleChecksum.get(id)),
+                });
+            }
+            if (cssRulesFileLocks[id]) {
+                cssRulesFileLocks[id].checksum = lang_utils_1.ensure(id2CssRulesChecksum.get(id));
+            }
+            else {
+                projectLock.fileLocks.push({
+                    type: "cssRules",
+                    assetId: id,
+                    checksum: lang_utils_1.ensure(id2CssRulesChecksum.get(id)),
+                });
+            }
+            if (compConfig.type === "managed") {
+                // Again, only need to touch files on disk if managed
+                yield file_utils_1.writeFileContent(context, compConfig.renderModuleFilePath, renderModule, {
+                    force: !shouldRegenerate,
+                });
+                const formattedCssRules = code_utils_1.formatAsLocal(cssRules, compConfig.cssFilePath, baseDir);
+                yield file_utils_1.writeFileContent(context, compConfig.cssFilePath, formattedCssRules, {
+                    force: !shouldRegenerate,
+                });
+            }
+            summary.set(id, { skeletonModuleModified });
+        }
+    });
+}
+exports.syncProjectComponents = syncProjectComponents;

package/dist/actions/sync-global-variants.d.ts

@@ -0,0 +1,3 @@
+import { ChecksumBundle, GlobalVariantBundle, ProjectMetaBundle } from "../api";
+import { PlasmicContext } from "../utils/config-utils";
+export declare function syncGlobalVariants(context: PlasmicContext, projectMeta: ProjectMetaBundle, bundles: GlobalVariantBundle[], checksums: ChecksumBundle, baseDir: string): Promise<void>;

package/dist/actions/sync-global-variants.js

@@ -0,0 +1,89 @@
+"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.syncGlobalVariants = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const upath_1 = __importDefault(require("upath"));
+const deps_1 = require("../deps");
+const code_utils_1 = require("../utils/code-utils");
+const config_utils_1 = require("../utils/config-utils");
+const file_utils_1 = require("../utils/file-utils");
+const lang_utils_1 = require("../utils/lang-utils");
+function syncGlobalVariants(context, projectMeta, bundles, checksums, baseDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const projectId = projectMeta.projectId;
+        const projectLock = config_utils_1.getOrAddProjectLock(context, projectId);
+        const existingVariantConfigs = lodash_1.default.keyBy(context.config.globalVariants.variantGroups.filter((group) => group.projectId === projectId), (c) => c.id);
+        const globalVariantFileLocks = lodash_1.default.keyBy(projectLock.fileLocks.filter((fileLock) => fileLock.type === "globalVariant"), (fl) => fl.assetId);
+        const id2VariantChecksum = new Map(checksums.globalVariantChecksums);
+        const variantBundleIds = lodash_1.default.keyBy(bundles, (i) => i.id);
+        const deletedGlobalVariants = lodash_1.default.filter(existingVariantConfigs, (i) => !variantBundleIds[i.id] && !id2VariantChecksum.has(i.id));
+        for (const bundle of bundles) {
+            if (context.cliArgs.quiet !== true) {
+                deps_1.logger.info(`Syncing global variant ${bundle.name} [${projectId}/${bundle.id}]`);
+            }
+            let variantConfig = existingVariantConfigs[bundle.id];
+            const isNew = !variantConfig;
+            const defaultContextFilePath = file_utils_1.defaultResourcePath(context, projectMeta, bundle.contextFileName);
+            if (isNew) {
+                variantConfig = {
+                    id: bundle.id,
+                    name: bundle.name,
+                    projectId,
+                    contextFilePath: defaultContextFilePath,
+                };
+                existingVariantConfigs[bundle.id] = variantConfig;
+                context.config.globalVariants.variantGroups.push(variantConfig);
+            }
+            else {
+                const contextFilePath = upath_1.default.join(upath_1.default.dirname(variantConfig.contextFilePath), upath_1.default.basename(defaultContextFilePath));
+                if (variantConfig.contextFilePath !== contextFilePath &&
+                    file_utils_1.fileExists(context, variantConfig.contextFilePath)) {
+                    if (context.cliArgs.quiet !== true) {
+                        deps_1.logger.info(`Renaming global variant: ${variantConfig.name} [${projectId}/${bundle.id}]`);
+                    }
+                    file_utils_1.renameFile(context, variantConfig.contextFilePath, contextFilePath);
+                    variantConfig.contextFilePath = contextFilePath;
+                }
+                variantConfig.name = bundle.name;
+            }
+            // Update FileLocks
+            if (globalVariantFileLocks[bundle.id]) {
+                globalVariantFileLocks[bundle.id].checksum = lang_utils_1.ensure(id2VariantChecksum.get(bundle.id));
+            }
+            else {
+                projectLock.fileLocks.push({
+                    type: "globalVariant",
+                    assetId: bundle.id,
+                    checksum: lang_utils_1.ensure(id2VariantChecksum.get(bundle.id)),
+                });
+            }
+            yield file_utils_1.writeFileContent(context, variantConfig.contextFilePath, code_utils_1.formatAsLocal(bundle.contextModule, variantConfig.contextFilePath, baseDir), { force: !isNew });
+        }
+        const deletedVariantsFiles = new Set();
+        for (const deletedGlobalVariant of deletedGlobalVariants) {
+            const variantConfig = existingVariantConfigs[deletedGlobalVariant.id];
+            if (file_utils_1.fileExists(context, variantConfig.contextFilePath)) {
+                deps_1.logger.info(`Deleting global variant: ${variantConfig.name} [${projectId}/${deletedGlobalVariant.id}]`);
+                file_utils_1.deleteFile(context, variantConfig.contextFilePath);
+                deletedVariantsFiles.add(deletedGlobalVariant.id);
+            }
+        }
+        context.config.globalVariants.variantGroups = context.config.globalVariants.variantGroups.filter((v) => !deletedVariantsFiles.has(v.id));
+        const deletedVariantIds = new Set(deletedGlobalVariants.map((i) => i.id));
+        projectLock.fileLocks = projectLock.fileLocks.filter((fileLock) => fileLock.type !== "globalVariant" ||
+            !deletedVariantIds.has(fileLock.assetId));
+    });
+}
+exports.syncGlobalVariants = syncGlobalVariants;

package/dist/actions/sync-icons.d.ts

@@ -0,0 +1,7 @@
+import { CommonArgs } from "..";
+import { ChecksumBundle, IconBundle } from "../api";
+import { PlasmicContext } from "../utils/config-utils";
+export interface SyncIconsArgs extends CommonArgs {
+    projects: readonly string[];
+}
+export declare function syncProjectIconAssets(context: PlasmicContext, projectId: string, version: string, iconBundles: IconBundle[], checksums: ChecksumBundle, baseDir: string): Promise<void>;

package/dist/actions/sync-icons.js

@@ -0,0 +1,92 @@
+"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.syncProjectIconAssets = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const upath_1 = __importDefault(require("upath"));
+const deps_1 = require("../deps");
+const code_utils_1 = require("../utils/code-utils");
+const config_utils_1 = require("../utils/config-utils");
+const file_utils_1 = require("../utils/file-utils");
+const lang_utils_1 = require("../utils/lang-utils");
+function syncProjectIconAssets(context, projectId, version, iconBundles, checksums, baseDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const project = config_utils_1.getOrAddProjectConfig(context, projectId);
+        if (!project.icons) {
+            project.icons = [];
+        }
+        const projectLock = config_utils_1.getOrAddProjectLock(context, projectId);
+        const knownIconConfigs = lodash_1.default.keyBy(project.icons, (i) => i.id);
+        const iconFileLocks = lodash_1.default.keyBy(projectLock.fileLocks.filter((fileLock) => fileLock.type === "icon"), (fl) => fl.assetId);
+        const id2IconChecksum = new Map(checksums.iconChecksums);
+        const iconBundleIds = lodash_1.default.keyBy(iconBundles, (i) => i.id);
+        const deletedIcons = lodash_1.default.filter(knownIconConfigs, (i) => !iconBundleIds[i.id] && !id2IconChecksum.has(i.id));
+        for (const bundle of iconBundles) {
+            if (context.cliArgs.quiet !== true) {
+                deps_1.logger.info(`Syncing icon: ${bundle.name}@${version}\t['${project.projectName}' ${project.projectId}/${bundle.id} ${project.version}]`);
+            }
+            let iconConfig = knownIconConfigs[bundle.id];
+            const isNew = !iconConfig;
+            const defaultModuleFilePath = file_utils_1.defaultResourcePath(context, project, "icons", bundle.fileName);
+            if (isNew) {
+                iconConfig = {
+                    id: bundle.id,
+                    name: bundle.name,
+                    moduleFilePath: defaultModuleFilePath,
+                };
+                knownIconConfigs[bundle.id] = iconConfig;
+                project.icons.push(iconConfig);
+            }
+            else {
+                const moduleFilePath = upath_1.default.join(upath_1.default.dirname(iconConfig.moduleFilePath), upath_1.default.basename(defaultModuleFilePath));
+                if (iconConfig.moduleFilePath !== moduleFilePath &&
+                    file_utils_1.fileExists(context, iconConfig.moduleFilePath)) {
+                    if (context.cliArgs.quiet !== true) {
+                        deps_1.logger.info(`Renaming icon: ${iconConfig.name}@${version}\t['${project.projectName}' ${project.projectId}/${bundle.id} ${project.version}]`);
+                    }
+                    file_utils_1.renameFile(context, iconConfig.moduleFilePath, moduleFilePath);
+                    iconConfig.moduleFilePath = moduleFilePath;
+                }
+                iconConfig.name = bundle.name;
+            }
+            // Update FileLocks
+            if (iconFileLocks[bundle.id]) {
+                iconFileLocks[bundle.id].checksum = lang_utils_1.ensure(id2IconChecksum.get(bundle.id));
+            }
+            else {
+                projectLock.fileLocks.push({
+                    type: "icon",
+                    assetId: bundle.id,
+                    checksum: lang_utils_1.ensure(id2IconChecksum.get(bundle.id)),
+                });
+            }
+            yield file_utils_1.writeFileContent(context, iconConfig.moduleFilePath, code_utils_1.formatAsLocal(bundle.module, iconConfig.moduleFilePath, baseDir), {
+                force: !isNew,
+            });
+        }
+        const deletedIconFiles = new Set();
+        for (const deletedIcon of deletedIcons) {
+            const iconConfig = knownIconConfigs[deletedIcon.id];
+            if (file_utils_1.fileExists(context, iconConfig.moduleFilePath)) {
+                deps_1.logger.info(`Deleting icon: ${iconConfig.name}@${version}\t['${project.projectName}' ${project.projectId}/${deletedIcon.id} ${project.version}]`);
+                file_utils_1.deleteFile(context, iconConfig.moduleFilePath);
+                deletedIconFiles.add(deletedIcon.id);
+            }
+        }
+        project.icons = project.icons.filter((i) => !deletedIconFiles.has(i.id));
+        const deletedIconIds = new Set(deletedIcons.map((i) => i.id));
+        projectLock.fileLocks = projectLock.fileLocks.filter((fileLock) => fileLock.type !== "icon" || !deletedIconIds.has(fileLock.assetId));
+    });
+}
+exports.syncProjectIconAssets = syncProjectIconAssets;

package/dist/actions/sync-images.d.ts

@@ -0,0 +1,6 @@
+import { ChecksumBundle, ImageBundle } from "../api";
+import { FixImportContext } from "../utils/code-utils";
+import { PlasmicContext } from "../utils/config-utils";
+export declare function syncProjectImageAssets(context: PlasmicContext, projectId: string, version: string, imageBundles: ImageBundle[], checksums: ChecksumBundle): Promise<void>;
+export declare function fixComponentCssReferences(context: PlasmicContext, fixImportContext: FixImportContext, cssFilePath: string): Promise<void>;
+export declare function fixComponentImagesReferences(context: PlasmicContext, fixImportContext: FixImportContext, renderModuleFilePath: string): Promise<boolean>;

package/dist/actions/sync-images.js

@@ -0,0 +1,137 @@
+"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.fixComponentImagesReferences = exports.fixComponentCssReferences = exports.syncProjectImageAssets = void 0;
+const lodash_1 = __importDefault(require("lodash"));
+const upath_1 = __importDefault(require("upath"));
+const deps_1 = require("../deps");
+const config_utils_1 = require("../utils/config-utils");
+const file_utils_1 = require("../utils/file-utils");
+const lang_utils_1 = require("../utils/lang-utils");
+function syncProjectImageAssets(context, projectId, version, imageBundles, checksums) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const project = config_utils_1.getOrAddProjectConfig(context, projectId);
+        const projectLock = config_utils_1.getOrAddProjectLock(context, projectId);
+        const knownImageConfigs = lodash_1.default.keyBy(project.images, (i) => i.id);
+        const imageBundleIds = lodash_1.default.keyBy(imageBundles, (i) => i.id);
+        const imageFileLocks = lodash_1.default.keyBy(projectLock.fileLocks.filter((fileLock) => fileLock.type === "image"), (fl) => fl.assetId);
+        const id2ImageChecksum = new Map(checksums.imageChecksums);
+        const deletedImages = lodash_1.default.filter(knownImageConfigs, (i) => !imageBundleIds[i.id] && !id2ImageChecksum.has(i.id));
+        for (const bundle of imageBundles) {
+            if (context.cliArgs.quiet !== true) {
+                deps_1.logger.info(`Syncing image: ${bundle.name}@${version}\t['${project.projectName}' ${project.projectId}/${bundle.id} ${project.version}]`);
+            }
+            let imageConfig = knownImageConfigs[bundle.id];
+            const isNew = !imageConfig;
+            const defaultFilePath = context.config.images.scheme === "public-files"
+                ? file_utils_1.defaultPublicResourcePath(context, project, "images", bundle.fileName)
+                : file_utils_1.defaultResourcePath(context, project, "images", bundle.fileName);
+            if (isNew) {
+                imageConfig = {
+                    id: bundle.id,
+                    name: bundle.name,
+                    filePath: defaultFilePath,
+                };
+                project.images.push(imageConfig);
+            }
+            else {
+                const filePath = upath_1.default.join(upath_1.default.dirname(imageConfig.filePath), upath_1.default.basename(defaultFilePath));
+                if (imageConfig.filePath !== filePath &&
+                    file_utils_1.fileExists(context, imageConfig.filePath)) {
+                    if (context.cliArgs.quiet !== true) {
+                        deps_1.logger.info(`Renaming image: ${imageConfig.name}@${version}\t['${project.projectName}' ${project.projectId}/${bundle.id} ${project.version}]`);
+                    }
+                    file_utils_1.renameFile(context, imageConfig.filePath, filePath);
+                    imageConfig.filePath = filePath;
+                }
+                imageConfig.name = bundle.name;
+            }
+            // Update FileLocks
+            if (imageFileLocks[bundle.id]) {
+                imageFileLocks[bundle.id].checksum = lang_utils_1.ensure(id2ImageChecksum.get(bundle.id));
+            }
+            else {
+                projectLock.fileLocks.push({
+                    type: "image",
+                    assetId: bundle.id,
+                    checksum: lang_utils_1.ensure(id2ImageChecksum.get(bundle.id)),
+                });
+            }
+            yield file_utils_1.writeFileContent(context, imageConfig.filePath, Buffer.from(bundle.blob, "base64"), {
+                force: !isNew,
+            });
+        }
+        const deletedImageFiles = new Set();
+        for (const deletedImage of deletedImages) {
+            const imageConfig = knownImageConfigs[deletedImage.id];
+            if (file_utils_1.fileExists(context, imageConfig.filePath)) {
+                deps_1.logger.info(`Deleting image: ${imageConfig.name}@${version}\t['${project.projectName}' ${project.projectId}/${deletedImage.id} ${project.version}]`);
+                file_utils_1.deleteFile(context, imageConfig.filePath);
+                deletedImageFiles.add(deletedImage.id);
+            }
+        }
+        project.images = project.images.filter((i) => !deletedImageFiles.has(i.id));
+        const deletedImageIds = new Set(deletedImages.map((i) => i.id));
+        projectLock.fileLocks = projectLock.fileLocks.filter((fileLock) => fileLock.type !== "image" || !deletedImageIds.has(fileLock.assetId));
+    });
+}
+exports.syncProjectImageAssets = syncProjectImageAssets;
+const RE_ASSETCSSREF_ALL = /var\(--image-([^\)]+)\)/g;
+function fixComponentCssReferences(context, fixImportContext, cssFilePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!file_utils_1.fileExists(context, cssFilePath)) {
+            return;
+        }
+        const prevContent = file_utils_1.readFileContent(context, cssFilePath);
+        const newContent = prevContent.replace(RE_ASSETCSSREF_ALL, (sub, assetId) => {
+            const asset = fixImportContext.images[assetId];
+            if (asset) {
+                return context.config.images.scheme === "public-files"
+                    ? `url("${upath_1.default.join("/", lang_utils_1.ensure(context.config.images.publicUrlPrefix), upath_1.default.relative(lang_utils_1.ensure(context.config.images.publicDir), asset.filePath))}")`
+                    : `url("./${upath_1.default.relative(upath_1.default.dirname(cssFilePath), asset.filePath)}")`;
+            }
+            else {
+                return sub;
+            }
+        });
+        if (prevContent !== newContent) {
+            yield file_utils_1.writeFileContent(context, cssFilePath, newContent, { force: true });
+        }
+    });
+}
+exports.fixComponentCssReferences = fixComponentCssReferences;
+const RE_ASSETTSXREF_ALL = /Plasmic_Image_([^\)\s]+)__Ref/g;
+function fixComponentImagesReferences(context, fixImportContext, renderModuleFilePath) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const prevContent = file_utils_1.readFileContent(context, renderModuleFilePath);
+        const newContent = prevContent.replace(RE_ASSETTSXREF_ALL, (sub, assetId) => {
+            const asset = fixImportContext.images[assetId];
+            if (asset) {
+                return upath_1.default.join("/", lang_utils_1.ensure(context.config.images.publicUrlPrefix), upath_1.default.relative(lang_utils_1.ensure(context.config.images.publicDir), asset.filePath));
+            }
+            else {
+                return sub;
+            }
+        });
+        if (prevContent !== newContent) {
+            yield file_utils_1.writeFileContent(context, renderModuleFilePath, newContent, {
+                force: true,
+            });
+            // Returns true if the content changed
+            return true;
+        }
+        return false;
+    });
+}
+exports.fixComponentImagesReferences = fixComponentImagesReferences;

package/dist/actions/sync-styles.d.ts

@@ -0,0 +1,3 @@
+import { StyleTokensMap } from "../api";
+import { PlasmicContext } from "../utils/config-utils";
+export declare function upsertStyleTokens(context: PlasmicContext, newStyleMap: StyleTokensMap): Promise<void>;

package/dist/actions/sync-styles.js

@@ -0,0 +1,58 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.upsertStyleTokens = void 0;
+const error_1 = require("../utils/error");
+const file_utils_1 = require("../utils/file-utils");
+function upsertStyleTokens(context, newStyleMap) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const curStyleMap = yield readCurStyleMap(context);
+        for (const prop of newStyleMap.props) {
+            const index = curStyleMap.props.findIndex((p) => p.meta.id === prop.meta.id);
+            if (index >= 0) {
+                curStyleMap.props[index] = prop;
+            }
+            else {
+                curStyleMap.props.push(prop);
+            }
+        }
+        curStyleMap.props.sort((prop1, prop2) => prop1.name === prop2.name ? 0 : prop1.name < prop2.name ? -1 : 1);
+        yield file_utils_1.writeFileContent(context, context.config.tokens.tokensFilePath, JSON.stringify(curStyleMap, undefined, 2), { force: true });
+    });
+}
+exports.upsertStyleTokens = upsertStyleTokens;
+function readCurStyleMap(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const filePath = context.config.tokens.tokensFilePath;
+        if (file_utils_1.fileExists(context, filePath)) {
+            try {
+                return JSON.parse(file_utils_1.readFileContent(context, context.config.tokens.tokensFilePath));
+            }
+            catch (e) {
+                throw new error_1.HandledError(`Error encountered reading ${context.config.tokens.tokensFilePath}: ${e}`);
+            }
+        }
+        else {
+            const defaultMap = {
+                props: [],
+                global: {
+                    meta: {
+                        source: "plasmic.app",
+                    },
+                },
+            };
+            yield file_utils_1.writeFileContent(context, context.config.tokens.tokensFilePath, JSON.stringify(defaultMap, undefined, 2), {
+                force: false,
+            });
+            return defaultMap;
+        }
+    });
+}