@youcan/cli-kit 2.1.4 → 2.3.0

package/dist/node/config.js

@@ -1,27 +1,25 @@
 import Conf from 'conf';
 
-// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-/** @ts-expect-error */
-class Manager {
-    store;
-    constructor(options) {
-        this.store = new Conf(options);
-    }
-    get(key) {
-        return this.store.get(key);
-    }
-    set(key, value) {
-        this.store.set(key, value);
-    }
-    delete(key) {
-        this.store.delete(key);
-    }
-    clear() {
-        this.store.clear();
-    }
-}
-function manager(options) {
-    return new Manager(options);
+class Manager {
+    store;
+    constructor(options) {
+        this.store = new Conf(options);
+    }
+    get(key) {
+        return this.store.get(key);
+    }
+    set(key, value) {
+        this.store.set(key, value);
+    }
+    delete(key) {
+        this.store.delete(key);
+    }
+    clear() {
+        this.store.clear();
+    }
+}
+function manager(options) {
+    return new Manager(options);
 }
 
 export { manager };

package/dist/node/context/helpers.d.ts

@@ -1 +1 @@
-export declare function truthy(val: string | undefined): boolean;
+export declare function truthy(val: string | undefined): boolean;

package/dist/node/context/helpers.js

@@ -1,8 +1,8 @@
-function truthy(val) {
-    if (!val) {
-        return false;
-    }
-    return ['1', 'true', 'TRUE', 'yes', 'YES', 'y', 'Y'].includes(val);
+function truthy(val) {
+    if (!val) {
+        return false;
+    }
+    return ['1', 'true', 'TRUE', 'yes', 'YES', 'y', 'Y'].includes(val);
 }
 
 export { truthy };

package/dist/node/context/local.d.ts

@@ -1,2 +1,2 @@
-/// <reference types="node" />
-export declare function isDevelopment(env?: NodeJS.ProcessEnv): boolean;
+/// <reference types="node" />
+export declare function isDevelopment(env?: NodeJS.ProcessEnv): boolean;

package/dist/node/context/local.js

@@ -1,7 +1,7 @@
 import { ENV_VARS } from '../../internal/node/constants.js';
 
-function isDevelopment(env = process.env) {
-    return env[ENV_VARS.ENV] === 'development';
+function isDevelopment(env = process.env) {
+    return env[ENV_VARS.ENV] === 'development';
 }
 
 export { isDevelopment };

package/dist/node/crypto.d.ts

@@ -1,9 +1,12 @@
-/// <reference types="node" />
-export declare function randomHex(size: number): string;
-export declare function base64URLEncode(str: Buffer): string;
-export declare function sha256(str: string): Buffer;
-export declare function sha1(str: Buffer | string): string;
-export declare function hashString(str: string): string;
-export declare function fileHash(buff: Buffer): string;
-export declare function randomBytes(size: number): Buffer;
-export declare function randomUUID(): string;
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { BinaryLike } from 'crypto';
+export declare function randomHex(size: number): string;
+export declare function base64URLEncode(str: Buffer): string;
+export declare function sha256(str: BinaryLike): Buffer;
+export declare function sha1(str: BinaryLike): string;
+export declare function hashString(str: string): string;
+export declare function fileHash(buff: BinaryLike): string;
+export declare function randomBytes(size: number): Buffer;
+export declare function randomUUID(): string;

package/dist/node/crypto.js

@@ -1,28 +1,28 @@
 import crypto from 'node:crypto';
 
-function randomHex(size) {
-    return crypto.randomBytes(size).toString('hex');
-}
-function base64URLEncode(str) {
-    return str.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]/g, '');
-}
-function sha256(str) {
-    return crypto.createHash('sha256').update(str).digest();
-}
-function sha1(str) {
-    return crypto.createHash('sha1').update(str).digest('hex');
-}
-function hashString(str) {
-    return crypto.createHash('sha1').update(str).digest('hex');
-}
-function fileHash(buff) {
-    return crypto.createHash('md5').update(buff).digest('hex');
-}
-function randomBytes(size) {
-    return crypto.randomBytes(size);
-}
-function randomUUID() {
-    return crypto.randomUUID();
+function randomHex(size) {
+    return crypto.randomBytes(size).toString('hex');
+}
+function base64URLEncode(str) {
+    return str.toString('base64').replace(/\+/g, '-').replace(/\//g, '_').replace(/[=]/g, '');
+}
+function sha256(str) {
+    return crypto.createHash('sha256').update(str).digest();
+}
+function sha1(str) {
+    return crypto.createHash('sha1').update(str).digest('hex');
+}
+function hashString(str) {
+    return crypto.createHash('sha1').update(str).digest('hex');
+}
+function fileHash(buff) {
+    return crypto.createHash('md5').update(buff).digest('hex');
+}
+function randomBytes(size) {
+    return crypto.randomBytes(size);
+}
+function randomUUID() {
+    return crypto.randomUUID();
 }
 
 export { base64URLEncode, fileHash, hashString, randomBytes, randomHex, randomUUID, sha1, sha256 };

package/dist/node/env.d.ts

@@ -1,6 +1,5 @@
-import { ENV_VARS } from '@/internal/node/constants';
-export declare function get(key: keyof typeof ENV_VARS): string;
-export declare function oauthClientId(): string;
-export declare function oauthClientSecret(): string;
-export declare function sellerAreaHostname(): string;
-export declare function apiHostname(): string;
+import { ENV_VARS } from '@/internal/node/constants';
+export declare function get(key: keyof typeof ENV_VARS): string;
+export declare function oauthClientId(): string;
+export declare function sellerAreaHostname(): string;
+export declare function apiHostname(): string;

package/dist/node/env.js

@@ -1,51 +1,40 @@
 import { ENV_VARS } from '../internal/node/constants.js';
 
-function get(key) {
-    return process.env[ENV_VARS[key]];
-}
-function oauthClientId() {
-    switch (get('HOST_ENV')) {
-        case 'dev':
-            return '3';
-        case 'test':
-            return '11';
-        case 'prod':
-        default:
-            return '8';
-    }
-}
-function oauthClientSecret() {
-    switch (get('HOST_ENV')) {
-        case 'dev':
-            return 'kvvtjXFCeuvvNX2nwD30SAfh7DMbVXm16E0MPCTu';
-        case 'test':
-            return 'UkNttuRvqjPtX08nSzwGssnKPb21Kg0s0NJNKMAo';
-        case 'prod':
-        default:
-            return 'lvUw2mQ7nXp4WqZ9CZlURMgRGAra3KuOrYhFlU7X';
-    }
-}
-function sellerAreaHostname() {
-    switch (get('HOST_ENV')) {
-        case 'dev':
-            return 'seller-area.dotshop.com';
-        case 'test':
-            return 'seller-area.testyoucan.shop';
-        case 'prod':
-        default:
-            return 'seller-area.youcan.shop';
-    }
-}
-function apiHostname() {
-    switch (get('HOST_ENV')) {
-        case 'dev':
-            return 'api.dotshop.com';
-        case 'test':
-            return 'api.testyoucan.shop';
-        case 'prod':
-        default:
-            return 'api.youcan.shop';
-    }
+function get(key) {
+    return process.env[ENV_VARS[key]];
+}
+function oauthClientId() {
+    switch (get('HOST_ENV')) {
+        case 'dev':
+            return '1';
+        case 'test':
+            return '11';
+        case 'prod':
+        default:
+            return '398';
+    }
+}
+function sellerAreaHostname() {
+    switch (get('HOST_ENV')) {
+        case 'dev':
+            return 'seller-area.dotshop.com';
+        case 'test':
+            return 'seller-area.testyoucan.shop';
+        case 'prod':
+        default:
+            return 'seller-area.youcan.shop';
+    }
+}
+function apiHostname() {
+    switch (get('HOST_ENV')) {
+        case 'dev':
+            return 'api.dotshop.com';
+        case 'test':
+            return 'api.testyoucan.shop';
+        case 'prod':
+        default:
+            return 'api.youcan.shop';
+    }
 }
 
-export { apiHostname, get, oauthClientId, oauthClientSecret, sellerAreaHostname };
+export { apiHostname, get, oauthClientId, sellerAreaHostname };

package/dist/node/filesystem.d.ts

@@ -1,29 +1,34 @@
-/// <reference types="node" />
-/// <reference types="node" />
-import type { Mode, OpenMode, PathLike, Stats } from 'fs';
-import type { GlobOptions } from 'glob';
-export declare function exists(path: string): Promise<boolean>;
-export declare function isDirectory(path: string): Promise<boolean>;
-export declare function tapIntoTmp<T>(callback: (tmp: string) => T | Promise<T>): Promise<T>;
-export declare function mkdir(path: string): Promise<void>;
-interface MoveFileOptions {
-    overwrite?: boolean;
-}
-export declare function move(src: string, dest: string, options?: MoveFileOptions): Promise<void>;
-export declare function readFile(path: PathLike, options?: {
-    encoding?: BufferEncoding;
-    flag?: OpenMode;
-}): Promise<Buffer | string>;
-export declare function writeFile(path: PathLike, data: string, options?: {
-    encoding: BufferEncoding;
-    flag: Mode;
-}): Promise<void>;
-export declare function readJsonFile<T = Record<string, unknown>>(path: PathLike): Promise<T>;
-export declare function writeJsonFile(path: PathLike, data: Record<string, unknown>): Promise<void>;
-export declare function glob(pattern: string | string[], options?: GlobOptions): Promise<string[]>;
-export declare function archived(path: string, name: string, glob?: string): Promise<string>;
-export declare function unlink(path: string): Promise<void>;
-export declare function readdir(path: string): Promise<string[]>;
-export declare function stat(path: string): Promise<Stats>;
-export declare const watch: typeof import("chokidar").watch;
-export {};
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import type { Mode, OpenMode, PathLike, Stats } from 'fs';
+import type { GlobOptions } from 'glob';
+export declare function exists(path: string): Promise<boolean>;
+export declare function isExecutable(path: string): Promise<boolean>;
+export declare function isDirectory(path: string): Promise<boolean>;
+export declare function tapIntoTmp<T>(callback: (tmp: string) => T | Promise<T>): Promise<T>;
+export declare function mkdir(path: string): Promise<void>;
+export declare function rm(path: string): Promise<void>;
+interface MoveFileOptions {
+    overwrite?: boolean;
+}
+export declare function move(src: string, dest: string, options?: MoveFileOptions): Promise<void>;
+export declare function readFile(path: PathLike, options?: {
+    encoding?: BufferEncoding;
+    flag?: OpenMode;
+}): Promise<Buffer | string>;
+export declare function writeFile(path: PathLike, data: string, options?: {
+    encoding: BufferEncoding;
+    flag: Mode;
+}): Promise<void>;
+export declare function readJsonFile<T = Record<string, unknown>>(path: PathLike): Promise<T>;
+export declare function writeJsonFile(path: PathLike, data: Record<string, unknown>): Promise<void>;
+export declare function glob(pattern: string | string[], options?: GlobOptions): Promise<string[]>;
+export declare function archived(path: string, name: string, glob?: string): Promise<string>;
+export declare function unlink(path: string): Promise<void>;
+export declare function readdir(path: string): Promise<string[]>;
+export declare function stat(path: string): Promise<Stats>;
+export declare const watch: typeof import("chokidar").watch;
+export declare function decompressGzip(file: string, destination: string, mode?: number): Promise<void>;
+export declare function extractTar(file: string, cwd: string, mode: number): Promise<void>;
+export {};

package/dist/node/filesystem.js

@@ -1,15 +1,18 @@
 import FilesystemPromises from 'node:fs/promises';
-import { createWriteStream } from 'node:fs';
+import { createGunzip } from 'node:zlib';
+import { pipeline } from 'node:stream/promises';
+import { createWriteStream, createReadStream } from 'node:fs';
 import { temporaryDirectoryTask } from 'tempy';
 import FsExtra from 'fs-extra';
 import archiver from 'archiver';
 import chokidar from 'chokidar';
 import { glob as glob$1 } from 'glob';
+import * as tar from 'tar';
 import './cli.js';
 import 'simple-git';
-import 'execa';
-import 'tcp-port-used';
 import 'find-process';
+import 'tcp-port-used';
+import 'execa';
 import 'env-paths';
 import { resolve } from './path.js';
 import 'node-fetch';
@@ -20,85 +23,112 @@ import 'formdata-node/file-from-path';
 import 'kleur';
 import 'conf';
 import 'dayjs';
+import '../ui/components/DevOutput.js';
+import 'react';
+import 'ink';
 
-async function exists(path) {
-    try {
-        await FilesystemPromises.access(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function isDirectory(path) {
-    try {
-        const stats = await FilesystemPromises.stat(path);
-        return stats.isDirectory();
-    }
-    catch {
-        return false;
-    }
-}
-async function tapIntoTmp(callback) {
-    return temporaryDirectoryTask(callback);
-}
-async function mkdir(path) {
-    await FilesystemPromises.mkdir(path, { recursive: true });
-}
-async function move(src, dest, options = {}) {
-    await FsExtra.move(src, dest, options);
-}
-async function readFile(path, options = { encoding: 'utf-8', flag: 'r' }) {
-    return await FilesystemPromises.readFile(path, options);
-}
-async function writeFile(path, data, options = { encoding: 'utf-8', flag: 'w' }) {
-    return await FilesystemPromises.writeFile(path, data, options);
-}
-async function readJsonFile(path) {
-    const file = await readFile(path);
-    return JSON.parse(file instanceof Buffer ? file.toString() : file);
-}
-async function writeJsonFile(path, data) {
-    return writeFile(path, JSON.stringify(data, null, 4));
-}
-async function glob(pattern, options) {
-    let _options = options;
-    if (options?.dot == null) {
-        _options = { ...options, dot: true };
-    }
-    return glob$1.glob(pattern, _options || {});
-}
-async function archived(path$1, name, glob = '**/*') {
-    return new Promise((resolve$1, reject) => {
-        try {
-            const archivePath = resolve(path$1, `${name}.zip`);
-            const output = createWriteStream(archivePath);
-            const _archiver = archiver('zip', { zlib: { level: 9 } });
-            output.on('close', () => resolve$1(archivePath));
-            _archiver.on('error', () => (err) => reject(err));
-            _archiver.pipe(output);
-            _archiver.glob(glob, {
-                ignore: [`${name}.zip`],
-                cwd: path$1,
-            });
-            _archiver.finalize();
-        }
-        catch (err) {
-            reject(err);
-        }
-    });
-}
-async function unlink(path) {
-    if (await exists(path)) {
-        await FilesystemPromises.unlink(path);
-    }
-}
-async function readdir(path) {
-    return await FilesystemPromises.readdir(path);
-}
-async function stat(path) {
-    return await FilesystemPromises.stat(path);
-}
+async function exists(path) {
+    try {
+        await FilesystemPromises.access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isExecutable(path) {
+    if (!await exists(path)) {
+        return false;
+    }
+    try {
+        await FilesystemPromises.access(path, FilesystemPromises.constants.X_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isDirectory(path) {
+    try {
+        const stats = await FilesystemPromises.stat(path);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function tapIntoTmp(callback) {
+    return temporaryDirectoryTask(callback);
+}
+async function mkdir(path) {
+    await FilesystemPromises.mkdir(path, { recursive: true });
+}
+async function rm(path) {
+    await FilesystemPromises.rm(path, { recursive: true });
+}
+async function move(src, dest, options = {}) {
+    await FsExtra.move(src, dest, options);
+}
+async function readFile(path, options = { encoding: 'utf-8', flag: 'r' }) {
+    return await FilesystemPromises.readFile(path, options);
+}
+async function writeFile(path, data, options = { encoding: 'utf-8', flag: 'w' }) {
+    return await FilesystemPromises.writeFile(path, data, options);
+}
+async function readJsonFile(path) {
+    const content = await readFile(path, { encoding: 'utf8' });
+    return JSON.parse(content);
+}
+async function writeJsonFile(path, data) {
+    return writeFile(path, JSON.stringify(data, null, 4));
+}
+async function glob(pattern, options) {
+    let _options = options;
+    if (options?.dot == null) {
+        _options = { ...options, dot: true };
+    }
+    return glob$1.glob(pattern, _options || {});
+}
+async function archived(path$1, name, glob = '**/*') {
+    return new Promise((resolve$1, reject) => {
+        try {
+            const archivePath = resolve(path$1, `${name}.zip`);
+            const output = createWriteStream(archivePath);
+            const _archiver = archiver('zip', { zlib: { level: 9 } });
+            output.on('close', () => resolve$1(archivePath));
+            _archiver.on('error', () => (err) => reject(err));
+            _archiver.pipe(output);
+            _archiver.glob(glob, {
+                ignore: [`${name}.zip`],
+                cwd: path$1,
+            });
+            _archiver.finalize();
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+async function unlink(path) {
+    if (await exists(path)) {
+        await FilesystemPromises.unlink(path);
+    }
+}
+async function readdir(path) {
+    return await FilesystemPromises.readdir(path);
+}
+async function stat(path) {
+    return await FilesystemPromises.stat(path);
+}
 const watch = chokidar.watch;
+async function decompressGzip(file, destination, mode = 0o755) {
+    const unzip = createGunzip();
+    const readStream = createReadStream(file);
+    const writeStream = createWriteStream(destination, { mode });
+    await pipeline(readStream, unzip, writeStream);
+}
+async function extractTar(file, cwd, mode) {
+    await tar.extract({ cwd, file, mode });
+}
 
-export { archived, exists, glob, isDirectory, mkdir, move, readFile, readJsonFile, readdir, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };
+export { archived, decompressGzip, exists, extractTar, glob, isDirectory, isExecutable, mkdir, move, readFile, readJsonFile, readdir, rm, stat, tapIntoTmp, unlink, watch, writeFile, writeJsonFile };

package/dist/node/form.d.ts

@@ -1,9 +1,9 @@
-/// <reference types="node" />
-import { FormData } from 'formdata-node';
-import type { FormDataEntryValue } from 'formdata-node';
-import { fileFromPath } from 'formdata-node/file-from-path';
-export type FormDataResolvable = Array<FormDataResolvable> | {
-    [key: string]: FormDataResolvable;
-} | FormDataEntryValue | undefined | boolean | number | Blob | Date | null;
-export declare const file: typeof fileFromPath;
-export declare function convert(source: Record<string, FormDataResolvable>, form?: FormData, parentKey?: string | null): FormData;
+/// <reference types="node" />
+import { FormData } from 'formdata-node';
+import type { FormDataEntryValue } from 'formdata-node';
+import { fileFromPath } from 'formdata-node/file-from-path';
+export type FormDataResolvable = Array<FormDataResolvable> | {
+    [key: string]: FormDataResolvable;
+} | FormDataEntryValue | undefined | boolean | number | Blob | Date | null;
+export declare const file: typeof fileFromPath;
+export declare function convert(source: Record<string, FormDataResolvable>, form?: FormData, parentKey?: string | null): FormData;

package/dist/node/form.js

@@ -1,45 +1,45 @@
 import { FormData, File } from 'formdata-node';
 import { fileFromPath } from 'formdata-node/file-from-path';
 
-const file = fileFromPath;
-function convert(source, form = new FormData(), parentKey = null) {
-    source = source || {};
-    for (const key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-            append(form, toKey(parentKey, key), source[key]);
-        }
-    }
-    return form;
-}
-function append(form, key, value) {
-    if (Array.isArray(value)) {
-        return Array.from(value.keys()).forEach(index => append(form, toKey(key, index.toString()), value[index]));
-    }
-    else if (value instanceof Date) {
-        return form.append(key, value.toISOString());
-    }
-    else if (value instanceof File) {
-        return form.append(key, value, value.name);
-    }
-    else if (value instanceof Blob) {
-        return form.append(key, value);
-    }
-    else if (typeof value === 'boolean') {
-        return form.append(key, value ? '1' : '0');
-    }
-    else if (typeof value === 'string') {
-        return form.append(key, value);
-    }
-    else if (typeof value === 'number') {
-        return form.append(key, `${value}`);
-    }
-    else if (value === null || value === undefined) {
-        return form.append(key, '');
-    }
-    convert(value, form, key);
-}
-function toKey(parent, key) {
-    return parent ? `${parent}[${key}]` : key;
+const file = fileFromPath;
+function convert(source, form = new FormData(), parentKey = null) {
+    source = source || {};
+    for (const key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+            append(form, toKey(parentKey, key), source[key]);
+        }
+    }
+    return form;
+}
+function append(form, key, value) {
+    if (Array.isArray(value)) {
+        return Array.from(value.keys()).forEach(index => append(form, toKey(key, index.toString()), value[index]));
+    }
+    else if (value instanceof Date) {
+        return form.append(key, value.toISOString());
+    }
+    else if (value instanceof File) {
+        return form.append(key, value, value.name);
+    }
+    else if (value instanceof Blob) {
+        return form.append(key, value);
+    }
+    else if (typeof value === 'boolean') {
+        return form.append(key, value ? '1' : '0');
+    }
+    else if (typeof value === 'string') {
+        return form.append(key, value);
+    }
+    else if (typeof value === 'number') {
+        return form.append(key, `${value}`);
+    }
+    else if (value === null || value === undefined) {
+        return form.append(key, '');
+    }
+    convert(value, form, key);
+}
+function toKey(parent, key) {
+    return parent ? `${parent}[${key}]` : key;
 }
 
 export { convert, file };