@eik/cli 3.0.0-next.2 → 3.1.0

package/types/classes/ping.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @typedef {object} PingOptions
+ * @property {string} [server]
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ */
+export default class Ping {
+    /**
+     * @param {PingOptions} options
+     */
+    constructor({ logger, server }?: PingOptions);
+    log: abslog.ValidLogger;
+    server: string;
+    /**
+     * Run the ping command
+     * @returns {Promise<boolean>}
+     */
+    run(): Promise<boolean>;
+}
+export type PingOptions = {
+    server?: string;
+    logger?: import("abslog").AbstractLoggerOptions;
+};
+import abslog from 'abslog';

package/types/classes/publish/map.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @typedef {object} PublishMapOptions
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ * @property {string} server
+ * @property {string} [cwd]
+ * @property {string} token
+ * @property {string} file
+ * @property {string} name
+ * @property {string} version
+ */
+/**
+ * @typedef {object} PublishMapResult
+ * @property {string} server
+ * @property {string} name
+ * @property {string} version
+ * @property {string} type
+ */
+export default class PublishMap {
+    /**
+     * @param {PublishMapOptions} options
+     */
+    constructor({ logger, cwd, server, token, file, name, version, }: PublishMapOptions);
+    log: abslog.ValidLogger;
+    cwd: string;
+    server: string;
+    token: string;
+    name: string;
+    version: string;
+    file: string;
+    /**
+     * @returns {Promise<PublishMapResult>}
+     */
+    run(): Promise<PublishMapResult>;
+    absoluteFile: string;
+}
+export type PublishMapOptions = {
+    logger?: import("abslog").AbstractLoggerOptions;
+    server: string;
+    cwd?: string;
+    token: string;
+    file: string;
+    name: string;
+    version: string;
+};
+export type PublishMapResult = {
+    server: string;
+    name: string;
+    version: string;
+    type: string;
+};
+import abslog from 'abslog';

package/types/classes/publish/package/index.d.ts

@@ -0,0 +1,94 @@
+/**
+ * @typedef {object} PublishOptions
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ * @property {string} [cwd]
+ * @property {string} token
+ * @property {boolean} [dryRun=false]
+ * @property {string} server
+ * @property {"package" | "map" | "npm" | "image"} [type="package"]
+ * @property {string} name
+ * @property {string} [version="1.0.0"]
+ * @property {string[]} [map]
+ * @property {string} [out="./.eik"]
+ * @property {Record<string, string>} files
+ */
+/**
+ * @typedef {object} PublishResult
+ * @property {string} type
+ * @property {string} server
+ * @property {string} name
+ * @property {unknown} level
+ * @property {boolean} dryRun
+ * @property {string} integrity
+ * @property {unknown} created
+ * @property {unknown} author
+ * @property {string} org
+ * @property {string} version
+ * @property {unknown} response
+ * @property {Array<{ pathname: string; type: string; }>} files
+ */
+export default class Publish {
+    /**
+     * @param {PublishOptions} options
+     */
+    constructor({ logger, cwd, token, dryRun, server, type, name, version, map, out, files, }: PublishOptions);
+    log: abslog.ValidLogger;
+    cwd: string;
+    dryRun: boolean;
+    config: EikConfig;
+    path: string;
+    validateInput: ValidateInput;
+    createTempDirectory: CreateTempDirectory;
+    createZipFile: CreateZipFile;
+    checkBundleSizes: CheckBundleSizes;
+    runDryRun: DryRun;
+    checkIfAlreadyPublished: CheckIfAlreadyPublished;
+    uploadFiles: UploadFiles;
+    saveMetafile: SaveMetafile;
+    cleanup: Cleanup;
+    /**
+     * @returns {Promise<PublishResult>}
+     */
+    run(): Promise<PublishResult>;
+}
+export type PublishOptions = {
+    logger?: import("abslog").AbstractLoggerOptions;
+    cwd?: string;
+    token: string;
+    dryRun?: boolean;
+    server: string;
+    type?: "package" | "map" | "npm" | "image";
+    name: string;
+    version?: string;
+    map?: string[];
+    out?: string;
+    files: Record<string, string>;
+};
+export type PublishResult = {
+    type: string;
+    server: string;
+    name: string;
+    level: unknown;
+    dryRun: boolean;
+    integrity: string;
+    created: unknown;
+    author: unknown;
+    org: string;
+    version: string;
+    response: unknown;
+    files: Array<{
+        pathname: string;
+        type: string;
+    }>;
+};
+import abslog from 'abslog';
+import { EikConfig } from '@eik/common';
+import ValidateInput from './tasks/validate-input.js';
+import CreateTempDirectory from './tasks/create-temp-directory.js';
+import CreateZipFile from './tasks/create-zip-file.js';
+import CheckBundleSizes from './tasks/check-bundle-sizes.js';
+import DryRun from './tasks/dry-run.js';
+import CheckIfAlreadyPublished from './tasks/check-if-already-published.js';
+import UploadFiles from './tasks/upload-files.js';
+import SaveMetafile from './tasks/save-metafile.js';
+import Cleanup from './tasks/cleanup.js';

package/types/classes/publish/package/tasks/check-bundle-sizes.d.ts

@@ -0,0 +1,4 @@
+export default class CheckBundleSizes extends Task {
+    process(): Promise<void>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/check-if-already-published.d.ts

@@ -0,0 +1,4 @@
+export default class CheckIfAlreadyPublished extends Task {
+    process(): Promise<string>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/cleanup.d.ts

@@ -0,0 +1,4 @@
+export default class Cleanup extends Task {
+    process(): Promise<void>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/create-temp-directory.d.ts

@@ -0,0 +1,4 @@
+export default class CreateTempDir extends Task {
+    process(): Promise<void>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/create-zip-file.d.ts

@@ -0,0 +1,4 @@
+export default class CreateZipFile extends Task {
+    process(): Promise<string>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/dry-run.d.ts

@@ -0,0 +1,7 @@
+export default class DryRun extends Task {
+    process(zipFile: any): Promise<{
+        pathname: any;
+        type: string;
+    }[]>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/save-metafile.d.ts

@@ -0,0 +1,4 @@
+export default class SaveMetaFile extends Task {
+    process(response: any): Promise<void>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/task.d.ts

@@ -0,0 +1,8 @@
+export default class Task {
+    constructor(options: any);
+    cwd: any;
+    log: abslog.ValidLogger;
+    path: any;
+    config: any;
+}
+import abslog from 'abslog';

package/types/classes/publish/package/tasks/upload-files.d.ts

@@ -0,0 +1,4 @@
+export default class UploadFiles extends Task {
+    process(zipFile: any): Promise<any>;
+}
+import Task from './task.js';

package/types/classes/publish/package/tasks/validate-input.d.ts

@@ -0,0 +1,4 @@
+export default class ValidateInput extends Task {
+    process(): void;
+}
+import Task from './task.js';

package/types/classes/version.d.ts

@@ -0,0 +1,43 @@
+/**
+ * @typedef {object} VersionOptions
+ * @property {import('abslog').AbstractLoggerOptions} [logger]
+ * @property {string} server
+ * @property {"package" | "npm" | "map"} [type="package"]
+ * @property {string} name
+ * @property {string} version
+ * @property {import("semver").ReleaseType} [level="patch"]
+ * @property {string} cwd
+ * @property {string[]} [map]
+ * @property {string} [out="./.eik"]
+ * @property {string | Record<string, string>} files
+ */
+export default class Version {
+    /**
+     * @param {VersionOptions} options
+     */
+    constructor({ logger, server, type, name, version, level, cwd, map, out, files, }: VersionOptions);
+    log: abslog.ValidLogger;
+    config: EikConfig;
+    path: string;
+    level: semver.ReleaseType;
+    /**
+     * Similar to `npm version`, but updates `eik.json`
+     * @returns {Promise<string | null>} The new version number, or null if the versioning failed
+     */
+    run(): Promise<string | null>;
+}
+export type VersionOptions = {
+    logger?: import("abslog").AbstractLoggerOptions;
+    server: string;
+    type?: "package" | "npm" | "map";
+    name: string;
+    version: string;
+    level?: import("semver").ReleaseType;
+    cwd: string;
+    map?: string[];
+    out?: string;
+    files: string | Record<string, string>;
+};
+import abslog from 'abslog';
+import { EikConfig } from '@eik/common';
+import semver from 'semver';

package/types/utils/hash/compare.d.ts

@@ -0,0 +1,2 @@
+declare function _default(hash1: string, hash2: string): boolean;
+export default _default;

package/types/utils/hash/file.d.ts

@@ -0,0 +1,2 @@
+declare function _default(path: string): Promise<string>;
+export default _default;

package/types/utils/hash/files.d.ts

@@ -0,0 +1,2 @@
+declare function _default(files: string[]): Promise<string>;
+export default _default;

package/types/utils/hash/index.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    export { file };
+    export { files };
+    export { compare };
+}
+export default _default;
+import file from './file.js';
+import files from './files.js';
+import compare from './compare.js';

package/types/utils/http/index.d.ts

@@ -0,0 +1,12 @@
+declare namespace _default {
+    export { latestVersion };
+    export { versions };
+    export { integrity };
+    export { request };
+}
+export default _default;
+import latestVersion from './latest-version.js';
+import versions from './versions.js';
+import integrity from './integrity.js';
+import request from './request.js';
+export { latestVersion, versions, integrity, request };

package/types/utils/http/integrity.d.ts

@@ -0,0 +1,2 @@
+declare function _default(server: string, type: any, name: string, version: string): Promise<string>;
+export default _default;

package/types/utils/http/latest-version.d.ts

@@ -0,0 +1,2 @@
+declare function _default(server: string, type: any, name: string, major: string | number): Promise<string | null>;
+export default _default;

package/types/utils/http/request.d.ts

@@ -0,0 +1,33 @@
+export default request;
+export type RequestOptions = {
+    method?: string;
+    host: string;
+    pathname: string;
+    data?: unknown;
+    file?: string;
+    map?: string;
+    token?: string;
+};
+/**
+ * @typedef {object} RequestOptions
+ * @property {string} [method="POST"]
+ * @property {string} host
+ * @property {string} pathname
+ * @property {unknown} [data]
+ * @property {string} [file]
+ * @property {string} [map]
+ * @property {string} [token]
+ */
+/**
+ * HTTP Utility for making requests against an Eik server
+ *
+ * @param {RequestOptions} options
+ *
+ * @returns {Promise<{ status:number; message: object | string }>} - Promise that resolves to an object with properties status and message
+ *
+ * @throws Error
+ */
+declare function request(options: RequestOptions): Promise<{
+    status: number;
+    message: object | string;
+}>;

package/types/utils/http/versions.d.ts

@@ -0,0 +1,5 @@
+declare function _default(server: string, type: any, name: string): Promise<Array<Array<number, {
+    version: string;
+    integrity: string;
+}>>>;
+export default _default;

package/types/utils/index.d.ts

@@ -0,0 +1,6 @@
+import logger from './logger.js';
+export const getDefaults: typeof helpers.getDefaults;
+export const typeSlug: typeof helpers.typeSlug;
+import typeTitle from './type-title.js';
+import { helpers } from '@eik/common';
+export { logger, typeTitle };

package/types/utils/json/index.d.ts

@@ -0,0 +1,9 @@
+declare namespace _default {
+    export { read };
+    export { write };
+    export { writeEik };
+}
+export default _default;
+import read from './read.js';
+import write from './write.js';
+import writeEik from './write-eik.js';

package/types/utils/json/read.d.ts

@@ -0,0 +1,5 @@
+declare function _default(location: string | {
+    filename: string;
+    cwd: string;
+}): Promise<unknown>;
+export default _default;

package/types/utils/json/write-eik.d.ts

@@ -0,0 +1,5 @@
+declare function _default(data: object, options: {
+    cwd: string;
+    filename: string;
+}): Promise<undefined>;
+export default _default;

package/types/utils/json/write.d.ts

@@ -0,0 +1,5 @@
+declare function _default(meta: object, location: string | {
+    cwd: string;
+    filename: string;
+}): Promise<undefined>;
+export default _default;

package/types/utils/logger.d.ts

@@ -0,0 +1,33 @@
+export default logger;
+/**
+ * Creates a logger object that wraps an instance of the "ora" module in order to provide consistent command line logging that includes a spinner
+ *
+ * @param {object} spinner
+ * @param {boolean} debug
+ */
+declare function logger(spinner: object, debug?: boolean): {
+    /**
+     * @param {string} message
+     */
+    fatal(message: string): void;
+    /**
+     * @param {string} message
+     */
+    error(message: string): void;
+    /**
+     * @param {string} message
+     */
+    warn(message: string): void;
+    /**
+     * @param {string} message
+     */
+    info(message: string): void;
+    /**
+     * @param {string} message
+     */
+    debug(message: string): void;
+    /**
+     * @param {string} message
+     */
+    trace(message: string): void;
+};

package/types/utils/type-title.d.ts

@@ -0,0 +1,2 @@
+declare function _default(type: any): "PACKAGE" | "NPM" | "MAP";
+export default _default;

package/utils/hash/compare.js

@@ -1,5 +1,3 @@
-'use strict';
-
 /**
  * Compares 2 hash strings for comparison. Returns `true` if hashes are identical, false otherwise.
  *
@@ -10,4 +8,4 @@
  *
  * @example hash.compare('a1b22c23d24e25f4g33a123b23c34', 'a1b22c23d24e25f4g33a123b23c34');
  */
-module.exports = (hash1, hash2) => hash1 === hash2;
+export default (hash1, hash2) => hash1 === hash2;

package/utils/hash/file.js

@@ -1,7 +1,5 @@
-'use strict';
-
-const ssri = require('ssri');
-const fs = require('fs');
+import ssri from 'ssri';
+import fs from 'fs';
 
 /**
  * Reads a file from a given path and produces and returns an integrity hash from its contents
@@ -12,7 +10,7 @@ const fs = require('fs');
  *
  * @example hash.file('/path/to/file.js');
  */
-module.exports = async (path) => {
+export default async (path) => {
     const integrity = await ssri.fromStream(fs.createReadStream(path));
     return integrity.toString();
 };

package/utils/hash/files.js

@@ -1,18 +1,16 @@
-'use strict';
-
-const ssri = require('ssri');
-const fileHash = require('./file');
+import ssri from 'ssri';
+import fileHash from './file.js';
 
 /**
  * Reads files from given paths and produces and returns an integrity hash from all files contents
  *
- * @param {[string]} files - an array of file paths
+ * @param {string[]} files - an array of file paths
  *
  * @returns {Promise<string>} - integrity string
  *
  * @example hash.files(['/path/to/file1.js', '/path/to/file2.js']);
  */
-module.exports = async (files) => {
+export default async (files) => {
     const hashes = await Promise.all(files.map(fileHash));
     const hasher = ssri.create();
     for (const hash of hashes.sort()) {

package/utils/hash/index.js

@@ -1,5 +1,5 @@
-const file = require('./file');
-const files = require('./files');
-const compare = require('./compare');
+import file from './file.js';
+import files from './files.js';
+import compare from './compare.js';
 
-module.exports = { file, files, compare };
+export default { file, files, compare };

package/utils/http/index.js

@@ -1,6 +1,7 @@
-const latestVersion = require('./latest-version');
-const versions = require('./versions');
-const integrity = require('./integrity');
-const request = require('./request');
+import latestVersion from './latest-version.js';
+import versions from './versions.js';
+import integrity from './integrity.js';
+import request from './request.js';
 
-module.exports = { latestVersion, versions, integrity, request };
+export default { latestVersion, versions, integrity, request };
+export { latestVersion, versions, integrity, request };

package/utils/http/integrity.js

@@ -1,7 +1,4 @@
-'use strict';
-
-const { join } = require('path');
-const fetch = require('node-fetch');
+import { join } from 'path';
 
 /**
  * Fetches package integrity string by name and version from a given Eik asset server.
@@ -14,7 +11,7 @@ const fetch = require('node-fetch');
  *
  * @throws Error
  */
-module.exports = async (server, type, name, version) => {
+export default async (server, type, name, version) => {
     const url = new URL(join(type, name, version), server);
     url.search = `?t=${Date.now()}`;
 

package/utils/http/latest-version.js

@@ -1,7 +1,4 @@
-'use strict';
-
-const { join } = require('path');
-const fetch = require('node-fetch');
+import { join } from 'path';
 
 /**
  * Fetches the latest version from an Eik server of a package by name, optionally restricting the lookup to a specified semver major version
@@ -14,7 +11,7 @@ const fetch = require('node-fetch');
  *
  * @throws Error
  */
-module.exports = async (server, type, name, major) => {
+export default async (server, type, name, major) => {
     const url = new URL(`${join(type, name)}?t=${Date.now()}`, server);
     const res = await fetch(url);
     if (!res.ok) {

package/utils/http/request.js

@@ -1,59 +1,65 @@
-'use strict';
+import { readFile } from 'node:fs/promises';
 
-const fetch = require('node-fetch');
-const FormData = require('form-data');
-const { createReadStream } = require('fs');
+/**
+ * @typedef {object} RequestOptions
+ * @property {string} [method="POST"]
+ * @property {string} host
+ * @property {string} pathname
+ * @property {unknown} [data]
+ * @property {string} [file]
+ * @property {string} [map]
+ * @property {string} [token]
+ */
 
 /**
  * HTTP Utility for making requests against an Eik server
  *
- * @param {{method:string,host:string,pathname:string,data:object,file:string,map:string,token:string}} options
+ * @param {RequestOptions} options
  *
- * @returns {Promise<{status:number,message:object|string}>} - Promise that resolves to an object with properties status and message
+ * @returns {Promise<{ status:number; message: object | string }>} - Promise that resolves to an object with properties status and message
  *
  * @throws Error
  */
 async function request(options) {
     const { method = 'POST', host, pathname, data, file, map, token } = options;
-    const form = new FormData();
-    const headers = {};
+    const body = new FormData();
+    const headers = new Headers();
 
     if (data) {
         for (const [key, value] of Object.entries(data)) {
-            form.append(key, value);
+            body.set(key, value);
         }
     }
 
     if (file) {
-        form.append('package', createReadStream(file));
+        const fileData = await readFile(file);
+        body.set('package', new Blob([fileData]));
     }
 
     if (map) {
-        form.append('map', createReadStream(map));
+        const mapData = await readFile(map);
+        body.set('map', new Blob([mapData]));
     }
 
     if (token) {
-        headers.Authorization = `Bearer ${token}`;
+        headers.set('Authorization', `Bearer ${token}`);
     }
 
     try {
         const url = new URL(pathname, host);
         url.search = `?t=${Date.now()}`;
 
-        const res = await fetch(url, {
-            method,
-            body: form,
-            headers: { ...headers, ...form.getHeaders() },
-        });
+        const res = await fetch(url, { method, body, headers });
 
         if (!res.ok) {
             const err = new Error(
                 `Server responded with a non 200 ok status code. Response: ${res.status}`,
             );
+            // @ts-ignore
             err.statusCode = res.status;
             throw err;
         }
-        if (res.headers.get('content-type').includes('application/json')) {
+        if (res?.headers?.get('content-type')?.includes('application/json')) {
             return { message: await res.json(), status: res.status };
         }
         return { message: await res.text(), status: res.status };
@@ -65,4 +71,4 @@ async function request(options) {
     }
 }
 
-module.exports = request;
+export default request;