@adminide-stack/extension-api 9.1.1-alpha.52 → 9.1.1-alpha.64

package/lib/connections/jsonrpc2/connection.js

@@ -1,4 +1,4 @@
-import*as abortableRx from'../../utils/abortable-rx.js';import {Subject,Observable,isObservable,from}from'rxjs';import {isPromise}from'../../utils/util.js';import'rxjs-compat/observable/fromArray.js';import'rxjs-compat/OuterSubscriber.js';import'rxjs-compat/scheduler/asap.js';import'rxjs-compat/util/subscribeToResult.js';import'@vscode-alt/monaco-editor/esm/vs/base/common/path.js';import {Emitter}from'./events.js';import {LinkedMap}from'./linkedMap.js';import AbortController from'abort-controller';import {isNotificationMessage,isRequestMessage,ErrorCodes,ResponseError,isResponseMessage}from'./messages.js';import {noopTracer}from'./trace.js';const { toPromise } = abortableRx; // to support vite esm
+import*as abortableRx from'../../utils/abortable-rx.js';import {Subject,Observable,isObservable,from}from'rxjs';import {isPromise}from'../../utils/util.js';import'@vscode-alt/monaco-editor/esm/vs/base/common/path.js';import {Emitter}from'./events.js';import {LinkedMap}from'./linkedMap.js';import AbortController from'abort-controller';import {isNotificationMessage,isRequestMessage,ErrorCodes,ResponseError,isResponseMessage}from'./messages.js';import {noopTracer}from'./trace.js';const { toPromise } = abortableRx; // to support vite esm
 const NullLogger = Object.freeze({
     error: () => {
         /* noop */
@@ -155,7 +155,7 @@ function _createConnection(transports, logger) {
         }
     }
     const callback = (message) => {
-        console.log("[callback.ON_MESSAGE]: ", { transports, message });
+        console.log('[callback.ON_MESSAGE]: ', { transports, message });
         try {
             // We have received an abort signal. Check if the message is still in the queue and abort it if allowed
             // to do so.
@@ -237,7 +237,8 @@ function _createConnection(transports, logger) {
             transports.writer.write(message);
         }
         tracer.requestReceived(requestMessage);
-        const element = requestHandlers[requestMessage.method] || requestHandlers[matchedStartActor(Object.keys(requestHandlers), requestMessage.method)];
+        const element = requestHandlers[requestMessage.method] ||
+            requestHandlers[matchedStartActor(Object.keys(requestHandlers), requestMessage.method)];
         const requestHandler = element && element.handler;
         if (requestHandler || starRequestHandler) {
             const abortController = new AbortController();
@@ -256,7 +257,7 @@ function _createConnection(transports, logger) {
                     const onComplete = () => {
                         delete requestAbortControllers[signalKey];
                     };
-                    from(handlerResult).subscribe(value => reply(value, false), error => {
+                    from(handlerResult).subscribe((value) => reply(value, false), (error) => {
                         onComplete();
                         if (error instanceof ResponseError) {
                             replyError(error);
@@ -470,15 +471,14 @@ function _createConnection(transports, logger) {
         catch (e) {
             responseObserver.observer.error(new ResponseError(ErrorCodes.MessageWriteError, e.message ? e.message : 'Unknown reason'));
         }
-        return new Observable(observer => {
-            subject.subscribe(observer).add(() => {
-                if (!isUnsubscribed() &&
-                    responseObserver &&
-                    !responseObserver.complete &&
-                    !responseObserver.observer.closed) {
+        return new Observable((observer) => {
+            const subscription = subject.subscribe(observer);
+            subscription.add(() => {
+                if (!isUnsubscribed() && responseObserver && !responseObserver.complete && !subscription.closed) {
                     sendNotification(ABORT_REQUEST_METHOD, [id]);
                 }
             });
+            return subscription;
         });
     };
     const connection = {
@@ -557,7 +557,7 @@ function setImmediateCompat(f) {
 }
 function matchedStartActor(requestHandlersKeys, method) {
     try {
-        return requestHandlersKeys.filter(name => {
+        return requestHandlersKeys.filter((name) => {
             let methodName = method.split('/')[0];
             return `${methodName}/*` === name;
         })[0];

package/lib/connections/remote-rpc/browser-remote-rpc.js

@@ -1,4 +1,4 @@
-import {QueueingSubject}from'queueing-subject';import {VSBuffer}from'@vscode-alt/monaco-editor/esm/vs/base/common/buffer.js';import {Emitter}from'@vscode-alt/monaco-editor/esm/vs/base/common/event.js';import makeWebSocketObservable,{normalClosureMessage}from'./rxjs-websockets.js';import {switchMap,share}from'rxjs/operators/index.js';class BrowserRemoteRPC {
+import {QueueingSubject}from'queueing-subject';import {VSBuffer}from'@vscode-alt/monaco-editor/esm/vs/base/common/buffer.js';import {Emitter}from'@vscode-alt/monaco-editor/esm/vs/base/common/event.js';import makeWebSocketObservable,{normalClosureMessage}from'./rxjs-websockets.js';import {switchMap,share}from'rxjs';class BrowserRemoteRPC {
     // this subject queues as necessary to ensure every message is delivered
     input$;
     _localHostId;

package/lib/react/components/view-component/ViewComponent.js

@@ -1,4 +1,4 @@
-import React__default,{useState,useEffect}from'react';import {Subscription}from'rxjs';import {map}from'rxjs/operators/index.js';import {useExtensionController}from'../../useExtensionController.js';import {ContributableViewContainer}from'../../../interfaces/contributions/contribution.js';const ViewComponent = (props) => {
+import React__default,{useState,useEffect}from'react';import {Subscription,map}from'rxjs';import {useExtensionController}from'../../useExtensionController.js';import {ContributableViewContainer}from'../../../interfaces/contributions/contribution.js';const ViewComponent = (props) => {
     const [panelView, setPanelView] = useState(null);
     const controller = useExtensionController();
     const subscriptions = new Subscription();

package/lib/utils/abortable-rx.js

@@ -1,4 +1,4 @@
-import {Observable,Subscription,from}from'rxjs';import {switchMap as switchMap$1,concatMap as concatMap$1,mergeMap as mergeMap$1}from'rxjs/operators/index.js';/**
+import {Observable,Subscription,from,switchMap as switchMap$1,concatMap as concatMap$1,mergeMap as mergeMap$1}from'rxjs';/**
  * Copied from https://github.com/felixfbecker/abortable-rx/blob/master/src/index.ts
  * To support esm
  * @returns
@@ -12,7 +12,7 @@ const createAbortError = () => {
 /**
  * Creates an Observable just like RxJS `create`, but exposes an AbortSignal in addition to the subscriber
  */
-const create = (subscribe) => new Observable(subscriber => {
+const create = (subscribe) => new Observable((subscriber) => {
     const abortController = new AbortController();
     const subscription = new Subscription();
     const teardown = subscribe && subscribe(subscriber, abortController.signal);
@@ -45,9 +45,9 @@ const toPromise = (observable, signal) => new Promise((resolve, reject) => {
         }
     };
     let value;
-    subscription = observable.subscribe(val => {
+    subscription = observable.subscribe((val) => {
         value = val;
-    }, err => {
+    }, (err) => {
         cleanup();
         reject(err);
     }, () => {
@@ -77,7 +77,7 @@ const forEach = (source, next, signal) => new Promise((resolve, reject) => {
             signal.removeEventListener('abort', listener);
         }
     };
-    subscription = source.subscribe(value => {
+    subscription = source.subscribe((value) => {
         try {
             next(value);
         }
@@ -87,7 +87,7 @@ const forEach = (source, next, signal) => new Promise((resolve, reject) => {
                 subscription.unsubscribe();
             }
         }
-    }, err => {
+    }, (err) => {
         cleanup();
         reject(err);
     }, () => {
@@ -101,12 +101,12 @@ const forEach = (source, next, signal) => new Promise((resolve, reject) => {
 /**
  * Like RxJS `switchMap`, but passes an AbortSignal that is aborted when the source emits another element.
  */
-const switchMap = (project) => source => source.pipe(switchMap$1((value, index) => defer(abortSignal => project(value, index, abortSignal))));
+const switchMap = (project) => (source) => source.pipe(switchMap$1((value, index) => defer((abortSignal) => project(value, index, abortSignal))));
 /**
  * Like RxJS `concatMap`, but passes an AbortSignal that is aborted when the returned Observable is unsubscribed from.
  */
-const concatMap = (project) => source => source.pipe(concatMap$1((value, index) => defer(abortSignal => project(value, index, abortSignal))));
+const concatMap = (project) => (source) => source.pipe(concatMap$1((value, index) => defer((abortSignal) => project(value, index, abortSignal))));
 /**
  * Like RxJS `mergeMap`, but passes an AbortSignal that is aborted when the returned Observable is unsubscribed from.
  */
-const mergeMap = (project) => source => source.pipe(mergeMap$1((value, index) => defer(abortSignal => project(value, index, abortSignal))));export{concatMap,create,defer,forEach,mergeMap,switchMap,toPromise};
+const mergeMap = (project) => (source) => source.pipe(mergeMap$1((value, index) => defer((abortSignal) => project(value, index, abortSignal))));export{concatMap,create,defer,forEach,mergeMap,switchMap,toPromise};

package/lib/utils/rxjs/combineLatestOrDefault.d.ts

@@ -1,4 +1,4 @@
-import { Observable, ObservableInput } from 'rxjs';
+import { type ObservableInput, Observable } from 'rxjs';
 /**
  * Like {@link combineLatest}, except that it does not wait for all Observables to emit before emitting an initial
  * value. It emits whenever any of the source Observables emit.
@@ -22,7 +22,7 @@ import { Observable, ObservableInput } from 'rxjs';
  * @param observables The source Observables.
  * @param defaultValue The value to emit for a source Observable if it has not yet emitted a value by the time
  * another Observable has emitted a value.
- * @return {Observable} An Observable of an array of the most recent values from each input Observable (or
+ * @returns An Observable of an array of the most recent values from each input Observable (or
  * {@link defaultValue}).
  */
 export declare function combineLatestOrDefault<T>(observables: ObservableInput<T>[], defaultValue?: T): Observable<T[]>;

package/lib/utils/rxjs/combineLatestOrDefault.js

@@ -1,5 +1,4 @@
-import {zip,of}from'rxjs';import {fromArray}from'rxjs-compat/observable/fromArray.js';import {OuterSubscriber}from'rxjs-compat/OuterSubscriber.js';import {asap}from'rxjs-compat/scheduler/asap.js';import {subscribeToResult}from'rxjs-compat/util/subscribeToResult.js';// tslint:disable no-use-before-declare
-/**
+import {Observable,from,asapScheduler,zip,of}from'rxjs';/**
  * Like {@link combineLatest}, except that it does not wait for all Observables to emit before emitting an initial
  * value. It emits whenever any of the source Observables emit.
  *
@@ -22,80 +21,77 @@ import {zip,of}from'rxjs';import {fromArray}from'rxjs-compat/observable/fromArra
  * @param observables The source Observables.
  * @param defaultValue The value to emit for a source Observable if it has not yet emitted a value by the time
  * another Observable has emitted a value.
- * @return {Observable} An Observable of an array of the most recent values from each input Observable (or
+ * @returns An Observable of an array of the most recent values from each input Observable (or
  * {@link defaultValue}).
  */
 function combineLatestOrDefault(observables, defaultValue) {
     switch (observables.length) {
-        case 0:
+        case 0: {
             // No source observables: emit an empty array and complete
             return of([]);
-        case 1:
+        }
+        case 1: {
             // Only one source observable: no need to handle emission accumulation or default values
             return zip(...observables);
-        default:
-            return fromArray(observables).lift(new CombineLatestOperator(defaultValue));
-    }
-}
-class CombineLatestOperator {
-    defaultValue;
-    constructor(defaultValue) {
-        this.defaultValue = defaultValue;
-    }
-    call(subscriber, source) {
-        return source.subscribe(new CombineLatestSubscriber(subscriber, this.defaultValue));
-    }
-}
-class CombineLatestSubscriber extends OuterSubscriber {
-    defaultValue;
-    activeObservables = 0;
-    values = [];
-    observables = [];
-    scheduled = false;
-    constructor(observer, defaultValue) {
-        super(observer);
-        this.defaultValue = defaultValue;
-    }
-    _next(observable) {
-        if (this.defaultValue !== undefined) {
-            this.values.push(this.defaultValue);
-        }
-        this.observables.push(observable);
-    }
-    _complete() {
-        this.activeObservables = this.observables.length;
-        for (let i = 0; i < this.observables.length; i++) {
-            this.add(subscribeToResult(this, this.observables[i], this.observables[i], i));
-        }
-    }
-    notifyComplete() {
-        this.activeObservables--;
-        if (this.activeObservables === 0 && this.destination.complete) {
-            this.destination.complete();
-        }
-    }
-    notifyNext(_outerValue, innerValue, outerIndex) {
-        const values = this.values;
-        values[outerIndex] = innerValue;
-        if (this.activeObservables === 1) {
-            // Only 1 observable is active, so no need to buffer.
-            //
-            // This makes it possible to use RxJS's `of` in tests without specifying an explicit scheduler.
-            if (this.destination.next) {
-                this.destination.next(this.values.slice());
-            }
-            return;
         }
-        // Buffer all next values that are emitted at the same time into one emission.
-        //
-        // This makes tests (using expectObservable) easier to write.
-        if (!this.scheduled) {
-            this.scheduled = true;
-            asap.schedule(() => {
-                if (this.scheduled && this.destination.next) {
-                    this.destination.next(this.values.slice());
+        default: {
+            return new Observable((subscriber) => {
+                // The array of the most recent values from each input Observable.
+                // If a source Observable has not yet emitted a value, it will be represented by the
+                // defaultValue (if provided) or not at all (if not provided).
+                const values = defaultValue !== undefined ? observables.map(() => defaultValue) : [];
+                // Whether the emission of the values array has been scheduled
+                let scheduled = false;
+                let scheduledWork;
+                // The number of source Observables that have not yet completed
+                // (so that we know when to complete the output Observable)
+                let activeObservables = observables.length;
+                // When everything is done, clean up the values array
+                subscriber.add(() => {
+                    values.length = 0;
+                });
+                // Subscribe to each source Observable. The index of the source Observable is used to
+                // keep track of the most recent value from that Observable in the values array.
+                for (let index = 0; index < observables.length; index++) {
+                    subscriber.add(from(observables[index]).subscribe({
+                        next: (value) => {
+                            values[index] = value;
+                            if (activeObservables === 1) {
+                                // If only one source Observable is active, emit the values array immediately
+                                // Abort any scheduled emission
+                                scheduledWork?.unsubscribe();
+                                scheduled = false;
+                                subscriber.next(values.slice());
+                            }
+                            else if (!scheduled) {
+                                scheduled = true;
+                                // Use asapScheduler to emit the values array, so that all
+                                // next values that are emitted at the same time are emitted together.
+                                // This makes tests (using expectObservable) easier to write.
+                                scheduledWork = asapScheduler.schedule(() => {
+                                    if (!subscriber.closed) {
+                                        subscriber.next(values.slice());
+                                        scheduled = false;
+                                        if (activeObservables === 0) {
+                                            subscriber.complete();
+                                        }
+                                    }
+                                });
+                            }
+                        },
+                        error: (error) => subscriber.error(error),
+                        complete: () => {
+                            activeObservables--;
+                            if (activeObservables === 0 && !scheduled) {
+                                subscriber.complete();
+                            }
+                        },
+                    }));
                 }
-                this.scheduled = false;
+                // When everything is done, clean up the values array
+                return () => {
+                    values.length = 0;
+                };
             });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@adminide-stack/extension-api",
-    "version": "9.1.1-alpha.52",
+    "version": "9.1.1-alpha.64",
     "description": "Workbench core for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -20,29 +20,12 @@
         "test:watch": "npm test -- --watch",
         "watch": "npm run build:lib:watch"
     },
-    "jest": {
-        "moduleFileExtensions": [
-            "ts",
-            "tsx",
-            "js",
-            "json"
-        ],
-        "roots": [
-            "src"
-        ],
-        "testEnvironment": "node",
-        "testRegex": "/__tests__/.*test*\\.(ts|tsx|js)$",
-        "transform": {
-            "\\.(ts|tsx)$": "<rootDir>/../../node_modules/ts-jest/preprocessor.js"
-        }
-    },
     "dependencies": {
-        "@adminide-stack/core": "9.1.1-alpha.52",
-        "@workbench-stack/core": "3.6.0",
-        "abort-controller": "^2.0.0",
-        "abortable-rx": "^1.0.9",
+        "@adminide-stack/core": "9.1.1-alpha.64",
+        "@workbench-stack/core": "3.9.5",
+        "abort-controller": "^3.0.0",
         "cdeops": "9.1.1-alpha.43",
-        "minimatch": "^9.0.0",
+        "minimatch": "^10.0.0",
         "queueing-subject": "0.3.4",
         "utility-types": "^3.10.0",
         "valid-url": "1.0.9"
@@ -52,7 +35,7 @@
     },
     "peerDependencies": {
         "@vscode-alt/monaco-editor": ">=0.17.1",
-        "rxjs": "^6.3.3"
+        "rxjs": "^7.8.1"
     },
     "publishConfig": {
         "access": "public"
@@ -60,5 +43,5 @@
     "typescript": {
         "definition": "lib/index.d.ts"
     },
-    "gitHead": "52c2c05beffb0f957159789f3e7aa8c491c4dc1d"
+    "gitHead": "08d13dffd33130f335fd460aedb5e393d6fdb3eb"
 }