@shoper/cli 0.6.4-2 → 0.7.1-1

package/build/theme/commands/watch/theme_watching_info.js

@@ -0,0 +1,14 @@
+import { Info } from '../../../ui/message_box/info.js';
+import React from 'react';
+import { Text } from '../../../ui/text.js';
+import { CSS_COLOR_TOKENS_VALUES } from '../../../ui/color_constants.js';
+import { COMMAND_PREFIX, WATCH_COMMANDS_NAMES } from './theme_watch_constants.js';
+export const ThemeWatchingInfo = ({ themeId, withPreview }) => {
+    return (React.createElement(Info, { header: `Watching theme (ID: ${themeId}) files for changes... ` },
+        React.createElement(Text, null, "Any modifications will be reflected in real-time."),
+        withPreview ? React.createElement(Text, null, "Live preview opened in your browser.") : null,
+        React.createElement(Text, { color: CSS_COLOR_TOKENS_VALUES.theme4 },
+            "(Press Ctrl+C or type ",
+            `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.quit}`,
+            " to stop watching)")));
+};

package/build/theme/commands/watch/watch.js

@@ -0,0 +1,55 @@
+import { ThemeWatchingInfo } from './theme_watching_info.js';
+import { Box } from '../../../ui/box.js';
+import React, { useEffect } from 'react';
+import { CommandInput } from '../../../ui/command_input/command_input.js';
+import { useApp } from 'ink';
+import { COMMAND_PREFIX, MAX_WATCH_LOGS, WATCH_COMMANDS, WATCH_COMMANDS_NAMES } from './theme_watch_constants.js';
+import { useLogs } from '../../../ui/logs/use_logs.js';
+import { LogsList } from '../../../ui/logs/logs_list.js';
+import { ThemeWatchUtils } from './theme_watch_utils.js';
+export const Watch = ({ executionContext, credentials, openBrowser, themeChecksums, themeFilesUploadApi, filesStructure, action, themeWatchApi }) => {
+    const { exit } = useApp();
+    const { logs, addLog, clearLogs } = useLogs(MAX_WATCH_LOGS);
+    useEffect(() => {
+        themeWatchApi.watchTheme({
+            themeChecksums,
+            executionContext,
+            credentials,
+            themeFilesUploadApi,
+            filesStructure,
+            action,
+            openBrowser,
+            onMessage: (log) => {
+                addLog(ThemeWatchUtils.mapAppLogToUiMessage(log));
+            }
+        });
+        return () => {
+            themeWatchApi.stopWatching();
+        };
+    }, []);
+    const handleCommandSubmit = async (value) => {
+        const command = value.trim();
+        addLog(`> ${command}`);
+        switch (command) {
+            case `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.open}`: {
+                await themeWatchApi.ensureBrowserTabOpen();
+                break;
+            }
+            case `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.quit}`: {
+                await themeWatchApi.stopWatching();
+                exit();
+                break;
+            }
+            case `${COMMAND_PREFIX}${WATCH_COMMANDS_NAMES.clear}`: {
+                clearLogs();
+                break;
+            }
+            default:
+                addLog(`Unknown command: ${command}`);
+        }
+    };
+    return (React.createElement(Box, { flexDirection: "column", padding: 1 },
+        React.createElement(ThemeWatchingInfo, { withPreview: openBrowser, themeId: executionContext.themeId }),
+        React.createElement(LogsList, { logs: logs }),
+        React.createElement(CommandInput, { commands: WATCH_COMMANDS, onSubmit: handleCommandSubmit })));
+};

package/build/theme/features/theme/actions/theme_actions_constants.js

@@ -8,7 +8,8 @@ export const THEME_ACTIONS_TYPES = {
     delete: 'delete',
     publishForm: 'publish_form',
     publish: 'publish',
-    verify: 'verify'
+    verify: 'verify',
+    partialPush: 'partial_push'
 };
 export const THEME_ACTION_DATA_TYPE = {
     file: 'file',

package/build/theme/features/theme/actions/theme_actions_utils.js

@@ -3,8 +3,10 @@ import { basename, looksLikeDirectory, toUnixPath } from '../../../../utils/path
 import { THEME_ACTION_DATA_TYPE } from './theme_actions_constants.js';
 import globs from 'fast-glob';
 import { THEME_PUSH_WILDCARD_GLOBS_FOR_FILES } from '../push/service/theme_push_service_constants.js';
+import micromatch from 'micromatch';
+import difference from 'lodash/difference.js';
 export class ThemeActionsUtils {
-    static getFilesGlobsThatMatchesActionName({ filesStructure, actionValue, actionType }) {
+    static getFilesGlobsThatMatchesAction({ filesStructure, actionValue, actionType }) {
         return Object.entries(filesStructure).reduce((acc, [filePath, fileStructureItem]) => {
             if (fileStructureItem._links?.[actionType] && this._doesActionValueMatch(fileStructureItem._links[actionType], actionValue)) {
                 return [...acc, toUnixPath(filePath)];
@@ -12,11 +14,32 @@ export class ThemeActionsUtils {
             return acc;
         }, []);
     }
-    static async getFilesRecordsFromActionData({ themeRootDir, themeAction, filesStructure }) {
+    static async getFilesThatMatchesAction({ actionType, actionValue, filesStructure, rootDir }) {
+        return await globs(ThemeActionsUtils.getFilesGlobsThatMatchesAction({
+            actionType,
+            actionValue,
+            filesStructure
+        }), {
+            suppressErrors: true,
+            onlyFiles: true,
+            cwd: rootDir
+        });
+    }
+    static async getDeletedFilesThatMatchesAction({ actionType, actionValue, themeChecksums, filesStructure }) {
+        const deletedFiles = await themeChecksums.getDeletedFiles();
+        const globs = ThemeActionsUtils.getFilesGlobsThatMatchesAction({
+            actionType,
+            actionValue,
+            filesStructure
+        });
+        return deletedFiles.filter((path) => !looksLikeDirectory(path) && micromatch.isMatch(path, globs));
+    }
+    static async getFilesRecordsFromActionData({ themeRootDir, themeAction, filesStructure, themeChecksums }) {
         const filesRecords = [];
+        const initialChecksums = await themeChecksums.getInitialChecksums();
         for (const [actionKey, actionData] of Object.entries(themeAction.data)) {
             if (actionData.type === THEME_ACTION_DATA_TYPE.file) {
-                const filesGlobs = ThemeActionsUtils.getFilesGlobsThatMatchesActionName({
+                const filesGlobs = ThemeActionsUtils.getFilesGlobsThatMatchesAction({
                     //TODO remove when backend fixed
                     actionType: 'push',
                     // actionType: themeAction.actionType,
@@ -24,6 +47,7 @@ export class ThemeActionsUtils {
                     filesStructure
                 });
                 for (const fileGlob of filesGlobs) {
+                    const checksumMatchedFiles = micromatch(Object.keys(initialChecksums), [fileGlob]);
                     const files = await globs(fileGlob, {
                         suppressErrors: true,
                         onlyFiles: true,
@@ -35,13 +59,15 @@ export class ThemeActionsUtils {
                             ? fileGlob.slice(0, fileGlob.length - 2)
                             : fileGlob;
                     }
-                    for (const filePath of files) {
+                    const deletedFiles = difference(checksumMatchedFiles, files);
+                    for (const filePath of [...files, ...deletedFiles]) {
                         filesRecords.push({
                             actionData,
                             actionKey,
                             path: filePath,
                             fileName: basename(filePath),
-                            fileGlob: processedFileGlob
+                            fileGlob: processedFileGlob,
+                            state: await themeChecksums.getFileState(filePath)
                         });
                     }
                 }
@@ -49,6 +75,35 @@ export class ThemeActionsUtils {
         }
         return filesRecords;
     }
+    // static async getFilesRecordsFromFiles({
+    //     files,
+    //     themeRootDir,
+    //     themeAction,
+    //     filesStructure,
+    //     themeChecksums
+    // }: {
+    //     files: string[];
+    //     themeRootDir: string;
+    //     themeAction: TThemeAction;
+    //     filesStructure: TThemeFilesStructure;
+    //     themeChecksums: ThemeChecksums;
+    // }): Promise<TFileRecord[]> {
+    //     const fileRecords: TFileRecord[] = [];
+    //
+    //     for (const file of files) {
+    //         const state = await themeChecksums.getFileState(file);
+    //
+    //         if (state) {
+    //             fileRecords.push({
+    //                 path: file,
+    //                 state,
+    //                 action: themeAction
+    //             });
+    //         }
+    //     }
+    //
+    //     return fileRecords;
+    // }
     static _doesActionValueMatch(currentActionValue, valuesToMatch) {
         if (typeof valuesToMatch === 'string') {
             return currentActionValue === valuesToMatch || valuesToMatch === THEME_ALL_ACTIONS_NAME;

package/build/theme/features/theme/fetch/service/theme_fetch_service.js

@@ -8,9 +8,9 @@ import { FetchResources } from '../../../../class/fetch_resources/fetch_resource
 import { jsonIndentTransform } from '../../../../../utils/stream_transforms/json_indent_transform.js';
 import { JSON_FILE_INDENT } from '../../../../../cli/cli_constants.js';
 import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
 import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 export class ThemeFetchService {
     #themeHttpApi;
     #httpApi;
@@ -55,7 +55,7 @@ export class ThemeFetchService {
         }
         try {
             this.#loggerApi.debug('Updating theme files structure.');
-            await ThemeFilesStructureUtils.updateFilesStructure(themeDir);
+            await ThemeFilesUtils.updateFilesStructure(themeDir);
         }
         catch (error) {
             throw new AppError({

package/build/theme/features/theme/init/service/theme_init_service.js

@@ -6,8 +6,8 @@ import { extractZip } from '../../../../../utils/zip/extract_zip_utils.js';
 import { ThemeMetaDataUtils } from '../../utils/meta_data/theme_meta_data_utils.js';
 import { ThemeInfoUtils } from '../../info/theme_info_utils.js';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 export class ThemeInitService {
     #httpApi;
     #loggerApi;
@@ -41,7 +41,7 @@ export class ThemeInitService {
         this.#loggerApi.info('Theme archive extracted.');
         try {
             this.#loggerApi.debug('Updating theme files structure.');
-            await ThemeFilesStructureUtils.updateFilesStructure(themeDir);
+            await ThemeFilesUtils.updateFilesStructure(themeDir);
         }
         catch (err) {
             throw new AppError({

package/build/theme/features/theme/merge/service/theme_merge_service.js

@@ -2,9 +2,9 @@ import FSTree from 'fs-tree-diff';
 import { copyFileSync, getAllDirectoriesNamesInside } from '../../../../../utils/fs/fs_utils.js';
 import walkSync from 'walk-sync';
 import { ThemeChecksums } from '../../../../class/checksums/theme_checksums.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
 import { join, platformSeparator } from '../../../../../utils/path_utils.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 export class ThemeMergeService {
     #loggerApi;
     constructor({ loggerApi }) {
@@ -73,7 +73,7 @@ export class ThemeMergeService {
         return patch;
     }
     async _getUserRootDirectories(themeDir) {
-        const filesStructure = await ThemeFilesStructureUtils.getThemeRootDirectories(themeDir);
+        const filesStructure = await ThemeFilesUtils.getThemeRootDirectories(themeDir);
         return (await getAllDirectoriesNamesInside(themeDir, {
             recursive: false,
             hidden: true

package/build/theme/features/theme/push/api/theme_push_api.js

@@ -7,7 +7,7 @@ export class ThemePushApi extends FeatureApi {
         super();
         this.#service = service;
     }
-    async push(props) {
-        return this.#service.push(props);
+    async partialPush(props) {
+        return this.#service.partialPush(props);
     }
 }

package/build/theme/features/theme/push/service/theme_push_service.js

@@ -1,19 +1,21 @@
 import tmp from 'tmp-promise';
 import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-import { join } from '../../../../../utils/path_utils.js';
+import { dirname, join } from '../../../../../utils/path_utils.js';
 import { v4 as uuid } from 'uuid';
 import { THEME_WILDCARD_ACTION_NAME } from '../../actions/service/theme_actions_service_constants.js';
-import { THEME_MODULE_SETTINGS_FILE_NAME } from '../theme_push_constants.js';
+import { THEME_FILES_LIST_FILE_NAME, THEME_MODULE_SETTINGS_FILE_NAME } from '../theme_push_constants.js';
 import { ThemePushErrorsFactory } from '../theme_push_errors_factory.js';
 import { ThemeImagesUtils } from '../../utils/theme_images_utils.js';
 import { ThemePublishUtils } from '../../skinstore/theme_publish_utils.js';
-import { writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { fileExists, getAllDirectoriesNamesInside, readJSONFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
 import { MODULES_DIRECTORY_NAME } from '../../theme_constants.js';
 import { removeOldResources } from '../../../../class/fetch_resources/fetch_resources_utils.js';
-import { ThemeArchive } from '../../../../class/archive/theme_archive.js';
-import { ThemeFilesStructureUtils } from '../../utils/files_structure/theme_files_structure_utils.js';
+import { ThemeFilesUtils } from '../../utils/files/theme_files_utils.js';
 import { ThemeActionsUtils } from '../../actions/theme_actions_utils.js';
-import { ArrayUtils } from '@dreamcommerce/utilities';
+import { ThemeArchiveUtils } from '../../utils/archive/theme_archive_utils.js';
+import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
+import uniq from 'lodash/uniq.js';
+import { FILES_LIST_CUSTOM_MODULES_TO_KEEP_IDS } from '../../utils/files/them_files_constants.js';
 export class ThemePushService {
     #themeFetchApi;
     #loggerApi;
@@ -21,8 +23,7 @@ export class ThemePushService {
         this.#themeFetchApi = themeFetchApi;
         this.#loggerApi = loggerApi;
     }
-    async push({ pushAction, credentials, filesStructure, executionContext, themeChecksums, themeFilesUploadApi }) {
-        this.#loggerApi.info('Pushing theme changes.');
+    async partialPush({ action, filesStructure, executionContext, themeChecksums, themeFilesUploadApi, credentials }) {
         const { path: tmpDir } = await tmp.dir({ unsafeCleanup: true });
         this.#loggerApi.debug('Temporary directory created.', { details: { path: tmpDir } });
         const themeRootDir = executionContext.themeRootDir;
@@ -30,48 +31,73 @@ export class ThemePushService {
             throw ThemePushErrorsFactory.createErrorWhilePushingUnpublishedThemeWithSkinstoreData(credentials.shopUrl);
         try {
             this.#loggerApi.debug('Getting file records from action data.');
+            //TODO to do api?
             const filesRecords = await ThemeActionsUtils.getFilesRecordsFromActionData({
                 themeRootDir,
-                themeAction: pushAction,
-                filesStructure
+                themeAction: action,
+                filesStructure,
+                themeChecksums
             });
             this.#loggerApi.debug('Filtering for created or modified files to upload.');
-            const filesToUpload = await ArrayUtils.asyncFilter(filesRecords, async ({ path }) => (await themeChecksums.hasThemeFileBeenCreated(path)) || (await themeChecksums.hasThemeFileBeenModified(path)));
+            const filesToUpload = filesRecords.filter(({ state }) => [FILE_STATES.modified, FILE_STATES.created].includes(state));
+            let localFileNameToUploaded;
             this.#loggerApi.debug('Files to upload determined.', { details: { count: filesToUpload.length } });
             if (filesToUpload.length) {
                 this.#loggerApi.info(`Uploading ${filesToUpload.length} theme files.`);
-                const { localFileNameToUploaded } = await this._uploadThemeFiles({
+                const uploadData = await this._uploadThemeFiles({
                     filesToUpload,
                     credentials,
                     themeRootDir,
                     themeFilesUploadApi
                 });
+                if (!uploadData.isSuccess)
+                    throw ThemePushErrorsFactory.createErrorWhileUploadingThemeFiles(credentials.shopUrl);
                 this.#loggerApi.info('Theme files uploaded.');
-                await this._createFilesList(themeRootDir, filesRecords, localFileNameToUploaded);
-            }
-            else {
-                this.#loggerApi.info('No new or modified files to upload. Creating files list for archive.');
-                await this._createFilesList(themeRootDir, filesRecords);
+                localFileNameToUploaded = uploadData.localFileNameToUploadedMap;
             }
             const themeArchivePath = join(tmpDir, `${uuid()}.zip`);
-            this.#loggerApi.info('Creating theme archive.');
-            await new ThemeArchive(themeRootDir).createFullArchive({
-                dist: themeArchivePath,
+            const filesInArchive = await ThemeActionsUtils.getFilesThatMatchesAction({
                 actionValue: THEME_WILDCARD_ACTION_NAME,
                 actionType: THEME_ACTIONS_TYPES.push,
-                logger: this.#loggerApi
+                filesStructure,
+                rootDir: themeRootDir
+            });
+            const groupedFiles = await themeChecksums.groupFilesByStatus(filesInArchive);
+            const deletedFiles = await ThemeActionsUtils.getDeletedFilesThatMatchesAction({
+                actionType: THEME_ACTIONS_TYPES.push,
+                actionValue: THEME_WILDCARD_ACTION_NAME,
+                themeChecksums,
+                filesStructure,
+                rootDir: themeRootDir
+            });
+            await this._createFilesList({
+                themeRootDir,
+                filesRecords,
+                localFileNameToUploaded,
+                deletedFiles,
+                //TODO catch error on settings failure
+                allCustomModulesIds: await this._getAllModulesIds(themeRootDir)
+            });
+            this.#loggerApi.info('Creating theme archive.');
+            const filestToArchive = [
+                ...(await this._appendSettingsIfNeeded([...groupedFiles.modified, ...groupedFiles.created])),
+                (await fileExists(ThemeFilesUtils.getFilesListFilePath(themeRootDir))) ? THEME_FILES_LIST_FILE_NAME : undefined
+            ].filter(Boolean);
+            await ThemeArchiveUtils.create({
+                dist: themeArchivePath,
+                rootDir: themeRootDir,
+                logger: this.#loggerApi,
+                files: filestToArchive
             });
             this.#loggerApi.info('Theme archive created.');
+            await ThemeFilesUtils.removeAFilesListFile(themeRootDir);
             const { resources, modules } = await themeFilesUploadApi.uploadArchive({
-                action: pushAction,
+                action,
                 themeArchivePath,
                 credentials
             });
-            this.#loggerApi.info('Theme archive uploaded.');
-            if (modules) {
-                this.#loggerApi.debug('Updating data for new modules.');
+            if (modules)
                 await this._updateDataForNewCreatedModules({ modules, themeRootDir });
-            }
             if (resources) {
                 this.#loggerApi.debug('Removing old resources.');
                 await removeOldResources(themeRootDir, resources);
@@ -80,12 +106,12 @@ export class ThemePushService {
                 this.#loggerApi.info('New resources fetched.');
             }
             this.#loggerApi.debug('Updating theme checksums.');
+            //TODO only changed files checksum
             await themeChecksums.updateAllChecksums();
-            this.#loggerApi.info('Push completed successfully.');
         }
-        finally {
-            this.#loggerApi.debug('Cleaning up files list.');
-            await ThemeFilesStructureUtils.removeAFilesListFile(themeRootDir);
+        catch (err) {
+            await ThemeFilesUtils.removeAFilesListFile(themeRootDir);
+            throw err;
         }
     }
     async _uploadThemeFiles({ filesToUpload, themeRootDir, credentials, themeFilesUploadApi }) {
@@ -103,7 +129,9 @@ export class ThemePushService {
                 await ThemeImagesUtils.removeUploadedOriginalFiles(themeRootDir, uploadedImageData);
             }
             return {
-                localFileNameToUploaded: uploadedImageData.reduce((acc, { originalFilename, uploadedFilename }) => {
+                isSuccess: rejectedImageData.length === 0,
+                rejectedImageData,
+                localFileNameToUploadedMap: uploadedImageData.reduce((acc, { originalFilename, uploadedFilename }) => {
                     return {
                         ...acc,
                         [originalFilename]: uploadedFilename ?? originalFilename
@@ -121,8 +149,40 @@ export class ThemePushService {
             await writeJSONFile(join(themeRootDir, MODULES_DIRECTORY_NAME, moduleDirectoryName, THEME_MODULE_SETTINGS_FILE_NAME), JSON.parse(metaData[THEME_MODULE_SETTINGS_FILE_NAME]));
         }
     }
-    async _createFilesList(themeRootDir, filesRecords, localFileNameToUploaded = {}) {
+    async _createFilesList({ deletedFiles, localFileNameToUploaded, filesRecords, themeRootDir, allCustomModulesIds }) {
         this.#loggerApi.debug('Creating filesList.json for the archive.');
-        await ThemeFilesStructureUtils.createAFilesListFile(themeRootDir, ThemeFilesStructureUtils.mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded));
+        const filesListContent = ThemeFilesUtils.mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded);
+        if (deletedFiles?.length)
+            filesListContent.removed = deletedFiles;
+        if (allCustomModulesIds?.length)
+            filesListContent[FILES_LIST_CUSTOM_MODULES_TO_KEEP_IDS] = allCustomModulesIds;
+        await ThemeFilesUtils.createAFilesListFile(themeRootDir, filesListContent);
+    }
+    async _appendSettingsIfNeeded(files) {
+        const withSettingsFiles = [...files];
+        for (const filePath of files) {
+            const settingsFilePath = join(dirname(filePath), 'settings.json');
+            const settingsExist = await fileExists(settingsFilePath);
+            if (settingsExist && !!(await readJSONFile(settingsFilePath))?.id) {
+                withSettingsFiles.push(join(dirname(filePath), 'settings.json'));
+            }
+        }
+        return uniq(withSettingsFiles);
+    }
+    async _getAllModulesIds(themeRootDir) {
+        const modulesPath = join(themeRootDir, MODULES_DIRECTORY_NAME);
+        if (!(await fileExists(modulesPath)))
+            return [];
+        const moduleDirs = await getAllDirectoriesNamesInside(modulesPath);
+        const modulesIds = [];
+        for (const moduleDir of moduleDirs) {
+            const moduleSettingsPath = join(themeRootDir, MODULES_DIRECTORY_NAME, moduleDir, THEME_MODULE_SETTINGS_FILE_NAME);
+            if (await fileExists(moduleSettingsPath)) {
+                const settingsContent = await readJSONFile(moduleSettingsPath);
+                if (settingsContent.id && Number.isInteger(settingsContent.id))
+                    modulesIds.push(settingsContent.id);
+            }
+        }
+        return modulesIds;
     }
 }

package/build/theme/features/theme/push/service/theme_push_service_types.js

@@ -0,0 +1 @@
+export {};

package/build/theme/features/theme/push/theme_push_utils.js

@@ -1,10 +1,10 @@
 import globs from 'fast-glob';
 import { AppError } from '../../../../cli/utilities/features/logger/logs/app_error.js';
 import { toUnixPath } from '../../../../utils/path_utils.js';
-import { ThemeFilesStructureUtils } from '../utils/files_structure/theme_files_structure_utils.js';
+import { ThemeFilesUtils } from '../utils/files/theme_files_utils.js';
 export class ThemePushUtils {
     static async getAllFilesThatAreSendToRemote(themeDir) {
-        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
+        const filesStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDir);
         if (!filesStructure)
             throw new AppError({
                 message: `Files structure not found in theme directory: ${themeDir}`,

package/build/theme/features/theme/utils/archive/theme_archive_utils.js

@@ -0,0 +1,26 @@
+import { createZip } from '../../../../../utils/zip/create_zip_utils.js';
+import { extname, join } from '../../../../../utils/path_utils.js';
+import { formatJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { ThemeArchiveErrorsFactory } from './theme_archive_utils_errors_factory.js';
+export class ThemeArchiveUtils {
+    static async create({ dist, files, rootDir, logger }) {
+        try {
+            // TODO spradzić czy potrzebne, ew po formatowanu sprawdzic czy plik sie zmienił jak nie to nie podmieniac contentu zformatowanego
+            // await this._formatJsonFiles(rootDir, files);
+            return createZip({
+                files,
+                baseDir: rootDir,
+                logger,
+                dist
+            });
+        }
+        catch (err) {
+            throw ThemeArchiveErrorsFactory.createErrorWhileCreatingThemeArchive(err);
+        }
+    }
+    static async _formatJsonFiles(themeRootDir, filesToUpload) {
+        await Promise.all(filesToUpload
+            .filter((path) => extname(path).toLowerCase() === '.json')
+            .map((jsonFile) => formatJSONFile(join(themeRootDir, jsonFile))));
+    }
+}

package/build/theme/{class/archive/theme_archive_errors_factory.js → features/theme/utils/archive/theme_archive_utils_errors_factory.js}

@@ -1,4 +1,4 @@
-import { AppError } from '../../../cli/utilities/features/logger/logs/app_error.js';
+import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
 export class ThemeArchiveErrorsFactory {
     static createErrorWhileCreatingThemeArchive(error) {
         return new AppError({

package/build/theme/features/theme/utils/files/them_files_constants.js

@@ -0,0 +1 @@
+export const FILES_LIST_CUSTOM_MODULES_TO_KEEP_IDS = 'customModulesIdsToKeep';

package/build/theme/features/theme/utils/{files_structure/theme_files_structure_utils.js → files/theme_files_utils.js}

@@ -1,4 +1,4 @@
-import { readJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
+import { fileExists, isDirectory, readJSONFile, removeFile, writeJSONFile } from '../../../../../utils/fs/fs_utils.js';
 import { join, looksLikeDirectory, mapKeysPathsToWindowPlatform, toUnixPath } from '../../../../../utils/path_utils.js';
 import { SHOPER_THEME_METADATA_DIR } from '../../../../constants/directory_contstants.js';
 import { THEME_CURRENT_CHECKSUMS_FILE_NAME, THEME_CURRENT_CHECKSUMS_VERITY_FILE_NAME, THEME_FILES_STRUCTURE_FILE_NAME, THEME_INITIAL_CHECKSUMS_FILE_NAME, THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME } from '../../theme_constants.js';
@@ -7,7 +7,8 @@ import { validateDirectory } from '../../../../utils/directory_validator/directo
 import path from 'node:path';
 import { THEME_FILES_LIST_FILE_NAME } from '../../push/theme_push_constants.js';
 import { THEME_ACTIONS_TYPES } from '../../actions/theme_actions_constants.js';
-export class ThemeFilesStructureUtils {
+import { FILE_STATES } from '../../../../../utils/fs/fs_constants.js';
+export class ThemeFilesUtils {
     static async getThemeFilesStructure(themeDirectory) {
         const filesStructure = await readJSONFile(join(themeDirectory, SHOPER_THEME_METADATA_DIR, THEME_FILES_STRUCTURE_FILE_NAME));
         if (!isWindowsOs())
@@ -19,7 +20,7 @@ export class ThemeFilesStructureUtils {
         await writeJSONFile(filePath, filesStructure);
     }
     static async getFilesPermissions(themeDirectory) {
-        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
+        const fileStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDirectory);
         return Object.entries(fileStructure).reduce((acc, [key, value]) => {
             return {
                 ...acc,
@@ -35,14 +36,25 @@ export class ThemeFilesStructureUtils {
         });
     }
     static async getThemeRootDirectories(themeDirectory) {
-        const filesStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDirectory);
+        const filesStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDirectory);
         return Object.keys(filesStructure).filter((path) => {
             return looksLikeDirectory(path);
         });
     }
     static mapFilesRecordsToFilesList(filesRecords, localFileNameToUploaded = {}) {
-        const mappedFilesRecords = filesRecords.reduce((acc, { fileGlob, fileName }) => {
+        let areAllSkinstoreFilesUnchanged = true;
+        const filesList = filesRecords.reduce((acc, { fileGlob, fileName, state, actionKey }) => {
             const name = localFileNameToUploaded[fileName] ?? fileName;
+            if (state === FILE_STATES.deleted && actionKey === 'thumbnail') {
+                return {
+                    ...acc,
+                    [fileGlob]: null
+                };
+            }
+            if (actionKey === 'skinstore_files' && state !== FILE_STATES.unchanged)
+                areAllSkinstoreFilesUnchanged = false;
+            if (state === FILE_STATES.deleted || (state === FILE_STATES.unchanged && actionKey !== 'skinstore_files'))
+                return acc;
             if (looksLikeDirectory(fileGlob)) {
                 const existingFiles = acc[fileGlob] || [];
                 return {
@@ -57,32 +69,31 @@ export class ThemeFilesStructureUtils {
                 };
             }
         }, {});
-        /*
-         * Brzydki fix, poprawione w partial push na ładniej
-         */
-        if (!mappedFilesRecords['settings/thumbnail.jpg']) {
-            mappedFilesRecords['settings/thumbnail.jpg'] = null;
-        }
-        return mappedFilesRecords;
+        if (areAllSkinstoreFilesUnchanged)
+            delete filesList['skinstore/files'];
+        return filesList;
     }
     static async createAFilesListFile(themeRootDir, filesList) {
         if (!filesList || !Object.keys(filesList).length)
             return;
-        const toUnixStyleFilesList = Object.entries(filesList).reduce((acc, [filePath, value]) => {
+        const toUnixStyleFilesList = {};
+        for (const [filePath, value] of Object.entries(filesList)) {
             const unixPath = toUnixPath(filePath);
-            const finalPath = looksLikeDirectory(unixPath) ? `${unixPath}${path.posix.sep}` : unixPath;
-            return {
-                ...acc,
-                [finalPath]: value
-            };
-        }, {});
-        await writeJSONFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME), toUnixStyleFilesList);
+            const finalPath = (await fileExists(join(themeRootDir, filePath))) && (await isDirectory(join(themeRootDir, filePath)))
+                ? `${unixPath}${path.posix.sep}`
+                : unixPath;
+            toUnixStyleFilesList[finalPath] = value;
+        }
+        await writeJSONFile(this.getFilesListFilePath(themeRootDir), toUnixStyleFilesList);
+    }
+    static getFilesListFilePath(themeRootDir) {
+        return join(themeRootDir, THEME_FILES_LIST_FILE_NAME);
     }
     static async removeAFilesListFile(themeRootDir) {
-        await removeFile(join(themeRootDir, THEME_FILES_LIST_FILE_NAME));
+        await removeFile(this.getFilesListFilePath(themeRootDir));
     }
     static async updateFilesStructure(themeDir) {
-        const fileStructure = await ThemeFilesStructureUtils.getThemeFilesStructure(themeDir);
+        const fileStructure = await ThemeFilesUtils.getThemeFilesStructure(themeDir);
         const checksumsFiles = [
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_FILE_NAME}`,
             `${SHOPER_THEME_METADATA_DIR}/${THEME_INITIAL_CHECKSUMS_VERITY_FILE_NAME}`,
@@ -115,6 +126,6 @@ export class ThemeFilesStructureUtils {
                 }
             };
         });
-        await ThemeFilesStructureUtils.writeThemeFilesStructure(themeDir, fileStructure);
+        await ThemeFilesUtils.writeThemeFilesStructure(themeDir, fileStructure);
     }
 }

package/build/theme/features/theme/utils/files_structure/theme_file_structure_errors_factory.js

@@ -1,9 +1 @@
-import { AppError } from '../../../../../cli/utilities/features/logger/logs/app_error.js';
-export class ThemeFileStructureErrorsFactory {
-    static createNoFilesStructureError() {
-        return new AppError({
-            code: 'theme.file_structure.no_files_structure',
-            message: 'No files structure found for the theme.'
-        });
-    }
-}
+export {};