@solibo/solibo-sdk 1.1.31 → 1.1.32

package/index.d.ts

@@ -1,5 +1,58 @@
 // Re-export everything from the ESM bundles
 export * from './solibo-sdk-sdk.mjs';
 export * from './solibo-sdk-sdk-home-api.mjs';
-// Explicitly re-export bridge types to resolve ESM ambiguity
-export { KtList, KtMap, KtMutableList, KtMutableMap } from './solibo-sdk-sdk.mjs';
+// Augment bridge types with JS collection methods
+declare module './solibo-sdk-sdk.mjs' {
+    interface KtList<E> {
+        map<U>(callback: (value: E, index: number, array: ReadonlyArray<E>) => U, thisArg?: any): U[];
+        filter(callback: (value: E, index: number, array: ReadonlyArray<E>) => boolean, thisArg?: any): E[];
+        forEach(callback: (value: E, index: number, array: ReadonlyArray<E>) => void, thisArg?: any): void;
+        reduce<U>(callback: (accumulator: U, value: E, index: number, array: ReadonlyArray<E>) => U, initialValue: U): U;
+        find(callback: (value: E, index: number, array: ReadonlyArray<E>) => boolean, thisArg?: any): E | undefined;
+        findIndex(callback: (value: E, index: number, array: ReadonlyArray<E>) => boolean, thisArg?: any): number;
+        some(callback: (value: E, index: number, array: ReadonlyArray<E>) => boolean, thisArg?: any): boolean;
+        every(callback: (value: E, index: number, array: ReadonlyArray<E>) => boolean, thisArg?: any): boolean;
+        includes(searchElement: E, fromIndex?: number): boolean;
+        indexOf(searchElement: E, fromIndex?: number): number;
+        lastIndexOf(searchElement: E, fromIndex?: number): number;
+        at(index: number): E | undefined;
+        join(separator?: string): string;
+        slice(start?: number, end?: number): E[];
+        [Symbol.iterator](): IterableIterator<E>;
+    }
+    interface KtMap<K, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        forEach(callback: (value: V, key: K, map: ReadonlyMap<K, V>) => void, thisArg?: any): void;
+        keys(): IterableIterator<K>;
+        values(): IterableIterator<V>;
+        entries(): IterableIterator<[K, V]>;
+        [Symbol.iterator](): IterableIterator<[K, V]>;
+    }
+    interface KtMutableList<E> {
+        map<U>(callback: (value: E, index: number, array: Array<E>) => U, thisArg?: any): U[];
+        filter(callback: (value: E, index: number, array: Array<E>) => boolean, thisArg?: any): E[];
+        forEach(callback: (value: E, index: number, array: Array<E>) => void, thisArg?: any): void;
+        reduce<U>(callback: (accumulator: U, value: E, index: number, array: Array<E>) => U, initialValue: U): U;
+        find(callback: (value: E, index: number, array: Array<E>) => boolean, thisArg?: any): E | undefined;
+        findIndex(callback: (value: E, index: number, array: Array<E>) => boolean, thisArg?: any): number;
+        some(callback: (value: E, index: number, array: Array<E>) => boolean, thisArg?: any): boolean;
+        every(callback: (value: E, index: number, array: Array<E>) => boolean, thisArg?: any): boolean;
+        includes(searchElement: E, fromIndex?: number): boolean;
+        indexOf(searchElement: E, fromIndex?: number): number;
+        lastIndexOf(searchElement: E, fromIndex?: number): number;
+        at(index: number): E | undefined;
+        join(separator?: string): string;
+        slice(start?: number, end?: number): E[];
+        [Symbol.iterator](): IterableIterator<E>;
+    }
+    interface KtMutableMap<K, V> {
+        get(key: K): V | undefined;
+        has(key: K): boolean;
+        forEach(callback: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+        keys(): IterableIterator<K>;
+        values(): IterableIterator<V>;
+        entries(): IterableIterator<[K, V]>;
+        [Symbol.iterator](): IterableIterator<[K, V]>;
+    }
+}

package/index.mjs

@@ -1,11 +1,54 @@
 // Re-export everything from the ESM bundles
 export * from './solibo-sdk-sdk.mjs';
 export * from './solibo-sdk-sdk-home-api.mjs';
-// Explicitly re-export bridge types from stdlib to resolve ESM ambiguity
-export {
+// Import bridge types from stdlib to polyfill and re-export them
+import {
   KtList,
   KtMap,
   KtMutableList,
   KtMutableMap,
-  Instant2s2zyzgfc4947 as Instant,
+  Instant2s2zyzgfc4947 as Instant_Internal,
 } from './kotlin-kotlin-stdlib.mjs';
+
+
+// Polyfill for KtList, KtMap, KtSet to support JS collection methods directly
+(function() {
+    if (typeof KtList !== 'undefined' && KtList.fromJsArray) {
+        const proto = Object.getPrototypeOf(KtList.fromJsArray([]));
+        if (proto && !proto.map) {
+            const arrayMethods = ['map', 'filter', 'forEach', 'reduce', 'reduceRight', 'find', 'findIndex', 'some', 'every', 'includes', 'indexOf', 'lastIndexOf', 'at', 'join', 'slice', 'flat', 'flatMap'];
+            arrayMethods.forEach(name => {
+                if (!proto[name]) proto[name] = function(...args) { return this.asJsReadonlyArrayView()[name](...args); };
+            });
+            if (!proto[Symbol.iterator]) proto[Symbol.iterator] = function() { return this.asJsReadonlyArrayView()[Symbol.iterator](); };
+        }
+    }
+    if (typeof KtMap !== 'undefined' && KtMap.fromJsMap) {
+        const proto = Object.getPrototypeOf(KtMap.fromJsMap(new Map()));
+        if (proto && !proto.get) {
+             const mapMethods = ['get', 'has', 'keys', 'values', 'entries', 'forEach'];
+             mapMethods.forEach(name => {
+                 if (!proto[name]) proto[name] = function(...args) { return this.asJsReadonlyMapView()[name](...args); };
+             });
+             if (!proto[Symbol.iterator]) proto[Symbol.iterator] = function() { return this.asJsReadonlyMapView()[Symbol.iterator](); };
+        }
+    }
+    if (typeof KtSet !== 'undefined' && KtSet.fromJsSet) {
+        const proto = Object.getPrototypeOf(KtSet.fromJsSet(new Set()));
+        if (proto && !proto.has) {
+             const setMethods = ['has', 'keys', 'values', 'entries', 'forEach'];
+             setMethods.forEach(name => {
+                 if (!proto[name]) proto[name] = function(...args) { return this.asJsReadonlySetView()[name](...args); };
+             });
+             if (!proto[Symbol.iterator]) proto[Symbol.iterator] = function() { return this.asJsReadonlySetView()[Symbol.iterator](); };
+        }
+    }
+})();
+
+export {
+  KtList,
+  KtMap,
+  KtMutableList,
+  KtMutableMap,
+  Instant_Internal as Instant,
+};

package/kotlin-kotlin-stdlib.mjs

@@ -37,17 +37,6 @@ if (typeof Array.prototype.fill === 'undefined') {
     Object.defineProperty(TypedArray.prototype, 'fill', {value: Array.prototype.fill});
   }
 });
-if (typeof Math.clz32 === 'undefined') {
-  Math.clz32 = function (log, LN2) {
-    return function (x) {
-      var asUint = x >>> 0;
-      if (asUint === 0) {
-        return 32;
-      }
-      return 31 - (log(asUint) / LN2 | 0) | 0; // the "| 0" acts like math.floor
-    };
-  }(Math.log, Math.LN2);
-}
 if (typeof Math.trunc === 'undefined') {
   Math.trunc = function (x) {
     if (isNaN(x)) {
@@ -64,6 +53,17 @@ if (typeof Math.log10 === 'undefined') {
     return Math.log(x) * Math.LOG10E;
   };
 }
+if (typeof Math.clz32 === 'undefined') {
+  Math.clz32 = function (log, LN2) {
+    return function (x) {
+      var asUint = x >>> 0;
+      if (asUint === 0) {
+        return 32;
+      }
+      return 31 - (log(asUint) / LN2 | 0) | 0; // the "| 0" acts like math.floor
+    };
+  }(Math.log, Math.LN2);
+}
 if (typeof String.prototype.endsWith === 'undefined') {
   Object.defineProperty(String.prototype, 'endsWith', {value: function (searchString, position) {
     var subjectString = this.toString();

package/kotlinx-coroutines-core.mjs

@@ -224,6 +224,11 @@ initMetadataForClass(SendBroadcast, 'SendBroadcast', VOID, VOID, [Waiter]);
 initMetadataForClass(BufferedChannelIterator, 'BufferedChannelIterator', VOID, VOID, [Waiter], [0, 3]);
 initMetadataForCoroutine($sendCOROUTINE$, CoroutineImpl);
 initMetadataForCoroutine($receiveCOROUTINE$, CoroutineImpl);
+function close$default(cause, $super) {
+  cause = cause === VOID ? null : cause;
+  return $super === VOID ? this.y2p(cause) : $super.y2p.call(this, cause);
+}
+initMetadataForInterface(SendChannel, 'SendChannel', VOID, VOID, VOID, [1]);
 function cancel$default_0(cause, $super) {
   cause = cause === VOID ? null : cause;
   var tmp;
@@ -236,12 +241,7 @@ function cancel$default_0(cause, $super) {
   return tmp;
 }
 initMetadataForInterface(ReceiveChannel, 'ReceiveChannel', VOID, VOID, VOID, [0]);
-function close$default(cause, $super) {
-  cause = cause === VOID ? null : cause;
-  return $super === VOID ? this.y2p(cause) : $super.y2p.call(this, cause);
-}
-initMetadataForInterface(SendChannel, 'SendChannel', VOID, VOID, VOID, [1]);
-initMetadataForClass(BufferedChannel, 'BufferedChannel', VOID, VOID, [ReceiveChannel, SendChannel], [1, 4, 0, 3]);
+initMetadataForClass(BufferedChannel, 'BufferedChannel', VOID, VOID, [SendChannel, ReceiveChannel], [1, 4, 0, 3]);
 initMetadataForClass(WaiterEB, 'WaiterEB');
 initMetadataForClass(ReceiveCatching, 'ReceiveCatching', VOID, VOID, [Waiter]);
 initMetadataForObject(Factory, 'Factory');
@@ -251,7 +251,7 @@ initMetadataForCompanion(Companion);
 initMetadataForClass(ChannelResult, 'ChannelResult');
 initMetadataForClass(ClosedReceiveChannelException, 'ClosedReceiveChannelException', VOID, NoSuchElementException);
 initMetadataForClass(ClosedSendChannelException, 'ClosedSendChannelException', VOID, IllegalStateException);
-initMetadataForClass(ChannelCoroutine, 'ChannelCoroutine', VOID, AbstractCoroutine, [AbstractCoroutine, ReceiveChannel, SendChannel], [1, 0]);
+initMetadataForClass(ChannelCoroutine, 'ChannelCoroutine', VOID, AbstractCoroutine, [AbstractCoroutine, SendChannel, ReceiveChannel], [1, 0]);
 initMetadataForClass(ConflatedBufferedChannel, 'ConflatedBufferedChannel', VOID, BufferedChannel, VOID, [1, 0]);
 initMetadataForInterface(ProducerScope, 'ProducerScope', VOID, VOID, [CoroutineScope, SendChannel], [1]);
 initMetadataForClass(ProducerCoroutine, 'ProducerCoroutine', VOID, ChannelCoroutine, [ChannelCoroutine, ProducerScope], [1, 0]);
@@ -270,7 +270,7 @@ initMetadataForClass(ContextScope, 'ContextScope', VOID, VOID, [CoroutineScope])
 initMetadataForClass(Symbol, 'Symbol');
 initMetadataForInterface(SelectInstance, 'SelectInstance');
 initMetadataForClass(ClauseData, 'ClauseData', VOID, VOID, VOID, [1]);
-initMetadataForClass(SelectImplementation, 'SelectImplementation', VOID, VOID, [CancelHandler, SelectInstance, Waiter], [0, 2]);
+initMetadataForClass(SelectImplementation, 'SelectImplementation', VOID, VOID, [CancelHandler, Waiter, SelectInstance], [0, 2]);
 initMetadataForClass(TrySelectDetailedResult, 'TrySelectDetailedResult', VOID, Enum);
 function tryLock$default(owner, $super) {
   owner = owner === VOID ? null : owner;