@youcan/cli-kit 2.1.4 → 2.2.0

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,30 @@
-/// <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 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 {};

package/dist/node/filesystem.js

@@ -20,85 +20,88 @@ 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 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 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;
 
 export { archived, exists, glob, isDirectory, mkdir, move, readFile, readJsonFile, readdir, 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 };

package/dist/node/git.d.ts

@@ -1,10 +1,10 @@
-export declare function binaryExists(): Promise<boolean>;
-export interface CloneOptions {
-    url: string;
-    destination: string;
-    progressUpdater?: (statusString: string) => void;
-    shallow?: boolean;
-    latestTag?: boolean;
-}
-export declare function assertGitExists(): Promise<void>;
-export declare function clone(cloneOptions: CloneOptions): Promise<void>;
+export declare function binaryExists(): Promise<boolean>;
+export interface CloneOptions {
+    url: string;
+    destination: string;
+    progressUpdater?: (statusString: string) => void;
+    shallow?: boolean;
+    latestTag?: boolean;
+}
+export declare function assertGitExists(): Promise<void>;
+export declare function clone(cloneOptions: CloneOptions): Promise<void>;

package/dist/node/git.js

@@ -1,52 +1,52 @@
 import git from 'simple-git';
 import { exec } from './system.js';
 
-async function binaryExists() {
-    try {
-        await exec('git', ['--version']);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function assertGitExists() {
-    if (!(await binaryExists())) {
-        throw new Error('Git is required for the setup to continue.');
-    }
-}
-async function clone(cloneOptions) {
-    await assertGitExists();
-    const { url, destination, shallow, latestTag } = cloneOptions;
-    const [repository, branch] = url.split('#');
-    const options = { '--recurse-submodules': null };
-    // ignore latest tag if branch is provided
-    if (branch) {
-        options['--branch'] = branch;
-    }
-    if (shallow && latestTag) {
-        throw new Error('Cannot get a shallow clone of the latest branch.');
-    }
-    if (shallow) {
-        options['--depth'] = 1;
-    }
-    const simpleGitOptions = {
-        config: ['core.askpass=true'],
-    };
-    await git(simpleGitOptions)
-        .clone(repository, destination, options);
-    if (latestTag) {
-        const localRepo = git(destination);
-        const latestTag = await getLocalLatestTag(localRepo, url);
-        await localRepo.checkout(latestTag);
-    }
-}
-async function getLocalLatestTag(repository, url) {
-    const latest = (await repository.tags()).latest;
-    if (!latest) {
-        throw new Error(`Couldn't infer the latest tag from ${url}`);
-    }
-    return latest;
+async function binaryExists() {
+    try {
+        await exec('git', ['--version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function assertGitExists() {
+    if (!(await binaryExists())) {
+        throw new Error('Git is required for the setup to continue.');
+    }
+}
+async function clone(cloneOptions) {
+    await assertGitExists();
+    const { url, destination, shallow, latestTag } = cloneOptions;
+    const [repository, branch] = url.split('#');
+    const options = { '--recurse-submodules': null };
+    // ignore latest tag if branch is provided
+    if (branch) {
+        options['--branch'] = branch;
+    }
+    if (shallow && latestTag) {
+        throw new Error('Cannot get a shallow clone of the latest branch.');
+    }
+    if (shallow) {
+        options['--depth'] = 1;
+    }
+    const simpleGitOptions = {
+        config: ['core.askpass=true'],
+    };
+    await git(simpleGitOptions)
+        .clone(repository, destination, options);
+    if (latestTag) {
+        const localRepo = git(destination);
+        const latestTag = await getLocalLatestTag(localRepo, url);
+        await localRepo.checkout(latestTag);
+    }
+}
+async function getLocalLatestTag(repository, url) {
+    const latest = (await repository.tags()).latest;
+    if (!latest) {
+        throw new Error(`Couldn't infer the latest tag from ${url}`);
+    }
+    return latest;
 }
 
 export { assertGitExists, binaryExists, clone };

package/dist/node/github.d.ts

@@ -1,6 +1,6 @@
-export interface RepositoryReference {
-    baseUrl: string;
-    branch?: string;
-    path?: string;
-}
-export declare function parseRepositoryReference(reference: string): RepositoryReference;
+export interface RepositoryReference {
+    baseUrl: string;
+    branch?: string;
+    path?: string;
+}
+export declare function parseRepositoryReference(reference: string): RepositoryReference;