@opra/core 0.0.5

package/esm/utils/headers.d.ts

@@ -0,0 +1,9 @@
+import { Opaque } from 'ts-gems';
+export declare type HeadersObject = Opaque<Record<string, any>, 'HeadersObject'>;
+/**
+ * Create a proxy that ensures header keys are always formatted according to well known header names
+ */
+export declare namespace Headers {
+    function from(obj: object): HeadersObject;
+    function create(): HeadersObject;
+}

package/esm/utils/headers.js

@@ -0,0 +1,55 @@
+import { HttpHeaders } from '../enums/index.js';
+const wellKnownHeaders = Object.values(HttpHeaders)
+    .reduce((target, k) => {
+    target[k.toLowerCase()] = k;
+    return target;
+}, {});
+const wrapKey = (prop) => {
+    return typeof prop == 'string' ? wellKnownHeaders[prop.toLowerCase()] || prop : prop;
+};
+/**
+ * Create a proxy that ensures header keys are always formatted according to well known header names
+ */
+export var Headers;
+(function (Headers) {
+    function from(obj) {
+        const headers = create();
+        for (const [k, v] of Object.entries(obj))
+            headers[k] = v;
+        return headers;
+    }
+    Headers.from = from;
+    function create() {
+        return new Proxy({}, {
+            set: (target, prop, value, receiver) => {
+                let key = prop;
+                if (typeof key === 'string')
+                    key = wellKnownHeaders[key.toLowerCase()] || key;
+                const result = Reflect.set(target, key, value, receiver);
+                /*  istanbul ignore next */
+                if (!result && Object.isFrozen(target))
+                    throw new TypeError('Cannot add property, object is not extensible');
+                return result;
+            },
+            get: (target, prop, receiver) => {
+                return Reflect.get(target, wrapKey(prop), receiver);
+            },
+            deleteProperty: (target, prop) => {
+                return Reflect.deleteProperty(target, wrapKey(prop));
+            },
+            defineProperty: (target, prop, descriptor) => {
+                let key = prop;
+                if (typeof key === 'string')
+                    key = wellKnownHeaders[key.toLowerCase()] || key;
+                return Reflect.defineProperty(target, key, descriptor);
+            },
+            getOwnPropertyDescriptor: (target, prop) => {
+                return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
+            },
+            has: (target, prop) => {
+                return Reflect.has(target, wrapKey(prop));
+            }
+        });
+    }
+    Headers.create = create;
+})(Headers || (Headers = {}));

package/esm/utils/internal-data-types.d.ts

@@ -0,0 +1,4 @@
+import { OpraSchema } from '@opra/schema';
+export declare const builtinClassMap: Map<any, any>;
+export declare const primitiveDataTypeNames: string[];
+export declare const internalDataTypes: Map<string, OpraSchema.DataType>;

package/esm/utils/internal-data-types.js

@@ -0,0 +1,41 @@
+export const builtinClassMap = new Map();
+builtinClassMap.set(Boolean, 'boolean');
+builtinClassMap.set(Number, 'number');
+builtinClassMap.set(String, 'string');
+builtinClassMap.set(Buffer, 'buffer');
+export const primitiveDataTypeNames = ['boolean', 'number', 'integer', 'string'];
+export const internalDataTypes = new Map();
+const internalDataTypeArray = [
+    {
+        kind: 'SimpleType',
+        name: 'boolean',
+        type: 'boolean',
+        description: 'Simple true/false value'
+    },
+    {
+        kind: 'SimpleType',
+        name: 'number',
+        type: 'number',
+        description: 'Both Integer as well as Floating-Point numbers'
+    },
+    {
+        kind: 'SimpleType',
+        name: 'string',
+        type: 'string',
+        description: 'A sequence of characters'
+    },
+    {
+        kind: 'ComplexType',
+        name: 'object',
+        description: 'Object type with additional properties',
+        additionalProperties: true
+    },
+    {
+        kind: 'SimpleType',
+        name: 'integer',
+        type: 'number',
+        base: 'number',
+        description: 'Integer number'
+    }
+];
+internalDataTypeArray.forEach(sch => internalDataTypes.set(sch.name, sch));

package/esm/utils/responsive-object.d.ts

@@ -0,0 +1,3 @@
+import { Opaque } from 'ts-gems';
+export declare type ResponsiveObject<T> = Opaque<Record<string, T>, 'ResponsiveObject'>;
+export declare function Responsive<T>(wrapped?: Record<string, T>): ResponsiveObject<T>;

package/esm/utils/responsive-object.js

@@ -0,0 +1,45 @@
+export function Responsive(wrapped) {
+    wrapped = wrapped || {};
+    const keyMap = {};
+    Object.keys(wrapped).forEach(k => keyMap[k.toLowerCase()] = k);
+    const wrapKey = (prop) => {
+        return typeof prop == 'string' ? keyMap[prop.toLowerCase()] : prop;
+    };
+    return new Proxy(wrapped, {
+        set: (target, prop, value, receiver) => {
+            let key = prop;
+            if (typeof key === 'string') {
+                const keyLower = key.toLowerCase();
+                key = keyMap[keyLower] = keyMap[keyLower] || key;
+            }
+            const result = Reflect.set(target, key, value, receiver);
+            if (!result && Object.isFrozen(target))
+                throw new TypeError('Cannot add property, object is not extensible');
+            return result;
+        },
+        get: (target, prop, receiver) => {
+            return Reflect.get(target, wrapKey(prop), receiver);
+        },
+        deleteProperty: (target, prop) => {
+            const key = wrapKey(prop);
+            if (typeof prop === 'string') {
+                delete keyMap[prop.toLowerCase()];
+            }
+            return Reflect.deleteProperty(target, key);
+        },
+        defineProperty: (target, prop, descriptor) => {
+            let key = prop;
+            if (typeof key === 'string') {
+                const keyLower = key.toLowerCase();
+                key = keyMap[keyLower] = keyMap[keyLower] || key;
+            }
+            return Reflect.defineProperty(target, key, descriptor);
+        },
+        getOwnPropertyDescriptor: (target, prop) => {
+            return Reflect.getOwnPropertyDescriptor(target, wrapKey(prop));
+        },
+        has: (target, prop) => {
+            return Reflect.has(target, wrapKey(prop));
+        }
+    });
+}

package/esm/utils/string-path-to-object-tree.d.ts

@@ -0,0 +1,4 @@
+export interface ObjectTree {
+    [key: string]: boolean | ObjectTree;
+}
+export declare function stringPathToObjectTree(arr: string[]): ObjectTree | undefined;

package/esm/utils/string-path-to-object-tree.js

@@ -0,0 +1,22 @@
+const dotPattern = /^([^.]+)\.(.*)$/;
+export function stringPathToObjectTree(arr) {
+    if (!arr.length)
+        return;
+    return _stringPathToObjectTree(arr, {});
+}
+function _stringPathToObjectTree(arr, target) {
+    for (const k of arr) {
+        const m = dotPattern.exec(k);
+        if (m) {
+            const key = m[1];
+            if (target[key] === true)
+                continue;
+            const sub = target[key] = typeof target[key] === 'object' ? target[key] : {};
+            _stringPathToObjectTree([m[2]], sub);
+        }
+        else {
+            target[k] = true;
+        }
+    }
+    return target;
+}

package/esm/utils/terminal-utils.d.ts

@@ -0,0 +1,4 @@
+export declare const nodeInspectCustom: unique symbol;
+export declare const colorReset = "\u001B[0m";
+export declare const colorFgYellow = "\u001B[33m";
+export declare const colorFgMagenta = "\u001B[35m";

package/esm/utils/terminal-utils.js

@@ -0,0 +1,4 @@
+export const nodeInspectCustom = Symbol.for('nodejs.util.inspect.custom');
+export const colorReset = "\x1b[0m";
+export const colorFgYellow = "\x1b[33m";
+export const colorFgMagenta = "\x1b[35m";

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@opra/core",
+  "version": "0.0.5",
+  "description": "Opra schema package",
+  "author": "Panates",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/panates/opra.git",
+    "directory": "packages/core"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "prebuild": "npm run lint && npm run clean",
+    "build": "npm run build:cjs && npm run build:esm",
+    "build:cjs": "tsc -b tsconfig-build-cjs.json",
+    "build:esm": "tsc -b tsconfig-build-esm.json",
+    "postbuild": "cp README.md package.json ../../LICENSE ../../build/core && cp ../../package.cjs.json ../../build/core/cjs/package.json",
+    "lint": "eslint .",
+    "test": "jest",
+    "cover": "jest --collect-coverage",
+    "clean": "npm run clean:src && npm run clean:dist && npm run clean:cover",
+    "clean:src": "ts-cleanup -s src --all",
+    "clean:dist": "rimraf ../../build/core",
+    "clean:cover": "rimraf ../../coverage/core"
+  },
+  "dependencies": {
+    "@opra/url": "0.x.x",
+    "@opra/i18n": "0.x.x",
+    "@opra/schema": "0.x.x",
+    "@opra/optionals": "0.x.x",
+    "ts-gems": "^2.2.0",
+    "lodash": "^4.17.21",
+    "putil-isplainobject": "^1.1.4",
+    "putil-varhelpers": "^1.6.4",
+    "rule-judgment": "^1.1.5"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.13",
+    "express": "^4.18.1"
+  },
+  "peerDependencies": {},
+  "type": "module",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./cjs/index.js",
+      "default": "./esm/index.js"
+    },
+    "./cjs": "./cjs/index.js",
+    "./esm": "./esm/index.js"
+  },
+  "engines": {
+    "node": ">=16.0",
+    "npm": ">=7.0.0"
+  },
+  "files": [
+    "bin/",
+    "cjs/",
+    "esm/",
+    "LICENSE",
+    "README.md"
+  ],
+  "keywords": [
+    "opra",
+    "rest",
+    "api",
+    "oas",
+    "open",
+    "swagger",
+    "raml",
+    "http",
+    "web"
+  ]
+}