@daiso-tech/core/dist/serde/implementations/derivables/serde-transformers.js

The library offers flexible, framework-agnostic solutions for modern web applications, built on adaptable components that integrate seamlessly with popular frameworks like Next Js.

import { getConstructorName, } from "../../../utilities/_module-exports.js";
/**
 * @internal
 */
export class ArrayBufferSerdeTransformer {
    get name() {
        return ArrayBuffer.name;
    }
    isApplicable(value) {
        return (value instanceof ArrayBuffer &&
            getConstructorName(value) === ArrayBuffer.name);
    }
    deserialize(serializedValue) {
        return Buffer.from(serializedValue.buffer, "base64").buffer;
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class BufferSerdeTransformer {
    get name() {
        return Buffer.name;
    }
    isApplicable(value) {
        return (value instanceof Buffer && getConstructorName(value) === Buffer.name);
    }
    deserialize(serializedValue) {
        return Buffer.from(serializedValue.buffer, "base64");
    }
    serialize(deserializedValue) {
        return {
            buffer: deserializedValue.toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Uint8ArraySerdeTransformer {
    get name() {
        return Uint8Array.name;
    }
    isApplicable(value) {
        return (value instanceof Uint8Array &&
            getConstructorName(value) === Uint8Array.name);
    }
    deserialize(serializedValue) {
        return new Uint8Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Int8ArraySerdeTransformer {
    get name() {
        return Int8Array.name;
    }
    isApplicable(value) {
        return (value instanceof Int8Array &&
            getConstructorName(value) === Int8Array.name);
    }
    deserialize(serializedValue) {
        return new Int8Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Uint16ArraySerdeTransformer {
    get name() {
        return Uint16Array.name;
    }
    isApplicable(value) {
        return (value instanceof Uint16Array &&
            getConstructorName(value) === Uint16Array.name);
    }
    deserialize(serializedValue) {
        return new Uint16Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Int16ArraySerdeTransformer {
    get name() {
        return Int16Array.name;
    }
    isApplicable(value) {
        return (value instanceof Int16Array &&
            getConstructorName(value) === Int16Array.name);
    }
    deserialize(serializedValue) {
        return new Int16Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Uint32ArraySerdeTransformer {
    get name() {
        return Uint32Array.name;
    }
    isApplicable(value) {
        return (value instanceof Uint32Array &&
            getConstructorName(value) === Uint32Array.name);
    }
    deserialize(serializedValue) {
        return new Uint32Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Int32ArraySerdeTransformer {
    get name() {
        return Int32Array.name;
    }
    isApplicable(value) {
        return (value instanceof Int32Array &&
            getConstructorName(value) === Int32Array.name);
    }
    deserialize(serializedValue) {
        return new Int32Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class BigUint64ArraySerdeTransformer {
    get name() {
        return BigUint64Array.name;
    }
    isApplicable(value) {
        return (value instanceof BigUint64Array &&
            getConstructorName(value) === BigUint64Array.name);
    }
    deserialize(serializedValue) {
        return new BigUint64Array(Buffer.from(serializedValue.buffer, "base64").buffer);
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue.buffer).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class BigInt64ArraySerdeTransformer {
    get name() {
        return BigInt64Array.name;
    }
    isApplicable(value) {
        return (value instanceof BigInt64Array &&
            getConstructorName(value) === BigInt64Array.name);
    }
    deserialize(serializedValue) {
        return new BigInt64Array(Buffer.from(serializedValue.buffer, "base64").buffer);
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue.buffer).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Float32ArraySerdeTransformer {
    get name() {
        return Float32Array.name;
    }
    isApplicable(value) {
        return (value instanceof Float32Array &&
            getConstructorName(value) === Float32Array.name);
    }
    deserialize(serializedValue) {
        return new Float32Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class Float64ArraySerdeTransformer {
    get name() {
        return Float64Array.name;
    }
    isApplicable(value) {
        return (value instanceof Float64Array &&
            getConstructorName(value) === Float64Array.name);
    }
    deserialize(serializedValue) {
        return new Float64Array(Buffer.from(serializedValue.buffer, "base64"));
    }
    serialize(deserializedValue) {
        return {
            buffer: Buffer.from(deserializedValue).toString("base64"),
        };
    }
}
/**
 * @internal
 */
export class MapSerdeTransformer {
    get name() {
        return Map.name;
    }
    isApplicable(value) {
        return value instanceof Map && getConstructorName(value) === Map.name;
    }
    deserialize(serializedValue) {
        return new Map(serializedValue);
    }
    serialize(deserializedValue) {
        return [...deserializedValue.entries()];
    }
}
/**
 * @internal
 */
export class SetSerdeTransformer {
    get name() {
        return Set.name;
    }
    isApplicable(value) {
        return value instanceof Set && getConstructorName(value) === Set.name;
    }
    deserialize(serializedValue) {
        return new Set(serializedValue);
    }
    serialize(deserializedValue) {
        return [...deserializedValue.values()];
    }
}
/**
 * @internal
 */
export class BigIntSerdeTransformer {
    get name() {
        return BigInt.name;
    }
    isApplicable(value) {
        return typeof value === "bigint";
    }
    deserialize(serializedValue) {
        return BigInt(serializedValue);
    }
    serialize(deserializedValue) {
        return deserializedValue.toString();
    }
}
/**
 * @internal
 */
export class NaNSerdeTransformer {
    get name() {
        return NaN.toString();
    }
    isApplicable(value) {
        return typeof value === "number" && Number.isNaN(value);
    }
    deserialize(serializedValue) {
        return Number(serializedValue);
    }
    serialize(deserializedValue) {
        return deserializedValue.toString();
    }
}
/**
 * @internal
 */
export class InfinitySerdeTransformer {
    get name() {
        return Infinity.toString();
    }
    isApplicable(value) {
        return typeof value === "number" && !Number.isFinite(value);
    }
    deserialize(serializedValue) {
        return Number(serializedValue);
    }
    serialize(deserializedValue) {
        return deserializedValue.toString();
    }
}
/**
 * @internal
 */
export class UndefinedSerdeTransformer {
    get name() {
        return "undefined";
    }
    isApplicable(value) {
        return value === undefined;
    }
    deserialize(_serializedValue) {
        return undefined;
    }
    serialize(deserializedValue) {
        return String(deserializedValue);
    }
}
/**
 * @internal
 */
export class RegExpSerdeTransformer {
    get name() {
        return RegExp.name;
    }
    isApplicable(value) {
        return (value instanceof RegExp && getConstructorName(value) === RegExp.name);
    }
    deserialize(serializedValue) {
        const body = serializedValue.slice(1, serializedValue.lastIndexOf("/"));
        const flags = serializedValue.slice(serializedValue.lastIndexOf("/") + 1);
        return new RegExp(body, flags);
    }
    serialize(deserializedValue) {
        return deserializedValue.toString();
    }
}
/**
 * @internal
 */
export class DateSerdeTransformer {
    get name() {
        return Date.name;
    }
    isApplicable(value) {
        return value instanceof Date && getConstructorName(value) === Date.name;
    }
    deserialize(serializedValue) {
        return new Date(serializedValue);
    }
    serialize(deserializedValue) {
        return deserializedValue.getTime();
    }
}
/**
 * @internal
 */
export class URLSerdeTransformer {
    get name() {
        return URL.name;
    }
    isApplicable(value) {
        return value instanceof URL && getConstructorName(value) === URL.name;
    }
    deserialize(serializedValue) {
        return new URL(serializedValue);
    }
    serialize(deserializedValue) {
        return deserializedValue.toString();
    }
}
/**
 * @internal
 */
export class URLSearchParamsSerdeTransformer {
    get name() {
        return URLSearchParams.name;
    }
    isApplicable(value) {
        return (value instanceof URLSearchParams &&
            getConstructorName(value) === URLSearchParams.name);
    }
    deserialize(serializedValue) {
        return new URLSearchParams(serializedValue);
    }
    serialize(deserializedValue) {
        return [...deserializedValue.entries()];
    }
}
//# sourceMappingURL=serde-transformers.js.map