ovsx 0.2.0 → 0.4.0

package/src/publish.ts

@@ -7,7 +7,6 @@
  *
  * SPDX-License-Identifier: EPL-2.0
  ********************************************************************************/
-
 import { createVSIX, ICreateVSIXOptions } from 'vsce';
 import { createTempFile, addEnvOptions } from './util';
 import { Registry, RegistryOptions } from './registry';
@@ -17,34 +16,46 @@ import { checkLicense } from './check-license';
  * Publishes an extension.
  */
 export async function publish(options: PublishOptions = {}): Promise<void> {
-    addEnvOptions(options);
+        addEnvOptions(options);
+        if (options.packagePath) {
+            // call the publish command for every package path
+            await Promise.all(options.packagePath.map(path => doPublish({ ...options, packagePath: path })));
+        } else {
+            return doPublish({ ... options, packagePath: undefined });
+        }
+}
+
+async function doPublish(options: InternalPublishOptions = {}): Promise<void> {
     if (!options.pat) {
         throw new Error("A personal access token must be given with the option '--pat'.");
     }
 
+    // if the packagePath is a link to a vsix, don't need to package it
+    if (options.packagePath && options.packagePath.endsWith('.vsix')) {
+        options.extensionFile = options.packagePath;
+        delete options.packagePath;
+    }
     const registry = new Registry(options);
     if (!options.extensionFile) {
         await packageExtension(options, registry);
         console.log(); // new line
+    } else if (options.preRelease) {
+        console.warn("Ignoring option '--pre-release' for prepackaged extension.");
     }
 
-    const extension = await registry.publish(options.extensionFile!, options.pat, options.web);
+    const extension = await registry.publish(options.extensionFile!, options.pat);
     if (extension.error) {
         throw new Error(extension.error);
     }
     console.log(`\ud83d\ude80  Published ${extension.namespace}.${extension.name} v${extension.version}`);
 }
 
-export interface PublishOptions extends RegistryOptions {
+interface PublishCommonOptions extends RegistryOptions {
     /**
      * Path to the vsix file to be published. Cannot be used together with `packagePath`.
      */
     extensionFile?: string;
-    /**
-     * Path to the extension to be packaged and published. Cannot be used together
-     * with `extensionFile`.
-     */
-    packagePath?: string;
+
     /**
 	 * The base URL for links detected in Markdown files. Only valid with `packagePath`.
 	 */
@@ -58,28 +69,45 @@ export interface PublishOptions extends RegistryOptions {
 	 */
     yarn?: boolean;
     /**
-     * Enables publishing of web extensions.
+     * Mark this package as a pre-release. Only valid with `packagePath`.
      */
-    web?: boolean;
+    preRelease?: boolean;
 }
 
-async function packageExtension(options: PublishOptions, registry: Registry): Promise<void> {
+// Interface used by top level CLI
+export interface PublishOptions extends PublishCommonOptions {
+
+    /**
+     * Paths to the extension to be packaged and published. Cannot be used together
+     * with `extensionFile`.
+     */
+    packagePath?: string[];
+}
+
+// Interface used internally by the doPublish method
+interface InternalPublishOptions extends PublishCommonOptions {
+
+    /**
+     * Only one path for our internal command.
+     * Path to the extension to be packaged and published. Cannot be used together
+     * with `extensionFile`.
+     */
+    packagePath?: string;
+}
+
+async function packageExtension(options: InternalPublishOptions, registry: Registry): Promise<void> {
     if (registry.requiresLicense) {
         await checkLicense(options.packagePath!);
     }
 
     options.extensionFile = await createTempFile({ postfix: '.vsix' });
-    const createVSIXOptions: IPackageOptions = {
+    const createVSIXOptions: ICreateVSIXOptions = {
         cwd: options.packagePath,
         packagePath: options.extensionFile,
         baseContentUrl: options.baseContentUrl,
         baseImagesUrl: options.baseImagesUrl,
         useYarn: options.yarn,
-        web: options.web
+        preRelease: options.preRelease
     };
     await createVSIX(createVSIXOptions);
-}
-
-interface IPackageOptions extends ICreateVSIXOptions {
-    web?: boolean // experimental flag, not part of the public ICreateVSIXOptions api, yet
-}
+}

package/src/registry.ts

@@ -58,12 +58,9 @@ export class Registry {
         }
     }
 
-    publish(file: string, pat: string, web?: boolean): Promise<Extension> {
+    publish(file: string, pat: string): Promise<Extension> {
         try {
             const query: { [key: string]: string } = { token: pat };
-            if (web) {
-                query.web = 'true';
-            }
             const url = this.getUrl('api/-/publish', query);
             return this.postFile(file, url, {
                 'Content-Type': 'application/octet-stream'