@xcrap/transformer 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Marcuth
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,133 @@
+# 🕷️ Xcrap Transformer
+
+**Xcrap Transformer** is the data transformation package for data extracted from the **Xcrap** Web Scraping framework.
+
+## 📦 Installation
+
+Installation is straightforward. Use your preferred dependency manager. Here's an example of how you'd install it using NPM:
+
+```bash
+npm i @xcrap/transformer
+```
+
+## 🚀 Usage
+
+Usage is similar to `@xcrap/parser`; we use declarative models to transform data. See an example below:
+
+```ts
+import {
+    StringTransformer,
+    StringValidator,
+    AnyValidator,
+    Transformer,
+    TransformingModel,
+    transform
+} from "./src"
+
+const rawData = [
+    {
+        id: "1",
+        name_: "Marcuth ",
+        avatar_url: "/assets/users/1/avatar.png"
+    },
+    {
+        id: "2,0",
+        name_: "JavaScript  User ",
+        avatar_url: "/assets/users/2/avatar.png"
+    },
+    {
+        id: 3,
+        name_: "Pedro",
+        avatar_url: "/assets/users/3/avatar.png"
+    },
+]
+
+const transformingModel = new TransformingModel({
+    id: [ // return key
+        transform({
+            key: "id",  // at index 0 always raw data key
+            condition: (value) => AnyValidator.isString(value) && value.includes(","),
+            transformer: StringTransformer.replace(",", ".")
+        }),
+        transform({
+            key: "id", // transformed data key
+            condition: StringValidator.isNumeric,
+            transformer: StringTransformer.toNumber
+        })
+    ],
+    name: [ // return key
+        transform({
+            key: "name_", // at index 0 always raw data key
+            transformer: StringTransformer.collapseWhitespace
+        })
+    ],
+    avatarUrl: [ // return key
+        transform({
+            key: "avatar_url", // at index 0 always raw data key
+            transformer: StringTransformer.resolveUrl("https://baseurl.com/")
+        })
+    ]
+}).after({
+    append: {
+        role: "USER"
+    },
+    delete: [
+        "name_",
+        "avatar_url"
+    ]
+})
+
+const transformer = new Transformer(rawData)
+
+;(async () => {
+    const transformedData = await transformer.transform(transformingModel)
+    console.log(transformedData)
+})();
+
+```
+
+**Expected output**:
+
+```js
+[
+  {
+    id: 1,
+    name: 'Marcuth',
+    avatarUrl: 'https://baseurl.com/assets/users/1/avatar.png',
+    role: 'USER'
+  },
+  {
+    id: 2,
+    name: 'JavaScript User',
+    avatarUrl: 'https://baseurl.com/assets/users/2/avatar.png',
+    role: 'USER'
+  },
+  {
+    id: 3,
+    name: 'Pedro',
+    avatarUrl: 'https://baseurl.com/assets/users/3/avatar.png',
+    role: 'USER'
+  }
+]
+```
+
+## 🧪 Tests
+
+Automated tests are located in `__tests__`. To run them:
+
+```bash
+npm run test
+```
+
+## 🤝 Contributing
+
+  - Want to contribute? Follow these steps:
+  - Fork the repository.
+  - Create a new branch (git checkout -b feature-new).
+  - Commit your changes (git commit -m 'Add new feature').
+  - Push to the branch (git push origin feature-new).
+  - Open a Pull Request.
+
+## 📝 License
+
+This project is licensed under the MIT License.

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export * from "./transforming-model";
+export * from "./transformer";
+export * from "./transformers";
+export * from "./validators";
+export type SkipFunction = () => void;
+export type TransformOptions<T, R> = {
+    key: string;
+    transformer: (value: T) => R | Promise<R>;
+    condition?: (value: T) => boolean | Promise<boolean>;
+};
+export declare function transform<T extends any, R extends any>({ key, transformer, condition }: TransformOptions<T, R>): (data: Record<string, any>, skip: SkipFunction) => Promise<void | R>;
+export type GetOptions<T> = {
+    key: string;
+    condition?: (value: T) => boolean | Promise<boolean>;
+};
+export declare function get<T extends any>({ key, condition }: GetOptions<T>): (data: Record<string, any>, skip: SkipFunction) => Promise<void | T>;

package/dist/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transform = transform;
+exports.get = get;
+__exportStar(require("./transforming-model"), exports);
+__exportStar(require("./transformer"), exports);
+__exportStar(require("./transformers"), exports);
+__exportStar(require("./validators"), exports);
+function transform({ key, transformer, condition }) {
+    return async (data, skip) => {
+        const value = data[key];
+        const isValid = condition ? await condition(value) : true;
+        if (!isValid) {
+            return skip();
+        }
+        const transformedValue = await transformer(value);
+        return transformedValue;
+    };
+}
+function get({ key, condition }) {
+    return async (data, skip) => {
+        const value = data[key];
+        const isValid = condition ? await condition(value) : true;
+        if (!isValid) {
+            return skip();
+        }
+        return value;
+    };
+}

package/dist/transformer.d.ts

@@ -0,0 +1,6 @@
+import { TransformingModel } from "./transforming-model";
+export declare class Transformer {
+    readonly data: Record<string, any> | Record<string, any>[];
+    constructor(data: Record<string, any> | Record<string, any>[]);
+    transform(transformingModel: TransformingModel): Promise<Record<string, any> | Record<string, any>[]>;
+}

package/dist/transformer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Transformer = void 0;
+class Transformer {
+    constructor(data) {
+        this.data = data;
+    }
+    async transform(transformingModel) {
+        if (Array.isArray(this.data)) {
+            return await Promise.all(this.data.map((item) => transformingModel.transform(item)));
+        }
+        return await transformingModel.transform(this.data);
+    }
+}
+exports.Transformer = Transformer;

package/dist/transformers/array.d.ts

@@ -0,0 +1,14 @@
+export declare namespace ArrayTransformer {
+    const join: (separator: string) => (value: string[]) => string;
+    const filter: <T>(predicate: (item: T) => boolean) => (value: T[]) => T[];
+    const map: <T, R>(mapper: (item: T) => R) => (value: T[]) => R[];
+    const unique: <T>(value: T[]) => T[];
+    const sort: <T>(compareFunction?: (a: T, b: T) => number) => (value: T[]) => T[];
+    const reduce: <T, R>(reducer: (acc: R, item: T) => R, initialValue: R) => (value: T[]) => R;
+    const compact: <T>(value: T[]) => T[];
+    const first: <T>(defaultValue?: T) => (value: T[]) => T | undefined;
+    const last: <T>(defaultValue?: T) => (value: T[]) => T | undefined;
+    const chunk: (size: number) => <T>(value: T[]) => T[][];
+    const toNumbers: (value: string[]) => number[];
+    const sum: (value: number[]) => number;
+}

package/dist/transformers/array.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayTransformer = void 0;
+var ArrayTransformer;
+(function (ArrayTransformer) {
+    ArrayTransformer.join = (separator) => (value) => value.join(separator);
+    ArrayTransformer.filter = (predicate) => {
+        return (value) => {
+            return value.filter(predicate);
+        };
+    };
+    ArrayTransformer.map = (mapper) => (value) => {
+        return value.map(mapper);
+    };
+    ArrayTransformer.unique = (value) => {
+        return [...new Set(value)];
+    };
+    ArrayTransformer.sort = (compareFunction) => {
+        return (value) => {
+            return [...value].sort(compareFunction);
+        };
+    };
+    ArrayTransformer.reduce = (reducer, initialValue) => (value) => {
+        return value.reduce(reducer, initialValue);
+    };
+    ArrayTransformer.compact = (value) => {
+        return value.filter(Boolean);
+    };
+    ArrayTransformer.first = (defaultValue) => (value) => {
+        return value.length > 0 ? value[0] : defaultValue;
+    };
+    ArrayTransformer.last = (defaultValue) => (value) => {
+        return value.length > 0 ? value[value.length - 1] : defaultValue;
+    };
+    ArrayTransformer.chunk = (size) => (value) => {
+        if (size <= 0)
+            return [value];
+        const result = [];
+        for (let i = 0; i < value.length; i += size) {
+            result.push(value.slice(i, i + size));
+        }
+        return result;
+    };
+    ArrayTransformer.toNumbers = (value) => {
+        return value.map(item => Number(item.replace(/[^\d.-]/g, "")) || 0);
+    };
+    ArrayTransformer.sum = (value) => {
+        return value.reduce((acc, item) => acc + item, 0);
+    };
+})(ArrayTransformer || (exports.ArrayTransformer = ArrayTransformer = {}));

package/dist/transformers/date.d.ts

@@ -0,0 +1,9 @@
+export declare namespace DateTansformer {
+    const fromString: (template: string) => (value: string) => Date;
+    const fromTimestamp: (value: number) => Date;
+    const fromISO: (value: string) => Date;
+    const isValid: (value: Date) => boolean;
+    const toISO: (value: Date) => string;
+    const toTimestamp: (value: Date) => number;
+    const format: (template: string) => (value: Date) => string;
+}

package/dist/transformers/date.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateTansformer = void 0;
+const dateFns = __importStar(require("date-fns"));
+var DateTansformer;
+(function (DateTansformer) {
+    DateTansformer.fromString = (template) => (value) => {
+        return dateFns.parse(value, template, new Date());
+    };
+    DateTansformer.fromTimestamp = (value) => {
+        return new Date(value);
+    };
+    DateTansformer.fromISO = (value) => {
+        return dateFns.parseISO(value);
+    };
+    DateTansformer.isValid = (value) => {
+        return dateFns.isValid(value);
+    };
+    DateTansformer.toISO = (value) => value.toISOString();
+    DateTansformer.toTimestamp = (value) => value.getTime();
+    DateTansformer.format = (template) => (value) => {
+        return dateFns.format(value, template);
+    };
+})(DateTansformer || (exports.DateTansformer = DateTansformer = {}));

package/dist/transformers/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./array";
+export * from "./date";
+export * from "./number";
+export * from "./string";

package/dist/transformers/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array"), exports);
+__exportStar(require("./date"), exports);
+__exportStar(require("./number"), exports);
+__exportStar(require("./string"), exports);

package/dist/transformers/number.d.ts

@@ -0,0 +1,27 @@
+export type FormatCurrencyOptions = {
+    locale: string;
+    currencyCode: string;
+    minimumFractionDigits: number;
+};
+export type FormatDecimalOptions = {
+    locale: string;
+    decimals: number;
+};
+export declare namespace NumberTransformer {
+    const toString: (value: number) => string;
+    const toInteger: (value: number) => number;
+    const multiply: (multiplier: number) => (value: number) => number;
+    const divide: (divider: number) => (value: number) => number;
+    const add: (addend: number) => (value: number) => number;
+    const subtract: (subtrahend: number) => (value: number) => number;
+    const power: (exponent: number) => (value: number) => number;
+    const sqrt: (value: number) => number;
+    const clamp: (min: number, max: number) => (value: number) => number;
+    const toBoolean: (value: number) => boolean;
+    const toBigint: BigIntConstructor;
+    const round: (decimals: number) => (value: number) => number;
+    const toPercentage: (decimals: number) => (value: number) => string;
+    const toAbsolute: (value: number) => number;
+    const formatCurrency: ({ currencyCode, locale, minimumFractionDigits }: FormatCurrencyOptions) => (value: number) => string;
+    const formatDecimal: ({ decimals, locale }: FormatDecimalOptions) => (value: number) => string;
+}

package/dist/transformers/number.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberTransformer = void 0;
+var NumberTransformer;
+(function (NumberTransformer) {
+    NumberTransformer.toString = (value) => value.toString();
+    NumberTransformer.toInteger = (value) => Math.floor(value);
+    NumberTransformer.multiply = (multiplier) => (value) => multiplier * value;
+    NumberTransformer.divide = (divider) => (value) => divider * value;
+    NumberTransformer.add = (addend) => (value) => value + addend;
+    NumberTransformer.subtract = (subtrahend) => (value) => value - subtrahend;
+    NumberTransformer.power = (exponent) => (value) => Math.pow(value, exponent);
+    NumberTransformer.sqrt = (value) => Math.sqrt(value);
+    NumberTransformer.clamp = (min, max) => (value) => {
+        return Math.min(Math.max(value, min), max);
+    };
+    NumberTransformer.toBoolean = (value) => {
+        if (value === 0)
+            return false;
+        if (value === 1)
+            return true;
+        throw new Error(`The number ${value} cannot be converted to boolean!`);
+    };
+    NumberTransformer.toBigint = BigInt;
+    NumberTransformer.round = (decimals) => {
+        return (value) => {
+            return Number(value.toFixed(decimals));
+        };
+    };
+    NumberTransformer.toPercentage = (decimals) => {
+        return (value) => {
+            return `${(value * 100).toFixed(decimals)}%`;
+        };
+    };
+    NumberTransformer.toAbsolute = (value) => Math.abs(value);
+    NumberTransformer.formatCurrency = ({ currencyCode, locale, minimumFractionDigits }) => {
+        return (value) => {
+            const formatter = new Intl.NumberFormat(locale, {
+                style: "currency",
+                currency: currencyCode,
+                minimumFractionDigits: minimumFractionDigits,
+            });
+            return formatter.format(value);
+        };
+    };
+    NumberTransformer.formatDecimal = ({ decimals, locale }) => {
+        return (value) => {
+            const formatter = new Intl.NumberFormat(locale, {
+                minimumFractionDigits: decimals,
+                maximumFractionDigits: decimals,
+            });
+            return formatter.format(value);
+        };
+    };
+})(NumberTransformer || (exports.NumberTransformer = NumberTransformer = {}));

package/dist/transformers/string.d.ts

@@ -0,0 +1,16 @@
+export declare namespace StringTransformer {
+    const toLowerCase: (value: string) => string;
+    const toUpperCase: (value: string) => string;
+    const trim: (value: string) => string;
+    const toNumber: NumberConstructor;
+    const replace: (searchValue: string | RegExp, replaceValue: string) => (value: string) => string;
+    const remove: (searchValue: string | RegExp) => (value: string) => string;
+    const split: (separator: string) => (value: string) => string[];
+    const toBoolean: (value: string) => boolean;
+    const normalize: (value: string) => string;
+    const removeHtmlTags: (value: string) => string;
+    const sanitize: (value: string) => string;
+    const collapseWhitespace: (value: string) => string;
+    const lookupInRecord: (record: Record<string, any>) => (value: string) => any;
+    const resolveUrl: (baseUrl: string) => (value: string) => string;
+}

package/dist/transformers/string.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringTransformer = void 0;
+const string_1 = require("../validators/string");
+var StringTransformer;
+(function (StringTransformer) {
+    StringTransformer.toLowerCase = (value) => value.toLowerCase();
+    StringTransformer.toUpperCase = (value) => value.toUpperCase();
+    StringTransformer.trim = (value) => value.trim();
+    StringTransformer.toNumber = Number;
+    StringTransformer.replace = (searchValue, replaceValue) => (value) => value.replace(searchValue, replaceValue);
+    StringTransformer.remove = (searchValue) => (value) => value.replace(searchValue, "");
+    StringTransformer.split = (separator) => (value) => value.split(separator);
+    StringTransformer.toBoolean = (value) => {
+        if (!string_1.StringValidator.isBooleanText(value)) {
+            throw new Error(`'${value}' cannot be converted to boolean!`);
+        }
+        const truthyValues = ["true", "1", "yes"];
+        const lowerValue = value.toLowerCase();
+        if (truthyValues.includes(lowerValue)) {
+            return true;
+        }
+        return false;
+    };
+    StringTransformer.normalize = (value) => {
+        return value
+            .normalize("NFD")
+            .toLowerCase()
+            .replace(/[\u0300-\u036f]/g, "")
+            .trim();
+    };
+    StringTransformer.removeHtmlTags = (value) => value.replace(/<\/?[^>]+(>|$)/g, "");
+    StringTransformer.sanitize = (value) => value.replace(/[^a-zA-Z0-9\s]/g, "").trim();
+    StringTransformer.collapseWhitespace = (value) => value.replace(/\s+/g, " ").trim();
+    StringTransformer.lookupInRecord = (record) => {
+        return (value) => {
+            if (!(value in record)) {
+                throw new Error(`Record does not have '${value}' as key!`);
+            }
+            return record[value];
+        };
+    };
+    StringTransformer.resolveUrl = (baseUrl) => {
+        return (value) => {
+            try {
+                const resolvedUrl = new URL(value, baseUrl).href;
+                if (!string_1.StringValidator.isUrl(resolvedUrl)) {
+                    throw new Error(`Invalid URL: '${value}' with base '${baseUrl}'`);
+                }
+                return resolvedUrl;
+            }
+            catch (error) {
+                throw new Error(`Invalid URL: '${value}' with base '${baseUrl}'`);
+            }
+        };
+    };
+})(StringTransformer || (exports.StringTransformer = StringTransformer = {}));

package/dist/transforming-model.d.ts

@@ -0,0 +1,24 @@
+import { SkipFunction } from ".";
+export type TransformerFunction = (data: Record<string, any>, skip: SkipFunction) => any | Promise<any>;
+export type TransformationModelShapeValueBase = TransformerFunction[];
+export type TransformationModelShapeNestedValue = {
+    multiple?: boolean;
+    model: TransformingModel;
+};
+export type TransformingModelShape = {
+    [key: string]: TransformationModelShapeValueBase | TransformationModelShapeNestedValue;
+};
+export type TransformingModelAfterOptions = {
+    delete?: string[];
+    append?: Record<string, any>;
+};
+export declare class TransformingModel {
+    readonly shape: TransformingModelShape;
+    private readonly fieldsToDelete;
+    private readonly fieldsToAppend;
+    constructor(shape: TransformingModelShape);
+    transform(data: Record<string, any>): Promise<Record<string, any>>;
+    transformValueBase(value: TransformationModelShapeValueBase, key: string, data: any): Promise<any>;
+    transformNestedValue(value: TransformationModelShapeNestedValue, data: any): Promise<any[] | Record<string, any>>;
+    after({ delete: delete_, append }: TransformingModelAfterOptions): this;
+}

package/dist/transforming-model.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransformingModel = void 0;
+class TransformingModel {
+    constructor(shape) {
+        this.shape = shape;
+        this.fieldsToDelete = [];
+        this.fieldsToAppend = {};
+    }
+    async transform(data) {
+        const result = { ...data };
+        for (const key in this.shape) {
+            const value = this.shape[key];
+            if (Array.isArray(value)) {
+                result[key] = await this.transformValueBase(value, key, result);
+            }
+            else {
+                result[key] = await this.transformNestedValue(value, result);
+            }
+        }
+        for (const field of this.fieldsToDelete) {
+            delete result[field];
+        }
+        for (const [key, value] of Object.entries(this.fieldsToAppend)) {
+            result[key] = value;
+        }
+        return result;
+    }
+    async transformValueBase(value, key, data) {
+        let result = data[key];
+        for (const transformer of value) {
+            let skiped = false;
+            const skip = () => {
+                skiped = true;
+            };
+            let tempResult = await transformer({
+                ...data,
+                [key]: result
+            }, skip);
+            if (!skiped) {
+                result = tempResult;
+            }
+        }
+        return result;
+    }
+    async transformNestedValue(value, data) {
+        if (value.multiple) {
+            return await Promise.all(data.map(value.model.transform.bind(this)));
+        }
+        else {
+            return await value.model.transform(data);
+        }
+    }
+    after({ delete: delete_, append }) {
+        if (delete_) {
+            this.fieldsToDelete.push(...delete_);
+        }
+        if (append) {
+            for (const [key, value] of Object.entries(append)) {
+                this.fieldsToAppend[key] = value;
+            }
+        }
+        return this;
+    }
+}
+exports.TransformingModel = TransformingModel;

package/dist/validators/any.d.ts

@@ -0,0 +1,12 @@
+export declare namespace AnyValidator {
+    const isString: (value: any) => value is string;
+    const isNumber: (value: any) => boolean;
+    const isArray: (arg: any) => arg is any[];
+    const isBigint: (value: any) => value is bigint;
+    const isFunction: (value: any) => boolean;
+    const isSymbol: (value: any) => value is symbol;
+    const isObject: (value: any) => boolean;
+    const isBoolean: (value: any) => value is boolean;
+    const isUndefined: (value: any) => boolean;
+    const isNull: (value: any) => boolean;
+}

package/dist/validators/any.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnyValidator = void 0;
+var AnyValidator;
+(function (AnyValidator) {
+    AnyValidator.isString = (value) => typeof value === "string";
+    AnyValidator.isNumber = (value) => typeof value === "number" && !isNaN(value) && value !== Infinity;
+    AnyValidator.isArray = Array.isArray;
+    AnyValidator.isBigint = (value) => typeof value === "bigint";
+    AnyValidator.isFunction = (value) => typeof value === "function";
+    AnyValidator.isSymbol = (value) => typeof value === "symbol";
+    AnyValidator.isObject = (value) => typeof value === "object" && !Array.isArray(value) && value !== null;
+    AnyValidator.isBoolean = (value) => typeof value === "boolean";
+    AnyValidator.isUndefined = (value) => value === undefined;
+    AnyValidator.isNull = (value) => value === null;
+})(AnyValidator || (exports.AnyValidator = AnyValidator = {}));

package/dist/validators/array.d.ts

@@ -0,0 +1,18 @@
+export declare namespace ArrayValidator {
+    const isEmpty: (value: any[]) => boolean;
+    const isNotEmpty: (value: any[]) => boolean;
+    const minLength: (min: number) => (value: any[]) => boolean;
+    const maxLength: (max: number) => (value: any[]) => boolean;
+    const exactLength: (length: number) => (value: any[]) => boolean;
+    const every: <T>(predicate: (item: T) => boolean) => (value: T[]) => boolean;
+    const some: <T>(predicate: (item: T) => boolean) => (value: T[]) => boolean;
+    const includes: <T>(item: T) => (value: T[]) => boolean;
+    const isUniformType: (value: any[]) => boolean;
+    const isAllStrings: (value: any[]) => value is string[];
+    const isAllNumbers: (value: any[]) => value is number[];
+    const isAllBooleans: (value: any[]) => value is boolean[];
+    const hasNoDuplicates: <T>(value: T[]) => boolean;
+    const isSorted: (direction?: "asc" | "desc") => <T>(value: T[]) => boolean;
+    const isAllTruthy: (value: any[]) => boolean;
+    const isAllFalsy: (value: any[]) => boolean;
+}

package/dist/validators/array.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayValidator = void 0;
+var ArrayValidator;
+(function (ArrayValidator) {
+    ArrayValidator.isEmpty = (value) => value.length === 0;
+    ArrayValidator.isNotEmpty = (value) => value.length > 0;
+    ArrayValidator.minLength = (min) => {
+        return (value) => value.length >= min;
+    };
+    ArrayValidator.maxLength = (max) => {
+        return (value) => value.length <= max;
+    };
+    ArrayValidator.exactLength = (length) => {
+        return (value) => value.length === length;
+    };
+    ArrayValidator.every = (predicate) => {
+        return (value) => value.every(predicate);
+    };
+    ArrayValidator.some = (predicate) => {
+        return (value) => value.some(predicate);
+    };
+    ArrayValidator.includes = (item) => {
+        return (value) => value.includes(item);
+    };
+    ArrayValidator.isUniformType = (value) => {
+        return value.length === 0 || value.every(item => typeof item === typeof value[0]);
+    };
+    ArrayValidator.isAllStrings = (value) => {
+        return value.every(item => typeof item === "string");
+    };
+    ArrayValidator.isAllNumbers = (value) => {
+        return value.every(item => typeof item === "number");
+    };
+    ArrayValidator.isAllBooleans = (value) => {
+        return value.every(item => typeof item === "boolean");
+    };
+    ArrayValidator.hasNoDuplicates = (value) => {
+        return value.length === new Set(value).size;
+    };
+    ArrayValidator.isSorted = (direction = "asc") => (value) => {
+        const compare = direction === "asc" ? (a, b) => a <= b : (a, b) => a >= b;
+        return value.every((item, index) => index === 0 || compare(value[index - 1], item));
+    };
+    ArrayValidator.isAllTruthy = (value) => value.every(Boolean);
+    ArrayValidator.isAllFalsy = (value) => value.every(item => !item);
+})(ArrayValidator || (exports.ArrayValidator = ArrayValidator = {}));

package/dist/validators/date.d.ts

@@ -0,0 +1,17 @@
+export declare namespace DateValidator {
+    const isValid: (value: Date) => boolean;
+    const isAfter: (compareDate: Date) => (value: Date) => boolean;
+    const isBefore: (compareDate: Date) => (value: Date) => boolean;
+    const isEqualDate: (compareDate: Date) => (value: Date) => boolean;
+    const isInRange: (start: Date, end: Date) => (value: Date) => boolean;
+    const isFuture: (value: Date) => boolean;
+    const isPast: (value: Date) => boolean;
+    const isToday: (value: Date) => boolean;
+    const isWeekend: (value: Date) => boolean;
+    const isWeekday: (value: Date) => boolean;
+    const isSameMonth: (compareDate: Date) => (value: Date) => boolean;
+    const isSameYear: (compareDate: Date) => (value: Date) => boolean;
+    const isFirstDayOfMonth: (value: Date) => boolean;
+    const isLastDayOfMonth: (value: Date) => boolean;
+    const isParsable: (template: string) => (value: string) => boolean;
+}

package/dist/validators/date.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateValidator = void 0;
+const dateFns = __importStar(require("date-fns"));
+var DateValidator;
+(function (DateValidator) {
+    DateValidator.isValid = (value) => dateFns.isValid(value);
+    DateValidator.isAfter = (compareDate) => {
+        return (value) => dateFns.isAfter(value, compareDate);
+    };
+    DateValidator.isBefore = (compareDate) => {
+        return (value) => dateFns.isBefore(value, compareDate);
+    };
+    DateValidator.isEqualDate = (compareDate) => {
+        return (value) => dateFns.isSameDay(value, compareDate);
+    };
+    DateValidator.isInRange = (start, end) => {
+        return (value) => dateFns.isWithinInterval(value, { start: start, end: end });
+    };
+    DateValidator.isFuture = (value) => dateFns.isFuture(value);
+    DateValidator.isPast = (value) => dateFns.isPast(value);
+    DateValidator.isToday = (value) => dateFns.isToday(value);
+    DateValidator.isWeekend = (value) => {
+        const day = dateFns.getDay(value);
+        return day === 0 || day === 6;
+    };
+    DateValidator.isWeekday = (value) => !DateValidator.isWeekend(value);
+    DateValidator.isSameMonth = (compareDate) => {
+        return (value) => dateFns.isSameMonth(value, compareDate);
+    };
+    DateValidator.isSameYear = (compareDate) => {
+        return (value) => dateFns.isSameYear(value, compareDate);
+    };
+    DateValidator.isFirstDayOfMonth = (value) => dateFns.isFirstDayOfMonth(value);
+    DateValidator.isLastDayOfMonth = (value) => dateFns.isLastDayOfMonth(value);
+    DateValidator.isParsable = (template) => {
+        return (value) => {
+            const parsed = dateFns.parse(value, template, new Date());
+            return dateFns.isValid(parsed);
+        };
+    };
+})(DateValidator || (exports.DateValidator = DateValidator = {}));

package/dist/validators/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./array";
+export * from "./date";
+export * from "./number";
+export * from "./string";
+export * from "./any";

package/dist/validators/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./array"), exports);
+__exportStar(require("./date"), exports);
+__exportStar(require("./number"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./any"), exports);

package/dist/validators/number.d.ts

@@ -0,0 +1,21 @@
+export declare namespace NumberValidator {
+    const isValid: (value: number) => boolean;
+    const isInteger: (value: number) => boolean;
+    const isFloat: (value: number) => boolean;
+    const isInfinity: (value: number) => boolean;
+    const isPositiveInfinity: (value: number) => boolean;
+    const isNegativeInfinity: (value: number) => boolean;
+    const isGreaterThan: (min: number) => (value: number) => boolean;
+    const isGreaterThanOrEqual: (min: number) => (value: number) => boolean;
+    const isLessThan: (max: number) => (value: number) => boolean;
+    const isLessThanOrEqual: (max: number) => (value: number) => boolean;
+    const isInRange: (min: number, max: number) => (value: number) => boolean;
+    const isPositive: (value: number) => boolean;
+    const isNegative: (value: number) => boolean;
+    const isZero: (value: number) => value is 0;
+    const isEven: (value: number) => boolean;
+    const isOdd: (value: number) => boolean;
+    const isFinite: (value: number) => boolean;
+    const isMultipleOf: (divisor: number) => (value: number) => boolean;
+    const hasDecimalPlaces: (places: number) => (value: number) => boolean;
+}

package/dist/validators/number.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NumberValidator = void 0;
+var NumberValidator;
+(function (NumberValidator) {
+    NumberValidator.isValid = (value) => !isNaN(value) && !NumberValidator.isInfinity(value);
+    NumberValidator.isInteger = (value) => Number.isInteger(value);
+    NumberValidator.isFloat = (value) => NumberValidator.isValid(value) && !Number.isInteger(value);
+    NumberValidator.isInfinity = (value) => {
+        return NumberValidator.isPositiveInfinity(value) || NumberValidator.isNegativeInfinity(value);
+    };
+    NumberValidator.isPositiveInfinity = (value) => value === Infinity;
+    NumberValidator.isNegativeInfinity = (value) => value === -Infinity;
+    NumberValidator.isGreaterThan = (min) => {
+        return (value) => value > min;
+    };
+    NumberValidator.isGreaterThanOrEqual = (min) => {
+        return (value) => value >= min;
+    };
+    NumberValidator.isLessThan = (max) => {
+        return (value) => value < max;
+    };
+    NumberValidator.isLessThanOrEqual = (max) => {
+        return (value) => value <= max;
+    };
+    NumberValidator.isInRange = (min, max) => {
+        return (value) => value >= min && value <= max;
+    };
+    NumberValidator.isPositive = (value) => value > 0;
+    NumberValidator.isNegative = (value) => value < 0;
+    NumberValidator.isZero = (value) => value === 0;
+    NumberValidator.isEven = (value) => value % 2 === 0;
+    NumberValidator.isOdd = (value) => value % 2 !== 0;
+    NumberValidator.isFinite = (value) => Number.isFinite(value);
+    NumberValidator.isMultipleOf = (divisor) => {
+        return (value) => value % divisor === 0;
+    };
+    NumberValidator.hasDecimalPlaces = (places) => (value) => {
+        const decimalPart = (value.toString().split(".")[1] || "").length;
+        return decimalPart === places;
+    };
+})(NumberValidator || (exports.NumberValidator = NumberValidator = {}));

package/dist/validators/string.d.ts

@@ -0,0 +1,17 @@
+export declare namespace StringValidator {
+    const includes: (str: string) => (value: string) => boolean;
+    const isNumeric: (value: string) => boolean;
+    const isEmpty: (value: string) => boolean;
+    const minLength: (min: number) => (value: string) => boolean;
+    const maxLength: (max: number) => (value: string) => boolean;
+    const exactLength: (length: number) => (value: string) => boolean;
+    const isEmail: (value: string) => boolean;
+    const isUrl: (value: string) => boolean;
+    const matches: (regex: RegExp) => (value: string) => boolean;
+    const isAlpha: (value: string) => boolean;
+    const isAlphanumeric: (value: string) => boolean;
+    const isIntegerText: (value: string) => boolean;
+    const isDecimalText: (value: string) => boolean;
+    const isWhitespace: (value: string) => boolean;
+    const isBooleanText: (value: string) => boolean;
+}

package/dist/validators/string.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringValidator = void 0;
+var StringValidator;
+(function (StringValidator) {
+    StringValidator.includes = (str) => (value) => value.includes(str);
+    StringValidator.isNumeric = (value) => !isNaN(Number(value));
+    StringValidator.isEmpty = (value) => value.trim() === "";
+    StringValidator.minLength = (min) => (value) => value.length >= min;
+    StringValidator.maxLength = (max) => (value) => value.length <= max;
+    StringValidator.exactLength = (length) => (value) => value.length === length;
+    StringValidator.isEmail = (value) => {
+        const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+        return emailRegex.test(value);
+    };
+    StringValidator.isUrl = (value) => {
+        const urlRegex = /^(https?:\/\/)?([\w-]+\.)+[\w-]+(\/[\w-./?%&=]*)?$/;
+        return urlRegex.test(value);
+    };
+    StringValidator.matches = (regex) => (value) => regex.test(value);
+    StringValidator.isAlpha = (value) => /^[a-zA-Z]+$/.test(value);
+    StringValidator.isAlphanumeric = (value) => /^[a-zA-Z0-9]+$/.test(value);
+    StringValidator.isIntegerText = (value) => /^\d+$/.test(value);
+    StringValidator.isDecimalText = (value) => /^\d+[.,]\d+$/.test(value);
+    StringValidator.isWhitespace = (value) => /^\s+$/.test(value);
+    StringValidator.isBooleanText = (value) => {
+        const booleanValues = ["true", "false", "1", "0", "yes", "no"];
+        return booleanValues.includes(value.toLowerCase());
+    };
+})(StringValidator || (exports.StringValidator = StringValidator = {}));

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@xcrap/transformer",
+  "version": "0.0.1",
+  "description": "Xcrap Transformer is the data transformation package extracted from the Web Scraping framework Xcrap.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/*",
+    "!/**/__tests__"
+  ],
+  "scripts": {
+    "test": "jest",
+    "build": "tsc"
+  },
+  "keywords": [
+    "xcrap",
+    "transformer",
+    "scrapy",
+    "web scraping"
+  ],
+  "author": "Marcuth",
+  "license": "MIT",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/jest": "30.0.0",
+    "@types/node": "24.0.3",
+    "jest": "30.0.2",
+    "ts-jest": "29.4.0",
+    "ts-node": "10.9.2",
+    "typescript": "5.8.3"
+  },
+  "dependencies": {
+    "date-fns": "4.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Xcrap-Cloud/transformer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Xcrap-Cloud/transformer/issues"
+  },
+  "homepage": "https://github.com/Xcrap-Cloud/transformer#readme"
+}