cdeops 0.0.2-alpha.0

package/src/cdeops.proposed.d.ts

@@ -0,0 +1,16 @@
+// Proposed
+/**
+ * This is the place for API experiments and proposals.
+ * These API are NOT stable and subject to change. They are only available in the Insiders
+ * distribution and CANNOT be used in published extensions.
+ *
+ * To test these API in local environment:
+ * - Use Insiders release of VS Code.
+ * - Add `"enableProposedApi": true` to your package.json.
+ * - Copy this file to your project.
+ */
+
+declare module 'cdeops' {
+
+
+}

package/src/index.js

@@ -0,0 +1,9 @@
+// This is the module that is bundled with extensions when they use `import ... from 'cdeops'` or
+// `require('cdeops')`. It delegates to the extension host's runtime implementation of this module by calling
+// `global.require` (which ensures that the extension host's `require` is called at runtime).
+//
+// This dummy file is used when extension is bundled with a JavaScript bundler that lacks support for externals
+// (or when `cdeops` is not configured as an external module). Parcel does not support extenals
+// (https://github.com/parcel-bundler/parcel/issues/144). Webpack, Rollup, and Microbundle support externals.
+
+module.exports = global.require('cdeops')

package/src/subscription.d.ts

@@ -0,0 +1,63 @@
+
+
+declare module 'cdeops' {
+
+    export interface Unsubscribable {
+        unsubscribe(): void;
+    }
+
+    /** Support types for {@link Subscribable}. */
+    interface NextObserver<T> {
+        closed?: boolean
+        next: (value: T) => void
+        error?: (err: any) => void
+        complete?: () => void
+    }
+    interface ErrorObserver<T> {
+        closed?: boolean
+        next?: (value: T) => void
+        error: (err: any) => void
+        complete?: () => void
+    }
+    interface CompletionObserver<T> {
+        closed?: boolean
+        next?: (value: T) => void
+        error?: (err: any) => void
+        complete: () => void
+    }
+    type PartialObserver<T> = NextObserver<T> | ErrorObserver<T> | CompletionObserver<T>
+
+    /**
+     * A stream of values that may be subscribed to.
+     */
+    export interface Subscribable<T> {
+        /**
+         * Subscribes to the stream of values.
+         *
+         * @returns An unsubscribable that, when its {@link Unsubscribable#unsubscribe} method is called, causes
+         * the subscription to stop reacting to the stream.
+         */
+        subscribe(observer?: PartialObserver<T>): Unsubscribable
+        /** @deprecated Use an observer instead of a complete callback */
+        subscribe(next: null | undefined, error: null | undefined, complete: () => void): Unsubscribable
+        /** @deprecated Use an observer instead of an error callback */
+        subscribe(next: null | undefined, error: (error: any) => void, complete?: (() => void) | null): Unsubscribable
+        /** @deprecated Use an observer instead of a complete callback */
+        subscribe(next: (value: T) => void, error: null | undefined, complete: () => void): Unsubscribable
+        subscribe(
+            next?: ((value: T) => void) | null,
+            error?: ((error: any) => void) | null,
+            complete?: (() => void) | null
+        ): Unsubscribable
+    }
+
+    // /**
+    //  * A provider result represents the values that a provider, such as the {@link HoverProvider}, may return. The
+    //  * result may be a single value, a Promise that resolves to a single value, or a Subscribable that emits zero
+    //  * or more values.
+    //  */
+    // export type ProviderResult<T> =
+
+         
+
+}