seishiro 0.1.6-untest

package/lib/policy.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @name PolicyBuilder
+ */
+class PolicyBuilder {
+    constructor({ passkey, version_now, version_min, version_forceupdate = true, }) {
+        if (!passkey || !version_now || !version_min) {
+            throw new Error("PolicyBuilder: passkey, version_now, and version_min are required!");
+        }
+        this.passkey = passkey;
+        this.version_now = version_now;
+        this.version_min = version_min;
+        this.version_forceupdate = version_forceupdate;
+        this.noaction_api = [];
+        this.noaction_server = [];
+    }
+    noaction(type = "", action = []) {
+        const onlyAllowed = ["server-action", "api-action"];
+        for (let actionRes of action) {
+            if (!onlyAllowed.includes(actionRes)) {
+                throw new Error(`Invalid action type: ${actionRes}. Only allowed actions are: ${onlyAllowed.join(", ")}`);
+            }
+        }
+        if (typeof type !== "string") {
+            throw new Error(`Invalid key type, it only string!`);
+        }
+        for (let actionRes of action) {
+            if (actionRes === "api-action") {
+                this.noaction_api.push(type);
+            }
+            else if (actionRes === "server-action") {
+                this.noaction_server.push(type);
+            }
+        }
+    }
+    compareVersions(v1, v2) {
+        const clean = (v) => v.replace(/-.*$/, "");
+        const p1 = clean(v1).split(".").map(Number);
+        const p2 = clean(v2).split(".").map(Number);
+        for (let i = 0; i < Math.max(p1.length, p2.length); i++) {
+            const n1 = p1[i] || 0;
+            const n2 = p2[i] || 0;
+            if (n1 > n2)
+                return 1;
+            if (n1 < n2)
+                return -1;
+        }
+        return 0;
+    }
+    version_info(version = "") {
+        const comparisonMin = this.compareVersions(version, this.version_min);
+        const comparisonNow = this.compareVersions(version, this.version_now);
+        const minimumVersion = comparisonMin >= 0;
+        const matchWithNow = comparisonNow >= 0;
+        return {
+            info_upgrade: this.version_forceupdate,
+            is_version_min: minimumVersion,
+            is_version_now: matchWithNow,
+        };
+    }
+    apply() {
+        return {
+            passkey: this.passkey,
+            version_now: this.version_now,
+            version_min: this.version_min,
+            version_forceupdate: this.version_forceupdate,
+            noaction_api: this.noaction_api,
+            noaction_server: this.noaction_server,
+        };
+    }
+}
+exports.default = PolicyBuilder;

package/lib/registry.d.ts

@@ -0,0 +1,29 @@
+import type { RegistryKey, RegistryFunction, RegistryLogic, RegistryMiddleware } from "../types/registry.type";
+/**
+ * @name RegistryBuilder
+ */
+export default class RegistryBuilder {
+    private registry_logic;
+    constructor();
+    /**
+     * @name set
+     * @param key RegistryKey
+     * @param function_regis RegistryFunction
+     * @param middleware RegistryMiddleware
+     */
+    set(key: RegistryKey, function_regis: RegistryFunction, middleware?: RegistryMiddleware): void;
+    /**
+     * @name get
+     * @param key string
+     */
+    get(key: RegistryKey): RegistryFunction | [RegistryMiddleware, RegistryFunction] | undefined;
+    /**
+     * @name apply
+     */
+    apply(): RegistryLogic;
+    /**
+     * @name use
+     * @param input RegistryBuilder | RegistryLogic
+     */
+    use(input: RegistryBuilder | RegistryLogic): void;
+}

package/lib/registry.js

@@ -0,0 +1,72 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const format_key_1 = __importDefault(require("../helper/format-key"));
+/**
+ * @name RegistryBuilder
+ */
+class RegistryBuilder {
+    constructor() {
+        this.registry_logic = {};
+        this.registry_logic = {};
+    }
+    /**
+     * @name set
+     * @param key RegistryKey
+     * @param function_regis RegistryFunction
+     * @param middleware RegistryMiddleware
+     */
+    set(key, function_regis, middleware) {
+        const keyStr = (0, format_key_1.default)(key);
+        if (typeof function_regis !== "function") {
+            throw new Error("Registry function is only type function!");
+        }
+        if (typeof key !== "string") {
+            throw new Error("Registry key is only type string!");
+        }
+        if (!!middleware && typeof middleware === "function") {
+            this.registry_logic[keyStr] = [middleware, function_regis];
+        }
+        else {
+            this.registry_logic[keyStr] = function_regis;
+        }
+    }
+    /**
+     * @name get
+     * @param key string
+     */
+    get(key) {
+        const keyStr = (0, format_key_1.default)(key);
+        return this.registry_logic[keyStr] || undefined;
+    }
+    /**
+     * @name apply
+     */
+    apply() {
+        return this.registry_logic;
+    }
+    /**
+     * @name use
+     * @param input RegistryBuilder | RegistryLogic
+     */
+    use(input) {
+        const logic = input instanceof RegistryBuilder ? input.registry_logic : input;
+        if (typeof logic === "object" && logic !== null) {
+            Object.entries(logic).forEach(([key, val]) => {
+                if (Array.isArray(val)) {
+                    const [middleware, func] = val;
+                    this.set(key, func, middleware);
+                }
+                else if (typeof val === "function") {
+                    this.set(key, val);
+                }
+            });
+        }
+        else {
+            throw new Error('The "use" input must be a RegistryBuilder or mapping object!');
+        }
+    }
+}
+exports.default = RegistryBuilder;

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "seishiro",
+  "version": "0.1.6-untest",
+  "description": "A simple response context API that eliminates the complexity of routing folder structures and replaces them with a single control center.",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "build": "tsc",
+    "build:package": "rm -r dist && tsc && cp ./package.json ./dist/ && cp ./README.md ./dist/ && cp ./LICENSE ./dist/",
+    "bun:build": "bun build ./src/**/*.ts --outdir ./dist",
+    "test": "bun test",
+    "lint": "biome check",
+    "format": "biome format --write"
+  },
+  "license": "AGPL-3.0",
+  "author": "Ernestoyoofi",
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.13",
+    "@types/jest": "^30.0.0"
+  }
+}

package/types/message.type.d.ts

@@ -0,0 +1,13 @@
+export type MessageKey = string;
+export type MessageLang = string | "en" | "id";
+export type MessageValue = string;
+export type MessageErrorContext = string;
+export type MessageErrorContextSlug = string;
+export type MessageErrorContextOpt = object;
+export type MessageErrorContextTrack = string;
+export type MessageLogicLang = {
+    [key: MessageLang]: {
+        [key: MessageKey]: MessageValue;
+    };
+};
+export type MessageLogic = Record<MessageKey, MessageValue>;

package/types/message.type.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Message Error Context

package/types/policy.type.d.ts

@@ -0,0 +1,10 @@
+export type PolicyPassKey = string;
+export type PolicyVersionNow = string;
+export type PolicyVersionMin = string;
+export type PolicyVersionForceUpdate = boolean;
+export type PolicyNoActionKey = string;
+type AllowedActions = "server-action" | "api-action";
+export type PolicyNoActionBase = AllowedActions[];
+export type PolicyNoActionAPIAction = string[];
+export type PolicyNoActionServerAction = string[];
+export {};

package/types/policy.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/registry.type.d.ts

@@ -0,0 +1,16 @@
+export type RegistryKey = string;
+export type RegistryParams = {
+    system: {
+        cookies: object;
+        headers: object;
+        ip: string;
+        location: string;
+        lang: string | "en";
+    };
+    type: RegistryKey;
+    middleware?: object | Function | Promise<any>;
+    data: object;
+};
+export type RegistryFunction = (params: RegistryParams) => any;
+export type RegistryMiddleware = (params: RegistryParams) => any;
+export type RegistryLogic = Record<RegistryKey, RegistryFunction | [RegistryMiddleware, RegistryFunction]>;

package/types/registry.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/var/message.d.ts

@@ -0,0 +1 @@
+export declare const DefaultLanguage: string;

package/var/message.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultLanguage = void 0;
+exports.DefaultLanguage = "en";

package/var/registry.d.ts

@@ -0,0 +1,3 @@
+export declare const ServerAction: string;
+export declare const APIAction: string;
+export declare const PolicyAction: string[];

package/var/registry.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyAction = exports.APIAction = exports.ServerAction = void 0;
+exports.ServerAction = "server-action";
+exports.APIAction = "api-action";
+exports.PolicyAction = ["server-action", "api-action"];