@aeriajs/common 0.0.0

package/dist/pipe.mjs

@@ -0,0 +1,259 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, g, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    };
+    return g = {
+        next: verb(0),
+        "throw": verb(1),
+        "return": verb(2)
+    }, typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(_)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+export var pipe = function(functions, options) {
+    var returnFirst = (options || {}).returnFirst;
+    return function() {
+        var _ref = _async_to_generator(function(value) {
+            var _len, args, _key, ret, _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, fn, result, err;
+            var _arguments = arguments;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        for(_len = _arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+                            args[_key - 1] = _arguments[_key];
+                        }
+                        ret = value;
+                        _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+                        _state.label = 1;
+                    case 1:
+                        _state.trys.push([
+                            1,
+                            6,
+                            7,
+                            8
+                        ]);
+                        _iterator = functions[Symbol.iterator]();
+                        _state.label = 2;
+                    case 2:
+                        if (!!(_iteratorNormalCompletion = (_step = _iterator.next()).done)) return [
+                            3,
+                            5
+                        ];
+                        fn = _step.value;
+                        return [
+                            4,
+                            fn.apply(void 0, [
+                                ret
+                            ].concat(_to_consumable_array(args)))
+                        ];
+                    case 3:
+                        ret = _state.sent();
+                        if (returnFirst && ret !== undefined) {
+                            switch(typeof returnFirst === "undefined" ? "undefined" : _type_of(returnFirst)){
+                                case "function":
+                                    {
+                                        result = returnFirst(ret);
+                                        if (result) {
+                                            return [
+                                                2,
+                                                result
+                                            ];
+                                        }
+                                        break;
+                                    }
+                                default:
+                                    {
+                                        return [
+                                            2,
+                                            ret
+                                        ];
+                                    }
+                            }
+                        }
+                        _state.label = 4;
+                    case 4:
+                        _iteratorNormalCompletion = true;
+                        return [
+                            3,
+                            2
+                        ];
+                    case 5:
+                        return [
+                            3,
+                            8
+                        ];
+                    case 6:
+                        err = _state.sent();
+                        _didIteratorError = true;
+                        _iteratorError = err;
+                        return [
+                            3,
+                            8
+                        ];
+                    case 7:
+                        try {
+                            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                                _iterator.return();
+                            }
+                        } finally{
+                            if (_didIteratorError) {
+                                throw _iteratorError;
+                            }
+                        }
+                        return [
+                            7
+                        ];
+                    case 8:
+                        return [
+                            2,
+                            ret
+                        ];
+                }
+            });
+        });
+        return function(value) {
+            return _ref.apply(this, arguments);
+        };
+    }();
+};

package/dist/schema.d.ts

@@ -0,0 +1,20 @@
+import { type Property, type ObjectToSchema } from '@aeriajs/types';
+export declare const fromLiteral: <const TObject, TRequired extends (keyof TObject & string)[]>(object: TObject, required?: TRequired | undefined) => ObjectToSchema<TObject, TRequired>;
+export declare const leftSchema: <const TObject extends Property>(object: TObject) => {
+    type: "object";
+    properties: {
+        _tag: {
+            literal: string;
+        };
+        value: Property;
+    };
+};
+export declare const rightSchema: <const TObject extends Property>(object: TObject) => {
+    type: "object";
+    properties: {
+        _tag: {
+            literal: string;
+        };
+        value: Property;
+    };
+};

package/dist/schema.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rightSchema = exports.leftSchema = exports.fromLiteral = void 0;
+const mapValueToProperty = (value) => {
+    if (value.constructor === Object) {
+        return Object.assign({
+            type: 'object',
+        }, (0, exports.fromLiteral)(value));
+    }
+    if (value === Date) {
+        return {
+            type: 'string',
+            format: 'date-time',
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            type: 'array',
+            items: mapValueToProperty(value[0]),
+        };
+    }
+    if (value && typeof value === 'string') {
+        return {
+            $ref: value,
+        };
+    }
+    return {
+        type: typeof value,
+    };
+};
+const fromLiteral = (object, required) => {
+    const entries = [];
+    for (const propName in object) {
+        const value = object[propName];
+        if (value === null || value === undefined) {
+            continue;
+        }
+        entries.push([
+            propName,
+            mapValueToProperty(value),
+        ]);
+    }
+    const properties = Object.fromEntries(entries);
+    return {
+        type: 'object',
+        required,
+        properties,
+    };
+};
+exports.fromLiteral = fromLiteral;
+const leftSchema = (object) => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                literal: 'Left',
+            },
+            value: object,
+        },
+    };
+};
+exports.leftSchema = leftSchema;
+const rightSchema = (object) => {
+    return {
+        type: 'object',
+        properties: {
+            _tag: {
+                literal: 'Right',
+            },
+            value: object,
+        },
+    };
+};
+exports.rightSchema = rightSchema;

package/dist/schema.mjs

@@ -0,0 +1,72 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+var mapValueToProperty = function(value) {
+    if (value.constructor === Object) {
+        return Object.assign({
+            type: "object"
+        }, fromLiteral(value));
+    }
+    if (value === Date) {
+        return {
+            type: "string",
+            format: "date-time"
+        };
+    }
+    if (Array.isArray(value)) {
+        return {
+            type: "array",
+            items: mapValueToProperty(value[0])
+        };
+    }
+    if (value && typeof value === "string") {
+        return {
+            $ref: value
+        };
+    }
+    return {
+        type: typeof value === "undefined" ? "undefined" : _type_of(value)
+    };
+};
+export var fromLiteral = function(object, required) {
+    var entries = [];
+    for(var propName in object){
+        var value = object[propName];
+        if (value === null || value === undefined) {
+            continue;
+        }
+        entries.push([
+            propName,
+            mapValueToProperty(value)
+        ]);
+    }
+    var properties = Object.fromEntries(entries);
+    return {
+        type: "object",
+        required: required,
+        properties: properties
+    };
+};
+export var leftSchema = function(object) {
+    return {
+        type: "object",
+        properties: {
+            _tag: {
+                literal: "Left"
+            },
+            value: object
+        }
+    };
+};
+export var rightSchema = function(object) {
+    return {
+        type: "object",
+        properties: {
+            _tag: {
+                literal: "Right"
+            },
+            value: object
+        }
+    };
+};

package/dist/serialize.d.ts

@@ -0,0 +1,3 @@
+import * as BSON from 'bson';
+export declare const serialize: (object: BSON.Document, options?: BSON.SerializeOptions | undefined) => string;
+export declare const deserialize: <T extends string>(buffer: T) => BSON.Document;

package/dist/serialize.js

@@ -0,0 +1,33 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deserialize = exports.serialize = void 0;
+const BSON = __importStar(require("bson"));
+const serialize = (...args) => Buffer.from(BSON.serialize(...args)).toString('latin1');
+exports.serialize = serialize;
+const deserialize = (buffer) => {
+    return BSON.deserialize(new Uint8Array(Array.from(buffer).map((c) => c.charCodeAt(0))));
+};
+exports.deserialize = deserialize;

package/dist/serialize.mjs

@@ -0,0 +1,38 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length) len = arr.length;
+    for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
+    return arr2;
+}
+function _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o) return;
+    if (typeof o === "string") return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor) n = o.constructor.name;
+    if (n === "Map" || n === "Set") return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
+}
+var _BSON;
+import * as BSON from "bson";
+export var serialize = function() {
+    for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
+        args[_key] = arguments[_key];
+    }
+    return Buffer.from((_BSON = BSON).serialize.apply(_BSON, _to_consumable_array(args))).toString("latin1");
+};
+export var deserialize = function(buffer) {
+    return BSON.deserialize(new Uint8Array(Array.from(buffer).map(function(c) {
+        return c.charCodeAt(0);
+    })));
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@aeriajs/common",
+  "version": "0.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "peerDependencies": {
+    "@aeriajs/types": "^0.0.0",
+    "bson": "^5.4.0"
+  },
+  "scripts": {
+    "test": "echo skipping",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "build": "pnpm build:cjs && pnpm build:esm",
+    "build:cjs": "tsc",
+    "build:esm": "swc src/* -d dist --strip-leading-paths -C module.type=es6 --out-file-extension=mjs && pnpm build:esm-transform",
+    "build:esm-transform": "pnpm -w esm-transform $PWD/dist"
+  }
+}