@adaas/a-frame 0.0.22 → 0.1.1

package/src/lib/A-FrameChannel/A-FrameChannelSocket.entity.ts

@@ -0,0 +1,189 @@
+import { A_Context, A_Entity, A_Error, A_Feature, A_Scope } from "@adaas/a-concept";
+import {
+    A_FrameChannelSocket_Init,
+    A_FrameChannelSocket_Serialized,
+    A_FrameChannelSocketStatusNames,
+} from "./A-FrameChannel.types";
+import { A_FrameChannelSocketFeatures, A_FrameChannelSocketStatuses } from "./A-FrameChannel.constants";
+import { A_FrameChannelEvent } from "./A-FrameChannelEvent.context";
+import { A_FrameChannelError } from "./A-FrameChannel.error";
+
+
+/**
+ * A_FrameChannelSocket — bidirectional WebSocket session entity.
+ *
+ * Lifecycle:
+ *   1. Instantiate with `new A_FrameChannelSocket({ method: 'GET', path: '/ws/...' })`.
+ *   2. Register event handlers via `@A_FrameChannelSocket.onEvent('type')` on a subclass.
+ *   3. Pass the instance to `A_FrameChannel.connect(socket)` which performs the
+ *      WebSocket handshake and sets the internal send capability.
+ *   4. While the connection is open, call `socket.send(event)` to push frames to
+ *      the server.  Incoming frames are dispatched via `propagate()`.
+ *   5. The socket transitions to Closed when the server sends a close frame or the
+ *      underlying transport ends.
+ */
+export class A_FrameChannelSocket<
+    T extends Record<string, any> = Record<string, any>
+> extends A_Entity<
+    A_FrameChannelSocket_Init<T>,
+    A_FrameChannelSocket_Serialized<T>
+> {
+
+    // ─── Static decorator ──────────────────────────────────────────────────────
+
+    /**
+     * Registers a method as a handler for a specific WebSocket event type sent
+     * by the server.  Mirrors `A_FrameChannelStream.onEvent()`.
+     *
+     * Usage (inside a subclass):
+     *   @A_FrameChannelSocket.onEvent('my_event')
+     *   async onMyEvent(@A_Inject(A_FrameChannelEvent) event: A_FrameChannelEvent) { ... }
+     *
+     * Omit the name (or use `'all'`) to receive every event type.
+     */
+    static onEvent(name?: string) {
+        const featureName = (name || 'all') + A_FrameChannelSocketFeatures.onEvent;
+
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: featureName,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        };
+    }
+
+    // ─── Protected state ──────────────────────────────────────────────────────
+
+    protected _method!: string;
+    protected _path!: string;
+    protected _body?: T;
+    protected _scope!: A_Scope;
+    protected _error?: A_Error;
+    protected _status!: A_FrameChannelSocketStatusNames;
+    protected _initDate!: string;
+
+    // ──────────────────────────────────────────────────────────────────────────
+    // SEND CAPABILITY
+    // Attached by the connect feature once the WebSocket handshake succeeds.
+    // Calling it serialises `data` to JSON and writes a masked WS text frame to
+    // the underlying raw socket.  Cleared to null on close / failure.
+    // ──────────────────────────────────────────────────────────────────────────
+    protected _sendFn: ((data: string) => void) | null = null;
+
+    // ─── Computed getters ─────────────────────────────────────────────────────
+
+    /** Scope allocated for the lifetime of this socket session. */
+    get scope(): A_Scope {
+        if (!this._scope) {
+            this._scope = A_Context.allocate(this, new A_Scope({ name: `${this.aseid.id}-scope` }));
+        }
+        return this._scope;
+    }
+
+    get method(): string { return this._method; }
+    get path(): string { return this._path; }
+    get body(): T | undefined { return this._body; }
+    get status(): A_FrameChannelSocketStatusNames { return this._status; }
+    get error(): A_Error | undefined { return this._error; }
+    get initDate(): Date { return new Date(this._initDate); }
+
+    // ─── Connect-feature interface ────────────────────────────────────────────
+
+    /**
+     * Called by the connect feature immediately after a successful handshake.
+     * Transitions status Connecting → Open and stores the send callback.
+     */
+    attachSendFn(fn: (data: string) => void): void {
+        this._sendFn = fn;
+        this._status = A_FrameChannelSocketStatuses.Open;
+    }
+
+    // ─── Public API ───────────────────────────────────────────────────────────
+
+    /**
+     * Send an event to the server over the open WebSocket connection.
+     *
+     * The event is serialised as `{ type, data }`, matching the shape the server
+     * uses for events it pushes to the client — keeping both directions symmetric.
+     *
+     * @throws {A_FrameChannelError} if the socket is not open.
+     */
+    send(event: A_FrameChannelEvent): void {
+        if (!this._sendFn || this._status !== A_FrameChannelSocketStatuses.Open) {
+            throw new A_FrameChannelError({
+                title: A_FrameChannelError.InvalidRequest,
+                description: `Cannot send event "${event.name}": WebSocket is not open (status: ${this._status})`,
+            });
+        }
+
+        this._sendFn(JSON.stringify({ type: event.name, data: event.data }));
+    }
+
+    // ─── Lifecycle ────────────────────────────────────────────────────────────
+
+    complete(): void {
+        this._sendFn = null;
+        this._status = A_FrameChannelSocketStatuses.Closed;
+    }
+
+    fail(error: A_Error): void {
+        this._sendFn = null;
+        this._status = A_FrameChannelSocketStatuses.Closed;
+        this._error = error;
+    }
+
+    destroy(): Promise<void> | void {
+        this.scope.destroy();
+    }
+
+    /**
+     * Dispatch an incoming server event to all registered `@onEvent` handlers.
+     * Mirrors `A_FrameChannelStream.propagate()`.
+     */
+    async propagate<D extends Record<string, any>>(name: string, data?: D): Promise<void> {
+        const eventFragment = new A_FrameChannelEvent<D>(name, data);
+
+        const executionScope = new A_Scope({
+            name: 'A_FrameChannelSocket.propagate',
+            fragments: [eventFragment],
+        }).inherit(A_Context.scope(this));
+
+        try {
+            const callName = (name || 'all') + A_FrameChannelSocketFeatures.onEvent;
+            await this.call(callName, executionScope);
+            executionScope.destroy();
+        } catch {
+            executionScope.destroy();
+        }
+    }
+
+    // ─── A_Entity serialisation ───────────────────────────────────────────────
+
+    fromNew(newEntity: A_FrameChannelSocket_Init<T>): void {
+        this._method = newEntity.method;
+        this._path = newEntity.path;
+        this._body = newEntity.body;
+        this._status = A_FrameChannelSocketStatuses.Connecting;
+        this._initDate = new Date().toISOString();
+    }
+
+    fromJSON(serialized: A_FrameChannelSocket_Serialized<T>): void {
+        this._method = serialized.method;
+        this._path = serialized.path;
+        this._body = serialized.body;
+        this._status = serialized.status;
+        this._initDate = serialized.initDate;
+    }
+
+    toJSON(): A_FrameChannelSocket_Serialized<T> {
+        return {
+            ...super.toJSON(),
+            initDate: this._initDate,
+            status: this._status,
+            error: this._error ? this._error.toJSON() : undefined,
+            method: this._method,
+            path: this._path,
+            body: this._body,
+        };
+    }
+}

package/src/lib/A-FrameChannel/A-FrameChannelStream.entity.ts

@@ -0,0 +1,144 @@
+import { A_Context, A_Entity, A_Error, A_Feature, A_Scope } from "@adaas/a-concept";
+import { A_FrameChannelStream_Init, A_FrameChannelStream_Serialized, A_FrameChannelStreamStatusNames } from "./A-FrameChannel.types";
+import { A_FrameChannelStreamFeatures, A_FrameChannelStreamStatuses } from "./A-FrameChannel.constants";
+import { A_FrameChannelEvent } from "./A-FrameChannelEvent.context";
+
+
+
+export class A_FrameChannelStream<
+    T extends Record<string, any> = Record<string, any>
+> extends A_Entity<
+    A_FrameChannelStream_Init<T>,
+    A_FrameChannelStream_Serialized<T>
+> {
+
+
+    static onEvent(name?: string) {
+
+        const eventName = (name || 'all') + A_FrameChannelStreamFeatures.onEvent;
+
+
+        return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+            return A_Feature.Extend({
+                name: eventName,
+                scope: [target.constructor],
+            })(target, propertyKey, descriptor);
+        }
+    }
+
+
+    protected _method!: string;
+    protected _path!: string;
+    protected _body?: T;
+    protected _scope!: A_Scope
+    protected _error?: A_Error;
+    protected _status!: A_FrameChannelStreamStatusNames;
+    protected _initDate!: string;
+
+    /**
+     * The scope of the session, Will be destroyed after the session is closed.
+     */
+    get scope(): A_Scope {
+
+        if (!this._scope) {
+            this._scope = A_Context.allocate(this, new A_Scope({ name: `${this.aseid.id}-scope` }));
+        }
+
+        return this._scope;
+    }
+
+    get method(): string {
+        return this._method;
+    }
+
+    get path(): string {
+        return this._path;
+    }
+
+    get body(): T | undefined {
+        return this._body;
+    }
+
+    get status(): A_FrameChannelStreamStatusNames {
+        return this._status;
+    }
+
+    get error(): A_Error | undefined {
+        return this._error;
+    }
+
+    get initDate(): Date {
+        return new Date(this._initDate);
+    }
+
+    complete(): void {
+        this._status = A_FrameChannelStreamStatuses.Closed;
+    }
+
+    fail(error: A_Error): void {
+        this._status = A_FrameChannelStreamStatuses.Closed;
+        this._error = error;
+    }
+
+    destroy(): Promise<void> | void {
+        this.scope.destroy();
+    }
+
+    async open(){
+        await this.call(A_FrameChannelStreamFeatures.open);
+    }
+
+    async send(){
+        await this.call(A_FrameChannelStreamFeatures.send);
+    }
+
+
+    async propagate<T extends Record<string, any>>(name: string, data?: T): Promise<void> {
+        const request = new A_FrameChannelEvent<T>(name, data);
+
+        const executionScope = new A_Scope({
+            name: 'A_FrameChannelStream.propagate',
+            fragments: [request],
+        })
+            .inherit(this.scope);
+
+        try {
+
+            const callName = (name || 'all') + A_FrameChannelStreamFeatures.onEvent;
+
+            await this.call(callName, executionScope);
+            executionScope.destroy();
+
+        } catch {
+            executionScope.destroy();
+        }
+    }
+
+    fromNew(newEntity: A_FrameChannelStream_Init<T>): void {
+        this._method = newEntity.method;
+        this._path = newEntity.path;
+        this._body = newEntity.body;
+        this._initDate = new Date().toISOString();
+    }
+
+    fromJSON(serialized: A_FrameChannelStream_Serialized<T>): void {
+        this._method = serialized.method;
+        this._path = serialized.path;
+        this._body = serialized.body;
+        this._initDate = serialized.initDate;
+    }
+
+
+    toJSON(): A_FrameChannelStream_Serialized<T> {
+        return {
+            ...super.toJSON(),
+            initDate: this._initDate,
+            status: this._status,
+            error: this._error ? this._error.toJSON() : undefined,
+            method: this._method,
+            path: this._path,
+            body: this._body,
+        }
+    }
+
+}

package/src/lib/A-FrameChannel/index.browser.ts

@@ -0,0 +1,3 @@
+export * from './A-FrameChannel.component.env-browser';
+export { A_FrameChannelSocket } from './A-FrameChannelSocket.entity';
+export * from './A-FrameChannel.types';

package/src/lib/A-FrameChannel/index.ts

@@ -0,0 +1,10 @@
+export * from './A-FrameChannel.component';
+export * from './A-FrameChannel.types';
+export * from './A-FrameChannel.error';
+export * from './A-FrameChannel.constants';
+
+export * from './A-FrameChannelStream.entity';
+export * from './A-FrameChannelEvent.context';
+export * from './A-FrameChannelRequest.context';
+
+export * from './A-FrameChannel.component.env-node';

package/src/lib/A-FrameCrypto/A-FrameCrypto.component.env-browser.ts

@@ -0,0 +1,123 @@
+import { A_Component } from "@adaas/a-concept";
+
+/**
+ * A_FrameCrypto — Browser environment
+ *
+ * AES-256-GCM encryption + SHA-256 hashing via globalThis.crypto.subtle.
+ * No Node.js-specific require() calls — safe to include in browser bundles.
+ *
+ * Binary payload format on disk:
+ *   IV (12B) + AuthTag (16B) + Ciphertext (NB)
+ */
+export class A_FrameCrypto extends A_Component {
+
+    // ─── Internal helpers ─────────────────────────────────────────────────────
+
+    private static getSubtle(): SubtleCrypto {
+        return globalThis.crypto.subtle;
+    }
+
+    /**
+     * Ensure a Uint8Array is backed by a plain ArrayBuffer.
+     * SubtleCrypto rejects ArrayBufferLike (e.g. SharedArrayBuffer) on strict TS targets.
+     */
+    private static bytes(u: Uint8Array): Uint8Array {
+        if (u.buffer instanceof ArrayBuffer) return u;
+        return new Uint8Array(u);
+    }
+
+    private static async importKey(keyBase64: string): Promise<CryptoKey> {
+        const raw = A_FrameCrypto.base64ToBytes(keyBase64);
+        return A_FrameCrypto.getSubtle().importKey(
+            'raw', raw.buffer as ArrayBuffer, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']
+        );
+    }
+
+
+    // ─── Encrypt ─────────────────────────────────────────────────────────────
+
+    /** Encrypt a Uint8Array → IV(12) + AuthTag(16) + Ciphertext */
+    static async encryptBytes(plain: Uint8Array, keyBase64: string): Promise<Uint8Array> {
+        const key = await A_FrameCrypto.importKey(keyBase64);
+        const iv = new Uint8Array(12);
+        globalThis.crypto.getRandomValues(iv);
+
+        const cipherWithTag = new Uint8Array(
+            await A_FrameCrypto.getSubtle().encrypt({ name: 'AES-GCM', iv, tagLength: 128 }, key, A_FrameCrypto.bytes(plain))
+        );
+        const ciphertext = cipherWithTag.slice(0, cipherWithTag.length - 16);
+        const authTag = cipherWithTag.slice(cipherWithTag.length - 16);
+
+        const out = new Uint8Array(12 + 16 + ciphertext.length);
+        out.set(iv, 0);
+        out.set(authTag, 12);
+        out.set(ciphertext, 28);
+        return out;
+    }
+
+    /** Encrypt a UTF-8 string → base64 payload string */
+    static async encrypt(plain: string, keyBase64: string): Promise<string> {
+        const bytes = new TextEncoder().encode(plain);
+        const encrypted = await A_FrameCrypto.encryptBytes(bytes, keyBase64);
+        return A_FrameCrypto.bytesToBase64(encrypted);
+    }
+
+
+    // ─── Decrypt ─────────────────────────────────────────────────────────────
+
+    /** Decrypt a Uint8Array payload produced by encryptBytes() */
+    static async decryptBytes(payload: Uint8Array, keyBase64: string): Promise<Uint8Array> {
+        if (payload.length < 28) throw new Error('Payload too short to decrypt');
+
+        const key = await A_FrameCrypto.importKey(keyBase64);
+        const iv = payload.slice(0, 12);
+        const authTag = payload.slice(12, 28);
+        const ciphertext = payload.slice(28);
+
+        const cipherWithTag = new Uint8Array(ciphertext.length + 16);
+        cipherWithTag.set(ciphertext, 0);
+        cipherWithTag.set(authTag, ciphertext.length);
+
+        const plain = await A_FrameCrypto.getSubtle().decrypt(
+            { name: 'AES-GCM', iv: A_FrameCrypto.bytes(iv), tagLength: 128 }, key, cipherWithTag
+        );
+        return new Uint8Array(plain);
+    }
+
+    /** Decrypt a base64 payload string → UTF-8 string */
+    static async decrypt(payloadBase64: string, keyBase64: string): Promise<string> {
+        const payload = A_FrameCrypto.base64ToBytes(payloadBase64);
+        const plain = await A_FrameCrypto.decryptBytes(payload, keyBase64);
+        return new TextDecoder().decode(plain);
+    }
+
+
+    // ─── Hashing ─────────────────────────────────────────────────────────────
+
+    /** SHA-256 of a string → hex string */
+    static async sha256hex(input: string): Promise<string> {
+        const data = new TextEncoder().encode(input);
+        const hashBuffer = await A_FrameCrypto.getSubtle().digest('SHA-256', data);
+        return A_FrameCrypto.bytesToHex(new Uint8Array(hashBuffer));
+    }
+
+
+    // ─── Encode helpers ───────────────────────────────────────────────────────
+
+    static bytesToBase64(bytes: Uint8Array): string {
+        let bin = '';
+        for (const b of bytes) bin += String.fromCharCode(b);
+        return btoa(bin);
+    }
+
+    static base64ToBytes(b64: string): Uint8Array {
+        const bin = atob(b64);
+        const bytes = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+        return bytes;
+    }
+
+    static bytesToHex(bytes: Uint8Array): string {
+        return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+}

package/src/lib/A-FrameCrypto/A-FrameCrypto.component.env-node.ts

@@ -0,0 +1,204 @@
+import { A_Component } from "@adaas/a-concept";
+
+/**
+ * A_FrameCrypto — Node.js environment
+ *
+ * AES-256-GCM encryption + SHA-256 hashing via the Web Crypto API.
+ * Falls back to node:crypto for Node < 19 that lack globalThis.crypto.
+ *
+ * Binary payload format on disk:
+ *   IV (12B) + AuthTag (16B) + Ciphertext (NB)
+ */
+export class A_FrameCrypto extends A_Component {
+
+    // ─── Internal helpers ─────────────────────────────────────────────────────
+
+    private static getSubtle(): SubtleCrypto {
+        if (typeof globalThis.crypto?.subtle !== 'undefined') {
+            return globalThis.crypto.subtle;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-var-requires
+        const nodeCrypto = require('node:crypto') as typeof import('node:crypto');
+        return nodeCrypto.webcrypto.subtle as unknown as SubtleCrypto;
+    }
+
+    private static getRandomBytes(n: number): Uint8Array {
+        const buf = new Uint8Array(n);
+        if (typeof globalThis.crypto?.getRandomValues !== 'undefined') {
+            globalThis.crypto.getRandomValues(buf);
+        } else {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const nodeCrypto = require('node:crypto') as typeof import('node:crypto');
+            buf.set(nodeCrypto.randomBytes(n));
+        }
+        return buf;
+    }
+
+    /**
+     * Ensure a Uint8Array is backed by a plain ArrayBuffer and return it.
+     * SubtleCrypto rejects ArrayBufferLike (e.g. SharedArrayBuffer) on strict TS targets.
+     */
+    private static bytes(u: Uint8Array): ArrayBuffer {
+        if (u.buffer instanceof ArrayBuffer && u.byteOffset === 0 && u.byteLength === u.buffer.byteLength) {
+            return u.buffer as ArrayBuffer;
+        }
+        return new Uint8Array(u).buffer as ArrayBuffer;
+    }
+
+    private static async importKey(keyBase64: string): Promise<CryptoKey> {
+        const raw = A_FrameCrypto.base64ToBytes(keyBase64);
+        return A_FrameCrypto.getSubtle().importKey(
+            'raw', raw.buffer as ArrayBuffer, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']
+        );
+    }
+
+
+    // ─── Encrypt ──────────────────────────────────────────────────────────────
+
+    /** Encrypt a Uint8Array → IV(12) + AuthTag(16) + Ciphertext */
+    static async encryptBytes(plain: Uint8Array, keyBase64: string): Promise<Uint8Array> {
+        const key = await A_FrameCrypto.importKey(keyBase64);
+        const iv = A_FrameCrypto.getRandomBytes(12);
+
+        const cipherWithTag = new Uint8Array(
+            await A_FrameCrypto.getSubtle().encrypt({ name: 'AES-GCM', iv: A_FrameCrypto.bytes(iv), tagLength: 128 }, key, A_FrameCrypto.bytes(plain))
+        );
+        const ciphertext = cipherWithTag.slice(0, cipherWithTag.length - 16);
+        const authTag = cipherWithTag.slice(cipherWithTag.length - 16);
+
+        const out = new Uint8Array(12 + 16 + ciphertext.length);
+        out.set(iv, 0);
+        out.set(authTag, 12);
+        out.set(ciphertext, 28);
+        return out;
+    }
+
+
+    /** Encrypt a UTF-8 string → base64 payload string */
+    static async encrypt(plain: string, keyBase64: string): Promise<string> {
+        const bytes = new TextEncoder().encode(plain);
+        const encrypted = await A_FrameCrypto.encryptBytes(bytes, keyBase64);
+        return A_FrameCrypto.bytesToBase64(encrypted);
+    }
+
+
+    // ─── Decrypt ─────────────────────────────────────────────────────────────
+
+    /** Decrypt a Uint8Array payload produced by encryptBytes() */
+    static async decryptBytes(payload: Uint8Array, keyBase64: string): Promise<Uint8Array> {
+        if (payload.length < 28) throw new Error('Payload too short to decrypt');
+
+        const key = await A_FrameCrypto.importKey(keyBase64);
+        const iv = payload.slice(0, 12);
+        const authTag = payload.slice(12, 28);
+        const ciphertext = payload.slice(28);
+
+        const cipherWithTag = new Uint8Array(ciphertext.length + 16);
+        cipherWithTag.set(ciphertext, 0);
+        cipherWithTag.set(authTag, ciphertext.length);
+
+        const plain = await A_FrameCrypto.getSubtle().decrypt(
+            { name: 'AES-GCM', iv: A_FrameCrypto.bytes(iv), tagLength: 128 }, key, A_FrameCrypto.bytes(cipherWithTag)
+        );
+        return new Uint8Array(plain);
+    }
+
+
+    /** Decrypt a base64 payload string → UTF-8 string */
+    static async decrypt(payloadBase64: string, keyBase64: string): Promise<string> {
+        const payload = A_FrameCrypto.base64ToBytes(payloadBase64);
+        const plain = await A_FrameCrypto.decryptBytes(payload, keyBase64);
+        return new TextDecoder().decode(plain);
+    }
+
+
+
+
+    // ─── Hashing ──────────────────────────────────────────────────────────────
+
+    /** SHA-256 of a string → hex string */
+    static async sha256hex(input: string): Promise<string> {
+        const data = new TextEncoder().encode(input);
+        try {
+            const hashBuffer = await A_FrameCrypto.getSubtle().digest('SHA-256', A_FrameCrypto.bytes(data));
+            return A_FrameCrypto.bytesToHex(new Uint8Array(hashBuffer));
+        } catch {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const nodeCrypto = require('node:crypto') as typeof import('node:crypto');
+            return nodeCrypto.createHash('sha256').update(input).digest('hex');
+        }
+    }
+
+
+
+
+    // ─── Encode helpers ───────────────────────────────────────────────────────
+
+    static bytesToBase64(bytes: Uint8Array): string {
+        if (typeof Buffer !== 'undefined') {
+            return Buffer.from(bytes).toString('base64');
+        }
+        let bin = '';
+        for (const b of bytes) bin += String.fromCharCode(b);
+        return btoa(bin);
+    }
+
+
+
+
+    static base64ToBytes(b64: string): Uint8Array {
+        if (typeof Buffer !== 'undefined') {
+            return new Uint8Array(Buffer.from(b64, 'base64'));
+        }
+        const bin = atob(b64);
+        const bytes = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+        return bytes;
+    }
+
+
+
+
+    static bytesToHex(bytes: Uint8Array): string {
+        return Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
+    }
+
+    // =================================================================================
+    // Instance methods just call the static versions for convenient injection into other components
+    // =================================================================================
+
+
+    encryptBytes(plain: Uint8Array, keyBase64: string): Promise<Uint8Array> {
+        return A_FrameCrypto.encryptBytes(plain, keyBase64);
+    }
+
+
+    encrypt(plain: string, keyBase64: string): Promise<string> {
+        return A_FrameCrypto.encrypt(plain, keyBase64);
+    }
+
+    decryptBytes(payload: Uint8Array, keyBase64: string): Promise<Uint8Array> {
+        return A_FrameCrypto.decryptBytes(payload, keyBase64);
+    }
+
+
+    decrypt(payloadBase64: string, keyBase64: string): Promise<string> {
+        return A_FrameCrypto.decrypt(payloadBase64, keyBase64);
+    }
+
+    sha256hex(input: string): Promise<string> {
+        return A_FrameCrypto.sha256hex(input);
+    }
+
+    bytesToBase64(bytes: Uint8Array): string {
+        return A_FrameCrypto.bytesToBase64(bytes);
+    }
+
+    base64ToBytes(b64: string): Uint8Array {
+        return A_FrameCrypto.base64ToBytes(b64);
+    }
+
+    bytesToHex(bytes: Uint8Array): string {
+        return A_FrameCrypto.bytesToHex(bytes);
+    }
+}

package/src/lib/A-FrameCrypto/index.browser.ts

@@ -0,0 +1 @@
+export * from './A-FrameCrypto.component.env-browser';

package/src/lib/A-FrameCrypto/index.ts

@@ -0,0 +1 @@
+export * from './A-FrameCrypto.component.env-node';