@permaweb/libs 0.0.85 → 0.0.87

package/dist/types/common/arweave.d.ts

@@ -1,10 +1,12 @@
 import { DependencyType, TagType } from '../helpers/types.ts';
 export declare function resolveTransactionWith(deps: DependencyType): (data: any) => Promise<any>;
 export declare function createTransaction(deps: DependencyType, args: {
-    data: File | string;
+    data: any;
     tags?: TagType[];
 }): Promise<string>;
-export declare function runUpload(fileBlob: Blob, txOpts: any & {
+export declare function runUpload(fileBlob: any, // Blob or Uint8Array (React Native)
+platform: any, // PlatformContext
+txOpts: any & {
     upload?: any;
 }, uploadOpts: {
     apiUrl: string;

package/dist/types/common/gql.d.ts

@@ -1,4 +1,4 @@
-import { BatchAGQLResponseType, BatchGQLArgsType, DefaultGQLResponseType, GQLArgsType, GQLNodeResponseType } from '../helpers/types.ts';
-export declare function getGQLData(args: GQLArgsType): Promise<DefaultGQLResponseType>;
-export declare function getAggregatedGQLData(args: GQLArgsType, callback?: (message: string) => void): Promise<GQLNodeResponseType[] | null>;
+import { BatchAGQLResponseType, BatchGQLArgsType, DefaultGQLResponseType, DependencyType, GQLArgsType, GQLNodeResponseType } from '../helpers/types.ts';
+export declare function getGQLDataWith(deps: DependencyType): (args: GQLArgsType) => Promise<DefaultGQLResponseType>;
+export declare function getAggregatedGQLDataWith(deps: DependencyType): (args: GQLArgsType, callback?: (message: string) => void) => Promise<GQLNodeResponseType[] | null>;
 export declare function getBatchGQLData(args: BatchGQLArgsType): Promise<BatchAGQLResponseType>;

package/dist/types/helpers/index.d.ts

@@ -1,4 +1,6 @@
 export * from './config.ts';
 export * from './endpoints.ts';
+export * from './platform.ts';
+export * from './platform-providers.ts';
 export * from './types.ts';
 export * from './utils.ts';

package/dist/types/helpers/platform-providers.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Platform-specific provider implementations
+ * Auto-detects platform and provides appropriate implementations
+ */
+import type { Base64Handler, BlobHandler, CryptoProvider, FileHandler, FileInput, PlatformContext, StorageProvider, WalletProvider } from './platform.ts';
+import { detectPlatform } from './platform.ts';
+declare class BrowserWalletProvider implements WalletProvider {
+    dispatch(tx: any): Promise<{
+        id: string;
+    }>;
+    sign(data: Uint8Array): Promise<Uint8Array>;
+    getActivePublicKey(): Promise<string>;
+    getAddress(): Promise<string>;
+    isConnected(): Promise<boolean>;
+}
+declare class BrowserFileHandler implements FileHandler {
+    readAsArrayBuffer(file: any): Promise<ArrayBuffer>;
+    getContentType(file: any): string;
+    getSize(file: any): number;
+    createFile(data: Uint8Array | ArrayBuffer | string, type?: string, name?: string): FileInput;
+    isFile(input: any): boolean;
+}
+declare class BrowserBlobHandler implements BlobHandler {
+    createBlob(data: Uint8Array | ArrayBuffer, type?: string): any;
+    readAsArrayBuffer(blob: Blob): Promise<ArrayBuffer>;
+    slice(blob: Blob, start: number, end: number): Blob;
+    getSize(blob: Blob): number;
+}
+declare class BrowserCryptoProvider implements CryptoProvider {
+    randomUUID(): string;
+    getRandomValues<T extends Uint8Array>(array: T): T;
+    randomBytes(size: number): Uint8Array;
+}
+declare class BrowserStorageProvider implements StorageProvider {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+declare class BrowserBase64Handler implements Base64Handler {
+    encode(data: Uint8Array | ArrayBuffer | string): string;
+    decode(base64: string): Uint8Array;
+    btoa(str: string): string;
+    atob(base64: string): string;
+}
+declare class ReactNativeWalletProvider implements WalletProvider {
+    dispatch(_tx: any): Promise<{
+        id: string;
+    }>;
+    sign(_data: Uint8Array): Promise<Uint8Array>;
+    getActivePublicKey(): Promise<string>;
+    getAddress(): Promise<string>;
+    isConnected(): Promise<boolean>;
+}
+declare class ReactNativeFileHandler implements FileHandler {
+    readAsArrayBuffer(file: any): Promise<ArrayBuffer>;
+    getContentType(file: any): string;
+    getSize(file: any): number;
+    createFile(data: Uint8Array | ArrayBuffer | string, type?: string, name?: string): FileInput;
+    isFile(input: any): boolean;
+    private base64ToUint8Array;
+    private atobPolyfill;
+}
+declare class ReactNativeBlobHandler implements BlobHandler {
+    createBlob(data: Uint8Array | ArrayBuffer, _type?: string): any;
+    readAsArrayBuffer(blob: any): Promise<ArrayBuffer>;
+    slice(blob: any, start: number, end: number): any;
+    getSize(blob: any): number;
+}
+declare class ReactNativeCryptoProvider implements CryptoProvider {
+    randomUUID(): string;
+    getRandomValues<T extends Uint8Array>(array: T): T;
+    randomBytes(size: number): Uint8Array;
+}
+declare class ReactNativeStorageProvider implements StorageProvider {
+    private cache;
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+    clear(): Promise<void>;
+}
+declare class ReactNativeBase64Handler implements Base64Handler {
+    encode(data: Uint8Array | ArrayBuffer | string): string;
+    decode(base64: string): Uint8Array;
+    btoa(str: string): string;
+    atob(base64: string): string;
+    private btoaPolyfill;
+    private atobPolyfill;
+}
+export declare function createPlatformContext(customProviders?: Partial<PlatformContext>): PlatformContext;
+export { BrowserBase64Handler, BrowserBlobHandler, BrowserCryptoProvider, BrowserFileHandler, BrowserStorageProvider, BrowserWalletProvider, detectPlatform, ReactNativeBase64Handler, ReactNativeBlobHandler, ReactNativeCryptoProvider, ReactNativeFileHandler, ReactNativeStorageProvider, ReactNativeWalletProvider, };

package/dist/types/helpers/platform.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Platform abstraction interfaces for cross-platform compatibility
+ * Supports Browser, Node.js, and React Native environments
+ */
+export interface WalletProvider {
+    /**
+     * Dispatch a transaction to the wallet for signing and submission
+     */
+    dispatch(tx: any): Promise<{
+        id: string;
+    }>;
+    /**
+     * Sign arbitrary data
+     */
+    sign(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Get the active public key
+     */
+    getActivePublicKey(): Promise<string>;
+    /**
+     * Get wallet address
+     */
+    getAddress(): Promise<string>;
+    /**
+     * Check if wallet is connected
+     */
+    isConnected(): Promise<boolean>;
+}
+export interface FileInput {
+    data: Uint8Array | ArrayBuffer | string;
+    type?: string;
+    size?: number;
+    name?: string;
+}
+export interface FileHandler {
+    /**
+     * Read file as ArrayBuffer
+     */
+    readAsArrayBuffer(file: any): Promise<ArrayBuffer>;
+    /**
+     * Get content type of file
+     */
+    getContentType(file: any): string;
+    /**
+     * Get size of file in bytes
+     */
+    getSize(file: any): number;
+    /**
+     * Create a file-like object from data
+     */
+    createFile(data: Uint8Array | ArrayBuffer | string, type?: string, name?: string): FileInput;
+    /**
+     * Check if input is a file
+     */
+    isFile(input: any): boolean;
+}
+export interface BlobHandler {
+    /**
+     * Create a blob from data
+     */
+    createBlob(data: Uint8Array | ArrayBuffer, type?: string): any;
+    /**
+     * Read blob as ArrayBuffer
+     */
+    readAsArrayBuffer(blob: any): Promise<ArrayBuffer>;
+    /**
+     * Slice a blob
+     */
+    slice(blob: any, start: number, end: number): any;
+    /**
+     * Get blob size
+     */
+    getSize(blob: any): number;
+}
+export interface CryptoProvider {
+    /**
+     * Generate a random UUID v4
+     */
+    randomUUID(): string;
+    /**
+     * Fill array with cryptographically secure random values
+     */
+    getRandomValues<T extends Uint8Array>(array: T): T;
+    /**
+     * Generate random bytes
+     */
+    randomBytes(size: number): Uint8Array;
+}
+export interface StorageProvider {
+    /**
+     * Get item from storage
+     */
+    getItem(key: string): Promise<string | null>;
+    /**
+     * Set item in storage
+     */
+    setItem(key: string, value: string): Promise<void>;
+    /**
+     * Remove item from storage
+     */
+    removeItem(key: string): Promise<void>;
+    /**
+     * Clear all storage
+     */
+    clear(): Promise<void>;
+}
+export interface SecureStorageProvider {
+    /**
+     * Securely store a value
+     */
+    setSecure(key: string, value: string): Promise<void>;
+    /**
+     * Retrieve securely stored value
+     */
+    getSecure(key: string): Promise<string | null>;
+    /**
+     * Delete securely stored value
+     */
+    deleteSecure(key: string): Promise<void>;
+}
+export interface Base64Handler {
+    /**
+     * Encode data to base64
+     */
+    encode(data: Uint8Array | ArrayBuffer | string): string;
+    /**
+     * Decode base64 to Uint8Array
+     */
+    decode(base64: string): Uint8Array;
+    /**
+     * Encode string to base64 (btoa equivalent)
+     */
+    btoa(str: string): string;
+    /**
+     * Decode base64 to string (atob equivalent)
+     */
+    atob(base64: string): string;
+}
+export interface PlatformContext {
+    wallet?: WalletProvider;
+    file: FileHandler;
+    blob: BlobHandler;
+    crypto: CryptoProvider;
+    storage?: StorageProvider;
+    secureStorage?: SecureStorageProvider;
+    base64: Base64Handler;
+}
+export type PlatformType = 'browser' | 'node' | 'react-native';
+export declare function detectPlatform(): PlatformType;
+export type PlatformDependencyType = {
+    ao: any;
+    signer?: any;
+    arweave?: any;
+    node?: {
+        url: string;
+        scheduler: string;
+        authority: string;
+    };
+    platform?: PlatformContext;
+};

package/dist/types/helpers/types.d.ts

@@ -1,5 +1,5 @@
 export type DependencyType = {
-    ao: any;
+    ao?: any;
     signer?: any;
     arweave?: any;
     node?: {
@@ -7,6 +7,7 @@ export type DependencyType = {
         scheduler: string;
         authority: string;
     };
+    gateway?: string;
 };
 export type ProcessReadType = {
     processId: string;

package/dist/types/helpers/utils.d.ts

@@ -13,7 +13,7 @@ export declare function splitTagValue(tag: any): any;
 export declare function getTagDisplay(value: string): string;
 export declare function getDataURLContentType(dataURL: string): string | null;
 export declare function getBase64Data(dataURL: string): string;
-export declare function getByteSize(input: string | Buffer): number;
+export declare function getByteSize(input: string | Uint8Array | ArrayBuffer | any): number;
 export declare function getTotalTokenBalance(tokenBalances: {
     profileBalance: number;
     walletBalance: number;

package/dist/types/index.d.ts

@@ -1,13 +1,15 @@
-import * as Common from './common/index.ts';
 import * as Helpers from './helpers/index.ts';
-import * as Services from './services/index.ts';
+import type { PlatformDependencyType } from './helpers/platform.ts';
+export type { Base64Handler, BlobHandler, CryptoProvider, FileHandler, FileInput, PlatformContext, PlatformType, SecureStorageProvider, StorageProvider, WalletProvider, } from './helpers/platform.ts';
+export { createPlatformContext, detectPlatform } from './helpers/platform-providers.ts';
 export * as Types from './helpers/types.ts';
 export declare const CurrentZoneVersion: string;
-declare function init(deps: Helpers.DependencyType): {
+declare function init(deps: Helpers.DependencyType | PlatformDependencyType): {
     createZone: (args: {
         data?: any;
         tags?: Helpers.TagType[];
         authUsers?: string[];
+        skipModeration?: boolean;
     }, callback?: (status: any) => void) => Promise<string | null>;
     updateZone: (args: object, zoneId: string) => Promise<string | null>;
     addToZone: (args: {
@@ -54,7 +56,7 @@ declare function init(deps: Helpers.DependencyType): {
     getAtomicAsset: (id: string, args?: {
         useGateway?: boolean;
     }) => Promise<Helpers.AssetDetailType | null>;
-    getAtomicAssets: typeof Services.getAtomicAssets;
+    getAtomicAssets: (ids: string[]) => Promise<Helpers.AssetHeaderType[] | null>;
     createComment: (args: Helpers.CommentCreateArgType) => Promise<string>;
     getComments: (args: {
         commentsId: string;
@@ -155,8 +157,8 @@ declare function init(deps: Helpers.DependencyType): {
         moderationId: string;
     }) => Promise<string[] | null>;
     resolveTransaction: (data: any) => Promise<any>;
-    getGQLData: typeof Common.getGQLData;
-    getAggregatedGQLData: typeof Common.getAggregatedGQLData;
+    getGQLData: (args: Helpers.GQLArgsType) => Promise<Helpers.DefaultGQLResponseType>;
+    getAggregatedGQLData: (args: Helpers.GQLArgsType, callback?: (message: string) => void) => Promise<Helpers.GQLNodeResponseType[] | null>;
     createProcess: (args: Helpers.ProcessCreateType, statusCB?: (status: any) => void) => Promise<string>;
     readProcess: (args: Helpers.MessageSendType) => Promise<any>;
     readState: (args: Helpers.ProcessReadType) => Promise<any>;

package/dist/types/services/assets.d.ts

@@ -6,5 +6,5 @@ export declare function getAtomicAsset(deps: DependencyType, id: string, args?:
 export declare function getAtomicAssetWith(deps: DependencyType): (id: string, args?: {
     useGateway?: boolean;
 }) => Promise<AssetDetailType | null>;
-export declare function getAtomicAssets(ids: string[]): Promise<AssetHeaderType[] | null>;
+export declare function getAtomicAssetsWith(deps: DependencyType): (ids: string[]) => Promise<AssetHeaderType[] | null>;
 export declare function buildAsset(element: GQLNodeResponseType): any;

package/dist/types/services/zones.d.ts

@@ -3,6 +3,7 @@ export declare function createZoneWith(deps: DependencyType): (args: {
     data?: any;
     tags?: TagType[];
     authUsers?: string[];
+    skipModeration?: boolean;
 }, callback?: (status: any) => void) => Promise<string | null>;
 export declare function updateZoneWith(deps: DependencyType): (args: object, zoneId: string) => Promise<string | null>;
 export declare function addToZoneWith(deps: DependencyType): (args: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@permaweb/libs",
-	"version": "0.0.85",
+	"version": "0.0.87",
 	"type": "module",
 	"main": "./dist/index.cjs",
 	"module": "./dist/index.js",
@@ -31,12 +31,15 @@
 	},
 	"exports": {
 		".": {
+			"react-native": "./dist/index.esm.js",
 			"import": "./dist/index.esm.js",
 			"require": "./dist/index.cjs"
 		},
 		"./browser": "./dist/index.esm.js",
-		"./node": "./dist/index.js"
+		"./node": "./dist/index.js",
+		"./native": "./dist/index.esm.js"
 	},
+	"react-native": "./dist/index.esm.js",
 	"scripts": {
 		"prepare": "husky install",
 		"clean:install": "rm -rf node_modules package-lock.json || true && npm cache clean --force && npm install",
@@ -44,7 +47,16 @@
 		"build": "node build.js"
 	},
 	"dependencies": {
-		"@dha-team/arbundles": "^1.0.3"
+		"@dha-team/arbundles": "^1.0.3",
+		"events": "^3.3.0"
+	},
+	"peerDependencies": {
+		"react-native-get-random-values": ">=1.8.0"
+	},
+	"peerDependenciesMeta": {
+		"react-native-get-random-values": {
+			"optional": true
+		}
 	},
 	"devDependencies": {
 		"@types/async-retry": "^1.4.9",