ovsx 0.2.1 → 0.5.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,60 @@ import { checkLicense } from './check-license';
  * Publishes an extension.
  */
 export async function publish(options: PublishOptions = {}): Promise<void> {
-    addEnvOptions(options);
+        addEnvOptions(options);
+        const internalPublishOptions = [];
+        const packagePaths = options.packagePath || [undefined];
+        const targets = options.targets || [undefined];
+        for (const packagePath of packagePaths) {
+            for (const target of targets) {
+                internalPublishOptions.push({ ... options, packagePath: packagePath, target: target });
+            }
+        }
+        await Promise.all(internalPublishOptions.map(publishOptions => doPublish(publishOptions)));
+}
+
+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;
+        delete options.target;
+    }
     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);
     if (extension.error) {
         throw new Error(extension.error);
     }
-    console.log(`\ud83d\ude80  Published ${extension.namespace}.${extension.name} v${extension.version}`);
+
+    const name = `${extension.namespace}.${extension.name}`;
+	let description = `${name} v${extension.version}`;
+    if (options.target) {
+        description += `@${options.target}`;
+    }
+
+    console.log(`\ud83d\ude80  Published ${description}`);
+    if (extension.warning) {
+        console.log(`\n!!  ${extension.warning}`);
+    }
 }
 
-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`.
 	 */
@@ -57,20 +82,58 @@ export interface PublishOptions extends RegistryOptions {
 	 * Should use `yarn` instead of `npm`. Only valid with `packagePath`.
 	 */
     yarn?: boolean;
+    /**
+     * Mark this package as a pre-release. Only valid with `packagePath`.
+     */
+    preRelease?: boolean;
+}
+
+// Interface used by top level CLI
+export interface PublishOptions extends PublishCommonOptions {
+
+    /**
+     * Target architectures.
+     */
+    targets?: string[];
+
+    /**
+     * 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 target for our internal command.
+     * Target architecture.
+     */
+     target?: string;
+
+    /**
+     * 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: PublishOptions, registry: Registry): Promise<void> {
+async function packageExtension(options: InternalPublishOptions, registry: Registry): Promise<void> {
     if (registry.requiresLicense) {
         await checkLicense(options.packagePath!);
     }
 
     options.extensionFile = await createTempFile({ postfix: '.vsix' });
     const createVSIXOptions: ICreateVSIXOptions = {
+        target: options.target,
         cwd: options.packagePath,
         packagePath: options.extensionFile,
         baseContentUrl: options.baseContentUrl,
         baseImagesUrl: options.baseImagesUrl,
-        useYarn: options.yarn
+        useYarn: options.yarn,
+        preRelease: options.preRelease
     };
     await createVSIX(createVSIXOptions);
 }

package/src/registry.ts

@@ -70,9 +70,12 @@ export class Registry {
         }
     }
 
-    getMetadata(namespace: string, extension: string): Promise<Extension> {
+    getMetadata(namespace: string, extension: string, target?: string): Promise<Extension> {
         try {
-            const path = `api/${encodeURIComponent(namespace)}/${encodeURIComponent(extension)}`;
+            let path = `api/${encodeURIComponent(namespace)}/${encodeURIComponent(extension)}`;
+            if (target) {
+                path += `/${encodeURIComponent(target)}`;
+            }
             return this.getJson(this.getUrl(path));
         } catch (err) {
             return Promise.reject(err);
@@ -240,6 +243,7 @@ export interface RegistryOptions {
 
 export interface Response {
     success?: string;
+    warning?: string;
     error?: string;
 }
 
@@ -252,6 +256,7 @@ export interface Extension extends Response {
     name: string;
     namespace: string;
     version: string;
+    targetPlatform: string;
     publishedBy: UserData;
     verified: boolean;
     // key: version, value: url