@youcan/theme 2.1.4 → 2.3.0

package/dist/cli/commands/theme/delete.d.ts

@@ -1,5 +1,5 @@
-import { ThemeCommand } from '@/util/theme-command';
-export default class Delete extends ThemeCommand {
-    static description: string;
-    run(): Promise<void>;
-}
+import { ThemeCommand } from '@/util/theme-command';
+export default class Delete extends ThemeCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/cli/commands/theme/delete.js

@@ -1,33 +1,33 @@
 import { Session, Http, Env, Tasks } from '@youcan/cli-kit';
 import { ThemeCommand } from '../../../util/theme-command.js';
 
-class Delete extends ThemeCommand {
-    static description = 'Select remote development themes to delete';
-    async run() {
-        await Session.authenticate(this);
-        const { dev: themes } = await Http.get(`${Env.apiHostname()}/themes`);
-        if (!themes.length) {
-            return this.output.info('You have no remote dev themes');
-        }
-        const choices = themes.map(t => ({ title: `${t.name} (${t.id})`, value: t.id }));
-        const { identifiers } = await this.prompt({
-            choices,
-            type: 'multiselect',
-            name: 'identifiers',
-            message: 'Select themes to delete',
-        });
-        const tasks = identifiers.map((id) => {
-            const theme = themes.find(t => t.id === id);
-            return {
-                title: `Deleting '${theme.name} (${theme.id})'...`,
-                async task() {
-                    await Http.post(`${Env.apiHostname()}/themes/${theme.id}/delete`);
-                },
-            };
-        });
-        await Tasks.run({}, tasks);
-        this.output.info(`Done! ${identifiers.length} themes deleted.`);
-    }
+class Delete extends ThemeCommand {
+    static description = 'Select remote development themes to delete';
+    async run() {
+        await Session.authenticate(this);
+        const { dev: themes } = await Http.get(`${Env.apiHostname()}/themes`);
+        if (!themes.length) {
+            return this.output.info('You have no remote dev themes');
+        }
+        const choices = themes.map(t => ({ title: `${t.name} (${t.id})`, value: t.id }));
+        const { identifiers } = await this.prompt({
+            choices,
+            type: 'multiselect',
+            name: 'identifiers',
+            message: 'Select themes to delete',
+        });
+        const tasks = identifiers.map((id) => {
+            const theme = themes.find(t => t.id === id);
+            return {
+                title: `Deleting '${theme.name} (${theme.id})'...`,
+                async task() {
+                    await Http.post(`${Env.apiHostname()}/themes/${theme.id}/delete`);
+                },
+            };
+        });
+        await Tasks.run({}, tasks);
+        this.output.info(`Done! ${identifiers.length} themes deleted.`);
+    }
 }
 
 export { Delete as default };

package/dist/cli/commands/theme/dev.d.ts

@@ -1,5 +1,5 @@
-import { ThemeCommand } from '@/util/theme-command';
-export default class Dev extends ThemeCommand {
-    static description: string;
-    run(): Promise<void>;
-}
+import { ThemeCommand } from '@/util/theme-command';
+export default class Dev extends ThemeCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/cli/commands/theme/dev.js

@@ -1,75 +1,76 @@
-import { Session, Tasks, Http, Env, Path, Filesystem, Crypto } from '@youcan/cli-kit';
+import { Session, Tasks, Http, Env, Path, Filesystem, Crypto, UI } from '@youcan/cli-kit';
 import { ThemeCommand } from '../../../util/theme-command.js';
 import { load } from '../../../util/theme-loader.js';
 import ThemeWorker from '../../services/dev/worker.js';
 import { execute } from '../../services/dev/execute.js';
 import { THEME_FILE_TYPES } from '../../../constants.js';
 
-class Dev extends ThemeCommand {
-    static description = 'Start a theme development server and preview your changes';
-    async run() {
-        const theme = await load();
-        await Session.authenticate(this);
-        const context = await Tasks.run({ cmd: this, workers: [] }, [
-            {
-                title: 'Fetching theme metadata...',
-                async task(ctx) {
-                    const store = await Http.get(`${Env.apiHostname()}/me`);
-                    ctx.store = {
-                        slug: store.slug,
-                        domain: store.domain,
-                    };
-                    const metadata = await Http.get(`${Env.apiHostname()}/themes/${theme.theme_id}/metadata`);
-                    theme.metadata = metadata;
-                },
-            },
-            {
-                title: 'Syncing theme files, please wait...',
-                async task(ctx) {
-                    for (const type of THEME_FILE_TYPES) {
-                        const descriptors = theme.metadata[type] ?? [];
-                        const directory = Path.resolve(theme.root, type);
-                        const present = await Filesystem.exists(directory)
-                            ? await Filesystem.readdir(directory)
-                            : [];
-                        if (type === 'config') {
-                            const order = ['settings_schema.json', 'settings_data.json'];
-                            descriptors.sort((a, b) => order.indexOf(a.file_name) - order.indexOf(b.file_name));
-                        }
-                        for (const file of present.filter(f => !descriptors.find(d => d.file_name === f))) {
-                            const path = Path.resolve(directory, file);
-                            const isDir = await Filesystem.isDirectory(path);
-                            if (isDir) {
-                                continue;
-                            }
-                            await execute(theme, 'save', type, file);
-                        }
-                        for (const descriptor of descriptors) {
-                            const path = Path.resolve(directory, descriptor.file_name);
-                            if ((await Filesystem.isDirectory(path)) || !(await Filesystem.exists(path))) {
-                                return await execute(theme, 'delete', type, descriptor.file_name);
-                            }
-                            const buffer = await Filesystem.readFile(path);
-                            const hash = Crypto.sha1(buffer);
-                            if (hash !== descriptor.hash) {
-                                await execute(theme, 'save', type, descriptor.file_name);
-                            }
-                        }
-                    }
-                },
-            },
-            {
-                title: 'Preparing dev processes...',
-                async task(ctx) {
-                    ctx.workers = [
-                        new ThemeWorker(ctx.cmd, ctx.store, theme),
-                    ];
-                    await Promise.all(ctx.workers.map(async (w) => await w.boot()));
-                },
-            },
-        ]);
-        await Promise.all(context.workers.map(async (w) => await w.run()));
-    }
+class Dev extends ThemeCommand {
+    static description = 'Start a theme development server and preview your changes';
+    async run() {
+        const theme = await load();
+        await Session.authenticate(this);
+        const context = await Tasks.run({ cmd: this, workers: [] }, [
+            {
+                title: 'Fetching theme metadata...',
+                async task(ctx) {
+                    const store = await Http.get(`${Env.apiHostname()}/me`);
+                    ctx.store = {
+                        slug: store.slug,
+                        domain: store.domain,
+                    };
+                    const metadata = await Http.get(`${Env.apiHostname()}/themes/${theme.theme_id}/metadata`);
+                    theme.metadata = metadata;
+                },
+            },
+            {
+                title: 'Syncing theme files, please wait...',
+                async task(ctx) {
+                    for (const type of THEME_FILE_TYPES) {
+                        const descriptors = theme.metadata[type] ?? [];
+                        const directory = Path.resolve(theme.root, type);
+                        const present = await Filesystem.exists(directory)
+                            ? await Filesystem.readdir(directory)
+                            : [];
+                        if (type === 'config') {
+                            const order = ['settings_schema.json', 'settings_data.json'];
+                            descriptors.sort((a, b) => order.indexOf(a.file_name) - order.indexOf(b.file_name));
+                        }
+                        for (const file of present.filter(f => !descriptors.find(d => d.file_name === f))) {
+                            const path = Path.resolve(directory, file);
+                            const isDir = await Filesystem.isDirectory(path);
+                            if (isDir) {
+                                continue;
+                            }
+                            await execute(theme, 'save', type, file);
+                        }
+                        for (const descriptor of descriptors) {
+                            const path = Path.resolve(directory, descriptor.file_name);
+                            if ((await Filesystem.isDirectory(path)) || !(await Filesystem.exists(path))) {
+                                return await execute(theme, 'delete', type, descriptor.file_name);
+                            }
+                            const buffer = await Filesystem.readFile(path);
+                            const hash = Crypto.sha1(buffer);
+                            if (hash !== descriptor.hash) {
+                                await execute(theme, 'save', type, descriptor.file_name);
+                            }
+                        }
+                    }
+                },
+            },
+            {
+                title: 'Preparing dev processes...',
+                async task(ctx) {
+                    ctx.workers = [
+                        new ThemeWorker(ctx.cmd, ctx.store, theme),
+                    ];
+                    await Promise.all(ctx.workers.map(async (w) => await w.boot()));
+                },
+            },
+        ]);
+        UI.renderDevOutput({ hotKeys: [], cmd: this });
+        await Promise.all(context.workers.map(async (w) => await w.run()));
+    }
 }
 
 export { Dev as default };

package/dist/cli/commands/theme/init.d.ts

@@ -1,16 +1,16 @@
-import { ThemeCommand } from '@/util/theme-command';
-declare class Init extends ThemeCommand {
-    static description: string;
-    static args: {
-        name: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
-    };
-    static flags: {
-        url: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-        inplace: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-        'no-color': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-    };
-    run(): Promise<any>;
-}
-export default Init;
+import { ThemeCommand } from '@/util/theme-command';
+declare class Init extends ThemeCommand {
+    static description: string;
+    static args: {
+        name: import("@oclif/core/lib/interfaces/parser").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        url: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        inplace: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        'no-color': import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        verbose: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<any>;
+}
+export default Init;

package/dist/cli/commands/theme/init.js

@@ -4,120 +4,120 @@ import { ThemeCommand } from '../../../util/theme-command.js';
 import { THEME_FLAGS } from '../../../flags.js';
 import { THEME_CONFIG_FILENAME } from '../../../constants.js';
 
-class Init extends ThemeCommand {
-    static description = 'Clones a theme template git repo';
-    static args = {
-        name: Args.string({
-            name: 'name',
-            required: false,
-            description: 'A name for the new theme',
-        }),
-    };
-    static flags = {
-        ...Cli.commonFlags,
-        ...THEME_FLAGS,
-        url: Flags.string({
-            char: 'u',
-            env: 'YC_FLAG_CLONE_URL',
-            description: 'The Git URL to clone from',
-            default: 'https://github.com/youcan-shop/dusk',
-        }),
-        inplace: Flags.boolean({
-            char: 'i',
-            default: false,
-            env: 'YC_FLAG_INPLACE',
-            description: 'Initialize the current directory as a dev theme instead of cloning',
-        }),
-    };
-    async run() {
-        const { flags } = await this.parse(Init);
-        const session = await Session.authenticate(this);
-        const answers = await (prompt(this));
-        const dest = Path.join(flags.path, flags.inplace ? '' : answers.theme_name);
-        await Tasks.run({
-            payload: answers,
-            theme_id: null,
-            cmd: this,
-        }, [
-            {
-                title: `Cloning ${flags.url} into ${dest}...`,
-                skip: () => flags.inplace,
-                task: async () => {
-                    await Git.clone({ url: flags.url, destination: dest });
-                },
-            },
-            {
-                title: 'Initializing development theme...',
-                task: async (ctx) => {
-                    const path = await Filesystem.archived(dest, answers.theme_name);
-                    const configPath = Path.join(Path.cwd(), THEME_CONFIG_FILENAME);
-                    if (flags.inplace && await Filesystem.exists(configPath)) {
+class Init extends ThemeCommand {
+    static description = 'Clones a theme template git repo';
+    static args = {
+        name: Args.string({
+            name: 'name',
+            required: false,
+            description: 'A name for the new theme',
+        }),
+    };
+    static flags = {
+        ...Cli.commonFlags,
+        ...THEME_FLAGS,
+        url: Flags.string({
+            char: 'u',
+            env: 'YC_FLAG_CLONE_URL',
+            description: 'The Git URL to clone from',
+            default: 'https://github.com/youcan-shop/dusk',
+        }),
+        inplace: Flags.boolean({
+            char: 'i',
+            default: false,
+            env: 'YC_FLAG_INPLACE',
+            description: 'Initialize the current directory as a dev theme instead of cloning',
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        const session = await Session.authenticate(this);
+        const answers = await (prompt(this));
+        const dest = Path.join(flags.path, flags.inplace ? '' : answers.theme_name);
+        await Tasks.run({
+            payload: answers,
+            theme_id: null,
+            cmd: this,
+        }, [
+            {
+                title: `Cloning ${flags.url} into ${dest}...`,
+                skip: () => flags.inplace,
+                task: async () => {
+                    await Git.clone({ url: flags.url, destination: dest });
+                },
+            },
+            {
+                title: 'Initializing development theme...',
+                task: async (ctx) => {
+                    const path = await Filesystem.archived(dest, answers.theme_name);
+                    const configPath = Path.join(Path.cwd(), THEME_CONFIG_FILENAME);
+                    if (flags.inplace && await Filesystem.exists(configPath)) {
                         throw new Error(`
                 This directory is already linked to a remote theme,
                 please delete youcan.app.json if you wish to create a new one
-              `);
-                    }
-                    Object.assign(ctx.payload, { archive: await Form.file(path) });
-                    const res = await Http.post(`${Env.apiHostname()}/themes/init`, {
-                        headers: { Authorization: `Bearer ${session.access_token}` },
-                        body: Form.convert(ctx.payload),
-                    });
-                    ctx.theme_id = res.id;
-                    await Filesystem.unlink(path);
-                },
-            },
-            {
-                title: 'Cleaning up...',
-                task: async (ctx) => {
-                    await Filesystem.writeJsonFile(Path.join(dest, THEME_CONFIG_FILENAME), { theme_id: ctx.theme_id });
-                    ctx.cmd.output.info(`\nDevelopment theme '${ctx.theme_id}' initiated!`);
-                },
-            },
-        ]);
-    }
-}
-async function prompt(command) {
-    return command.prompt([
-        {
-            name: 'theme_name',
-            type: 'text',
-            initial: 'Starter',
-            message: 'Your theme\'s name',
-            validate: (v) => {
-                if (!v.length) {
-                    return 'Theme name cannot be empty';
-                }
-                if (v.length > 32) {
-                    return 'Theme name cannot exceed 32 characters';
-                }
-                return true;
-            },
-        },
-        {
-            type: 'text',
-            name: 'theme_author',
-            message: 'The theme\'s author',
-            initial: 'YouCan',
-        },
-        {
-            type: 'text',
-            name: 'theme_version',
-            message: 'The theme\'s current version',
-            initial: '1.0.0',
-        },
-        {
-            type: 'text',
-            name: 'theme_support_url',
-            message: 'A support URL for this theme.',
-            initial: 'https://developer.youcan.shop',
-        },
-        {
-            type: 'text',
-            name: 'theme_documentation_url',
-            message: 'A documentation URL for this theme.',
-            initial: 'https://developer.youcan.shop',
-        },
-    ]);
+              `);
+                    }
+                    Object.assign(ctx.payload, { archive: await Form.file(path) });
+                    const res = await Http.post(`${Env.apiHostname()}/themes/init`, {
+                        headers: { Authorization: `Bearer ${session.access_token}` },
+                        body: Form.convert(ctx.payload),
+                    });
+                    ctx.theme_id = res.id;
+                    await Filesystem.unlink(path);
+                },
+            },
+            {
+                title: 'Cleaning up...',
+                task: async (ctx) => {
+                    await Filesystem.writeJsonFile(Path.join(dest, THEME_CONFIG_FILENAME), { theme_id: ctx.theme_id });
+                    ctx.cmd.output.info(`\nDevelopment theme '${ctx.theme_id}' initiated!`);
+                },
+            },
+        ]);
+    }
+}
+async function prompt(command) {
+    return command.prompt([
+        {
+            name: 'theme_name',
+            type: 'text',
+            initial: 'Starter',
+            message: 'Your theme\'s name',
+            validate: (v) => {
+                if (!v.length) {
+                    return 'Theme name cannot be empty';
+                }
+                if (v.length > 32) {
+                    return 'Theme name cannot exceed 32 characters';
+                }
+                return true;
+            },
+        },
+        {
+            type: 'text',
+            name: 'theme_author',
+            message: 'The theme\'s author',
+            initial: 'YouCan',
+        },
+        {
+            type: 'text',
+            name: 'theme_version',
+            message: 'The theme\'s current version',
+            initial: '1.0.0',
+        },
+        {
+            type: 'text',
+            name: 'theme_support_url',
+            message: 'A support URL for this theme.',
+            initial: 'https://developer.youcan.shop',
+        },
+        {
+            type: 'text',
+            name: 'theme_documentation_url',
+            message: 'A documentation URL for this theme.',
+            initial: 'https://developer.youcan.shop',
+        },
+    ]);
 }
 
 export { Init as default };

package/dist/cli/commands/theme/list.d.ts

@@ -1,5 +1,5 @@
-import { ThemeCommand } from '@/util/theme-command';
-export default class List extends ThemeCommand {
-    static description: string;
-    run(): Promise<void>;
-}
+import { ThemeCommand } from '@/util/theme-command';
+export default class List extends ThemeCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/cli/commands/theme/list.js

@@ -1,32 +1,32 @@
 import { Session, Http, Env } from '@youcan/cli-kit';
 import { ThemeCommand } from '../../../util/theme-command.js';
 
-const formatter = Intl.NumberFormat('en', {
-    notation: 'compact',
-    style: 'unit',
-    unit: 'byte',
-    unitDisplay: 'narrow',
-});
-class List extends ThemeCommand {
-    static description = 'List remote development themes';
-    async run() {
-        await Session.authenticate(this);
-        const { dev: themes } = await Http.get(`${Env.apiHostname()}/themes`);
-        if (!themes.length) {
-            return this.output.info('You have no remote dev themes');
-        }
-        this.output.table(themes.map(t => ({
-            id: t.id,
-            name: t.name,
-            version: t.version,
-            size: formatter.format(t.size),
-        })), {
-            id: { header: 'Identifier' },
-            name: { header: 'Name' },
-            version: { header: 'Version' },
-            size: { header: 'Size' },
-        });
-    }
+const formatter = Intl.NumberFormat('en', {
+    notation: 'compact',
+    style: 'unit',
+    unit: 'byte',
+    unitDisplay: 'narrow',
+});
+class List extends ThemeCommand {
+    static description = 'List remote development themes';
+    async run() {
+        await Session.authenticate(this);
+        const { dev: themes } = await Http.get(`${Env.apiHostname()}/themes`);
+        if (!themes.length) {
+            return this.output.info('You have no remote dev themes');
+        }
+        this.output.table(themes.map(t => ({
+            id: t.id,
+            name: t.name,
+            version: t.version,
+            size: formatter.format(t.size),
+        })), {
+            id: { header: 'Identifier' },
+            name: { header: 'Name' },
+            version: { header: 'Version' },
+            size: { header: 'Size' },
+        });
+    }
 }
 
 export { List as default };

package/dist/cli/commands/theme/pack.d.ts

@@ -1,6 +1,6 @@
-import { ThemeCommand } from '@/util/theme-command';
-export declare function date(): string;
-export default class Pack extends ThemeCommand {
-    static description: string;
-    run(): Promise<void>;
-}
+import { ThemeCommand } from '@/util/theme-command';
+export declare function date(): string;
+export default class Pack extends ThemeCommand {
+    static description: string;
+    run(): Promise<void>;
+}

package/dist/cli/commands/theme/pack.js

@@ -2,45 +2,45 @@ import { Session, Tasks, Path, Filesystem } from '@youcan/cli-kit';
 import { ThemeCommand } from '../../../util/theme-command.js';
 import { load } from '../../../util/theme-loader.js';
 
-const formatter = Intl.NumberFormat('en', {
-    notation: 'compact',
-    style: 'unit',
-    unit: 'byte',
-    unitDisplay: 'narrow',
-});
-const FILE_TYPES = [
-    'layouts',
-    'sections',
-    'locales',
-    'assets',
-    'snippets',
-    'config',
-    'templates',
-];
-function date() {
-    const date = new Date();
-    const day = date.getDate();
-    const month = date.getMonth() + 1;
-    const year = date.getFullYear();
-    return `${day}-${month}-${year}`;
-}
-class Pack extends ThemeCommand {
-    static description = 'Pack your theme into an archive to upload or share';
-    async run() {
-        await Session.authenticate(this);
-        const theme = await load();
-        const context = await Tasks.run({}, [
-            {
-                title: 'Packing your theme...',
-                async task(ctx) {
-                    const name = `${Path.basename(theme.root)}-${date()}`;
-                    ctx.path = await Filesystem.archived(theme.root, name, `{${FILE_TYPES.join(',')}}/*`);
-                },
-            },
-        ]);
-        const { size } = await Filesystem.stat(context.path);
-        this.output.info(`Theme successfully packed into ${Path.basename(context.path)} (${formatter.format(size)})`);
-    }
+const formatter = Intl.NumberFormat('en', {
+    notation: 'compact',
+    style: 'unit',
+    unit: 'byte',
+    unitDisplay: 'narrow',
+});
+const FILE_TYPES = [
+    'layouts',
+    'sections',
+    'locales',
+    'assets',
+    'snippets',
+    'config',
+    'templates',
+];
+function date() {
+    const date = new Date();
+    const day = date.getDate();
+    const month = date.getMonth() + 1;
+    const year = date.getFullYear();
+    return `${day}-${month}-${year}`;
+}
+class Pack extends ThemeCommand {
+    static description = 'Pack your theme into an archive to upload or share';
+    async run() {
+        await Session.authenticate(this);
+        const theme = await load();
+        const context = await Tasks.run({}, [
+            {
+                title: 'Packing your theme...',
+                async task(ctx) {
+                    const name = `${Path.basename(theme.root)}-${date()}`;
+                    ctx.path = await Filesystem.archived(theme.root, name, `{${FILE_TYPES.join(',')}}/*`);
+                },
+            },
+        ]);
+        const { size } = await Filesystem.stat(context.path);
+        this.output.info(`Theme successfully packed into ${Path.basename(context.path)} (${formatter.format(size)})`);
+    }
 }
 
 export { date, Pack as default };

package/dist/cli/services/dev/execute.d.ts

@@ -1,4 +1,4 @@
-import type { Worker } from '@youcan/cli-kit';
-import type { Theme } from '@/types';
-import type { THEME_FILE_TYPES } from '@/constants';
-export declare function execute(theme: Theme, op: 'save' | 'delete', type: typeof THEME_FILE_TYPES[number], name: string, logger?: Worker.Logger | null): Promise<void>;
+import type { Worker } from '@youcan/cli-kit';
+import type { Theme } from '@/types';
+import type { THEME_FILE_TYPES } from '@/constants';
+export declare function execute(theme: Theme, op: 'save' | 'delete', type: typeof THEME_FILE_TYPES[number], name: string, logger?: Worker.Logger | null): Promise<void>;

package/dist/cli/services/dev/execute.js

@@ -1,28 +1,28 @@
 import { Path, Form, Http, Env } from '@youcan/cli-kit';
 
-async function execute(theme, op, type, name, logger = null) {
-    try {
-        const path = Path.join(theme.root, type, name);
-        const payload = {
-            file_name: name,
-            file_type: type,
-            file_operation: op,
-        };
-        if (op === 'save') {
-            payload.file_content = await Form.file(path);
-        }
-        await Http.post(`${Env.apiHostname()}/themes/${theme.theme_id}/update`, {
-            body: Form.convert(payload),
-        });
-        logger && logger.write(`[${op === 'save' ? 'updated' : 'deleted'}] - ${Path.join(type, name)}`);
-    }
-    catch (err) {
-        if (err instanceof Error && logger) {
-            logger.write(`[error] - ${Path.join(type, name)}\n${err.message}`);
-            return;
-        }
-        throw err;
-    }
+async function execute(theme, op, type, name, logger = null) {
+    try {
+        const path = Path.join(theme.root, type, name);
+        const payload = {
+            file_name: name,
+            file_type: type,
+            file_operation: op,
+        };
+        if (op === 'save') {
+            payload.file_content = await Form.file(path);
+        }
+        await Http.post(`${Env.apiHostname()}/themes/${theme.theme_id}/update`, {
+            body: Form.convert(payload),
+        });
+        logger && logger.write(`[${op === 'save' ? 'updated' : 'deleted'}] - ${Path.join(type, name)}`);
+    }
+    catch (err) {
+        if (err instanceof Error && logger) {
+            logger.write(`[error] - ${Path.join(type, name)}\n${err.message}`);
+            return;
+        }
+        throw err;
+    }
 }
 
 export { execute };

package/dist/cli/services/dev/worker.d.ts

@@ -1,17 +1,17 @@
-import { Worker } from '@youcan/cli-kit';
-import type { ThemeCommand } from '@/util/theme-command';
-import type { Store, Theme } from '@/types';
-export default class ThemeWorker extends Worker.Abstract {
-    private command;
-    private store;
-    private theme;
-    private logger;
-    private previewLogger;
-    private queue;
-    private io;
-    constructor(command: ThemeCommand, store: Store, theme: Theme);
-    boot(): Promise<void>;
-    run(): Promise<void>;
-    private enqueue;
-    private execute;
-}
+import { Worker } from '@youcan/cli-kit';
+import type { ThemeCommand } from '@/util/theme-command';
+import type { Store, Theme } from '@/types';
+export default class ThemeWorker extends Worker.Abstract {
+    private command;
+    private store;
+    private theme;
+    private logger;
+    private previewLogger;
+    private queue;
+    private io;
+    constructor(command: ThemeCommand, store: Store, theme: Theme);
+    boot(): Promise<void>;
+    run(): Promise<void>;
+    private enqueue;
+    private execute;
+}

package/dist/cli/services/dev/worker.js

@@ -1,93 +1,93 @@
-import { Worker, Color, Http, System, Path, Filesystem } from '@youcan/cli-kit';
+import { Worker, Http, System, Path, Filesystem } from '@youcan/cli-kit';
 import { Server } from 'socket.io';
 import debounce from 'debounce';
 import { execute } from './execute.js';
 import { THEME_FILE_TYPES } from '../../../constants.js';
 
-class ThemeWorker extends Worker.Abstract {
-    command;
-    store;
-    theme;
-    logger;
-    previewLogger;
-    queue = [];
-    io;
-    constructor(command, store, theme) {
-        super();
-        this.command = command;
-        this.store = store;
-        this.theme = theme;
-        this.logger = new Worker.Logger('stdout', 'themes', Color.magenta);
-        this.previewLogger = new Worker.Logger('stdout', 'preview', Color.dim);
-    }
-    async boot() {
-        try {
-            this.io = new Server(7565, {
-                cors: {
-                    origin: `${Http.scheme()}://${this.store.domain}`,
-                    methods: ['GET', 'POST'],
-                },
-            });
-            this.io.on('connection', (socket) => {
-                this.previewLogger.write(`attached to preview page at ${socket.handshake.address}`);
-            });
-            System.open(`${Http.scheme()}://${this.store.domain}/themes/${this.theme.theme_id}/preview`);
-        }
-        catch (err) {
-            this.command.error(err);
-        }
-    }
-    async run() {
-        const directories = THEME_FILE_TYPES.map(t => Path.resolve(this.theme.root, t));
-        const watcher = Filesystem.watch(directories, {
-            awaitWriteFinish: { stabilityThreshold: 50 },
-            ignoreInitial: true,
-            persistent: true,
-            depth: 0,
-        });
-        this.command.controller.signal.addEventListener('abort', () => {
-            watcher.close();
-        });
-        watcher.on('all', async (event, path) => {
-            if (!['add', 'change', 'unlink'].includes(event)) {
-                return;
-            }
-            const [filetype, filename] = [
-                Path.basename(Path.dirname(path)),
-                Path.basename(path),
-            ];
-            switch (event) {
-                case 'add':
-                case 'change':
-                    this.enqueue('save', filetype, filename);
-                    break;
-                case 'unlink':
-                    this.enqueue('delete', filetype, filename);
-                    break;
-            }
-        });
-        this.logger.write('Listening for changes...');
-        // quick racing conditions hack
-        setInterval(async () => {
-            const task = this.queue.shift();
-            if (task == null) {
-                return;
-            }
-            await task();
-        }, 10);
-    }
-    enqueue(op, type, name) {
-        this.queue.push(async () => {
-            await this.execute(op, type, name, true);
-            debounce(() => {
-                this.io.emit('theme:update');
-                this.previewLogger.write('reloading preview...');
-            }, 100)();
-        });
-    }
-    async execute(op, type, name, log = false) {
-        return execute(this.theme, op, type, name, this.logger);
-    }
+class ThemeWorker extends Worker.Abstract {
+    command;
+    store;
+    theme;
+    logger;
+    previewLogger;
+    queue = [];
+    io;
+    constructor(command, store, theme) {
+        super();
+        this.command = command;
+        this.store = store;
+        this.theme = theme;
+        this.logger = new Worker.Logger('themes', 'magenta');
+        this.previewLogger = new Worker.Logger('preview', 'dim');
+    }
+    async boot() {
+        try {
+            this.io = new Server(7565, {
+                cors: {
+                    origin: `${Http.scheme()}://${this.store.domain}`,
+                    methods: ['GET', 'POST'],
+                },
+            });
+            this.io.on('connection', (socket) => {
+                this.previewLogger.write(`attached to preview page at ${socket.handshake.address}`);
+            });
+            System.open(`${Http.scheme()}://${this.store.domain}/themes/${this.theme.theme_id}/preview`);
+        }
+        catch (err) {
+            this.command.error(err);
+        }
+    }
+    async run() {
+        const directories = THEME_FILE_TYPES.map(t => Path.resolve(this.theme.root, t));
+        const watcher = Filesystem.watch(directories, {
+            awaitWriteFinish: { stabilityThreshold: 50 },
+            ignoreInitial: true,
+            persistent: true,
+            depth: 0,
+        });
+        this.command.controller.signal.addEventListener('abort', () => {
+            watcher.close();
+        });
+        watcher.on('all', async (event, path) => {
+            if (!['add', 'change', 'unlink'].includes(event)) {
+                return;
+            }
+            const [filetype, filename] = [
+                Path.basename(Path.dirname(path)),
+                Path.basename(path),
+            ];
+            switch (event) {
+                case 'add':
+                case 'change':
+                    this.enqueue('save', filetype, filename);
+                    break;
+                case 'unlink':
+                    this.enqueue('delete', filetype, filename);
+                    break;
+            }
+        });
+        this.logger.write('Listening for changes...');
+        // quick racing conditions hack
+        setInterval(async () => {
+            const task = this.queue.shift();
+            if (task == null) {
+                return;
+            }
+            await task();
+        }, 10);
+    }
+    enqueue(op, type, name) {
+        this.queue.push(async () => {
+            await this.execute(op, type, name, true);
+            debounce(() => {
+                this.io.emit('theme:update');
+                this.previewLogger.write('reloading preview...');
+            }, 100)();
+        });
+    }
+    async execute(op, type, name, log = false) {
+        return execute(this.theme, op, type, name, this.logger);
+    }
 }
 
 export { ThemeWorker as default };

package/dist/constants.d.ts

@@ -1,3 +1,3 @@
-import type { Metadata } from './types';
-export declare const THEME_CONFIG_FILENAME = "youcan.theme.json";
-export declare const THEME_FILE_TYPES: Array<keyof Metadata>;
+import type { Metadata } from './types';
+export declare const THEME_CONFIG_FILENAME = "youcan.theme.json";
+export declare const THEME_FILE_TYPES: Array<keyof Metadata>;

package/dist/constants.js

@@ -1,12 +1,12 @@
-const THEME_CONFIG_FILENAME = 'youcan.theme.json';
-const THEME_FILE_TYPES = [
-    'layouts',
-    'sections',
-    'locales',
-    'assets',
-    'snippets',
-    'config',
-    'templates',
+const THEME_CONFIG_FILENAME = 'youcan.theme.json';
+const THEME_FILE_TYPES = [
+    'layouts',
+    'sections',
+    'locales',
+    'assets',
+    'snippets',
+    'config',
+    'templates',
 ];
 
 export { THEME_CONFIG_FILENAME, THEME_FILE_TYPES };

package/dist/flags.d.ts

@@ -1,3 +1,3 @@
-export declare const THEME_FLAGS: {
-    path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-};
+export declare const THEME_FLAGS: {
+    path: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+};

package/dist/flags.js

@@ -1,13 +1,13 @@
 import { Flags } from '@oclif/core';
 import { Path } from '@youcan/cli-kit';
 
-const THEME_FLAGS = {
-    path: Flags.string({
-        env: 'YC_FLAG_PATH',
-        default: async () => Path.cwd(),
-        parse: async (input) => Path.resolve(input),
-        description: 'The path to your theme directory.',
-    }),
+const THEME_FLAGS = {
+    path: Flags.string({
+        env: 'YC_FLAG_PATH',
+        default: async () => Path.cwd(),
+        parse: async (input) => Path.resolve(input),
+        description: 'The path to your theme directory.',
+    }),
 };
 
 export { THEME_FLAGS };

package/dist/types.d.ts

@@ -1,40 +1,42 @@
-export interface FileDescriptor {
-    id: string;
-    type: string;
-    name: string;
-    file_name: string;
-    updated: boolean;
-    deleted: boolean;
-    size: number;
-    hash: string;
-}
-export interface Metadata {
-    theme_name: string;
-    theme_author: string;
-    theme_version: string;
-    theme_support_url: string;
-    theme_documentation_url: string;
-    config: FileDescriptor[];
-    layouts: FileDescriptor[];
-    sections: FileDescriptor[];
-    templates: FileDescriptor[];
-    locales: FileDescriptor[];
-    snippets: FileDescriptor[];
-    assets: FileDescriptor[];
-}
-export interface Theme {
-    root: string;
-    theme_id: string;
-    metadata?: Metadata;
-}
-export interface ThemeInfo {
-    id: string;
-    name: string;
-    size: number;
-    version: string;
-    live: boolean;
-}
-export interface Store {
-    domain: string;
-    slug: string;
-}
+export interface FileDescriptor {
+    id: string;
+    type: string;
+    name: string;
+    file_name: string;
+    updated: boolean;
+    deleted: boolean;
+    size: number;
+    hash: string;
+}
+export interface Metadata {
+    theme_name: string;
+    theme_author: string;
+    theme_version: string;
+    theme_support_url: string;
+    theme_documentation_url: string;
+    config: FileDescriptor[];
+    layouts: FileDescriptor[];
+    sections: FileDescriptor[];
+    templates: FileDescriptor[];
+    locales: FileDescriptor[];
+    snippets: FileDescriptor[];
+    assets: FileDescriptor[];
+}
+export interface Theme {
+    root: string;
+    theme_id: string;
+    metadata?: Metadata;
+}
+export interface ThemeInfo {
+    id: string;
+    name: string;
+    size: number;
+    version: string;
+    live: boolean;
+}
+export interface Store {
+    domain: string;
+    slug: string;
+}
+declare const _default: {};
+export default _default;

package/dist/types.js

@@ -1 +1,3 @@
+var types = {};
 
+export { types as default };

package/dist/util/theme-command.d.ts

@@ -1,4 +1,4 @@
-import { Cli } from '@youcan/cli-kit';
-export declare abstract class ThemeCommand extends Cli.Command {
-    protected configFileName(): string;
-}
+import { Cli } from '@youcan/cli-kit';
+export declare abstract class ThemeCommand extends Cli.Command {
+    protected configFileName(): string;
+}

package/dist/util/theme-command.js

@@ -1,10 +1,10 @@
 import { Cli } from '@youcan/cli-kit';
 import { THEME_CONFIG_FILENAME } from '../constants.js';
 
-class ThemeCommand extends Cli.Command {
-    configFileName() {
-        return THEME_CONFIG_FILENAME;
-    }
+class ThemeCommand extends Cli.Command {
+    configFileName() {
+        return THEME_CONFIG_FILENAME;
+    }
 }
 
 export { ThemeCommand };

package/dist/util/theme-loader.d.ts

@@ -1,2 +1,2 @@
-import type { Theme } from '@/types';
-export declare function load(): Promise<Theme>;
+import type { Theme } from '@/types';
+export declare function load(): Promise<Theme>;

package/dist/util/theme-loader.js

@@ -1,16 +1,16 @@
 import { Path, Filesystem } from '@youcan/cli-kit';
 import { THEME_CONFIG_FILENAME } from '../constants.js';
 
-async function load() {
-    const path = Path.resolve(Path.cwd(), THEME_CONFIG_FILENAME);
-    if (!await Filesystem.exists(path)) {
-        throw new Error(`Theme config not found at ${path}`);
-    }
-    const config = await Filesystem.readJsonFile(path);
-    return {
-        ...config,
-        root: Path.cwd(),
-    };
+async function load() {
+    const path = Path.resolve(Path.cwd(), THEME_CONFIG_FILENAME);
+    if (!await Filesystem.exists(path)) {
+        throw new Error(`Theme config not found at ${path}`);
+    }
+    const config = await Filesystem.readJsonFile(path);
+    return {
+        ...config,
+        root: Path.cwd(),
+    };
 }
 
 export { load };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@youcan/theme",
   "type": "module",
-  "version": "2.1.4",
+  "version": "2.3.0",
   "description": "OCLIF plugin for building themes",
   "author": "YouCan <contact@youcan.shop> (https://youcan.shop)",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "@oclif/core": "^2.15.0",
     "debounce": "^2.0.0",
     "socket.io": "^4.7.2",
-    "@youcan/cli-kit": "2.1.4"
+    "@youcan/cli-kit": "2.3.0"
   },
   "devDependencies": {
     "@oclif/plugin-legacy": "^1.3.0",