cotomy 0.1.0

package/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+Copyright (c) 2025 Yasuhiro Arakawa
+
+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,49 @@
+# Cotomy
+
+A lightweight framework for managing form behavior and page controllers in web applications.  
+Ideal for SPA (Single Page Application) or traditional web apps with dynamic form operations.
+
+## Installation
+
+To install Cotomy in your project, run the following command:
+
+```bash
+npm i cotomy
+```
+
+## Usage
+
+Cotomy will continue to expand with more detailed usage instructions and code examples added to the README in the future.  
+For the latest updates, please check the official documentation or repository regularly.
+
+The core of Cotomy is `CotomyElement`, which is constructed as a wrapper for `Element`.  
+By passing HTML and CSS strings to the constructor, it is possible to generate Element designs with a limited scope.
+
+```typescript
+const element = new CotomyElement(/* html */\`
+  <div>
+    <p>Text</p>
+  </div>
+\`, /* css */\`
+  [scope] {
+    display: block;
+  }
+  [scope] > p {
+    text-align: center;
+  }
+\`);
+```
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## Warning
+
+This project is in its early stages, and the API is still evolving.  
+Since the version is below `1.0.0`, breaking changes may occur without prior notice.
+
+## Contact
+
+You can reach out to me at: [yshr1920@gmail.com](mailto:yshr1920@gmail.com)  
+GitHub repository: [https://github.com/yshr1920/cotomy](https://github.com/yshr1920/cotomy)

package/dist/api.d.ts

@@ -0,0 +1,80 @@
+import { CotomyElementWrap } from "./view";
+export declare class CotomyResponseJsonParseException extends Error {
+    constructor(message?: string);
+}
+export declare class CotomyInvalidFormDataBodyException extends Error {
+    constructor(message?: string);
+}
+export declare class CotomyRestApiResponse {
+    private readonly _response?;
+    private _json;
+    private _map;
+    constructor(_response?: (Response | null) | undefined);
+    get available(): boolean;
+    get empty(): boolean;
+    get ok(): boolean;
+    get status(): number;
+    get statusText(): string;
+    get headers(): Headers;
+    textAsync(): Promise<string>;
+    blobAsync(): Promise<Blob>;
+    objectAsync<T extends object>(defaultValue?: T): Promise<any>;
+}
+export declare class CotomyViewRenderer {
+    private readonly element;
+    private _locale;
+    private _currency;
+    private _renderers;
+    private _builded;
+    constructor(element: CotomyElementWrap);
+    protected get locale(): string;
+    protected get currency(): string;
+    renderer(type: string, callback: (element: CotomyElementWrap, value: any) => void): this;
+    get builded(): boolean;
+    build(): this;
+    applyAsync(respose: CotomyRestApiResponse): Promise<this>;
+}
+export interface ICotomyRestApiOptions {
+    baseUrl?: string | null;
+    headers?: Record<string, string> | null;
+    credentials?: RequestCredentials | null;
+    redirect?: RequestRedirect | null;
+    cache?: RequestCache | null;
+    referrerPolicy?: ReferrerPolicy | null;
+    mode?: RequestMode | null;
+    keepalive?: boolean | null;
+    integrity?: string | null;
+    unauthorizedHandler?: ((response: CotomyRestApiResponse) => void) | null;
+}
+export interface ICotomyRestSubmitForm {
+    method: string;
+    action: string;
+    body: globalThis.FormData | Record<string, string> | any;
+}
+export declare class CotomyRestApi {
+    private readonly _options;
+    private readonly _abortController;
+    constructor(_options?: ICotomyRestApiOptions);
+    get baseUrl(): string;
+    get headers(): Record<string, string>;
+    get credentials(): RequestCredentials;
+    get redirect(): RequestRedirect;
+    get cache(): RequestCache;
+    get referrerPolicy(): ReferrerPolicy;
+    get mode(): RequestMode;
+    get keepalive(): boolean;
+    get integrity(): string;
+    get abortController(): AbortController;
+    get unauthorizedHandler(): (response: CotomyRestApiResponse) => void;
+    private requestAsync;
+    getAsync(path: string, parameters?: globalThis.FormData | Record<string, string | number> | null): Promise<CotomyRestApiResponse>;
+    postAsync(path: string, body: globalThis.FormData | Record<string, string | number> | any): Promise<CotomyRestApiResponse>;
+    putAsync(path: string, body: globalThis.FormData | Record<string, string | number> | any): Promise<CotomyRestApiResponse>;
+    patchAsync(path: string, body: globalThis.FormData | Record<string, string | number> | any): Promise<CotomyRestApiResponse>;
+    deleteAsync(path: string): Promise<CotomyRestApiResponse>;
+    headAsync(path: string): Promise<CotomyRestApiResponse>;
+    optionsAsync(path: string): Promise<CotomyRestApiResponse>;
+    traceAsync(path: string): Promise<CotomyRestApiResponse>;
+    connectAsync(path: string): Promise<CotomyRestApiResponse>;
+    submitAsync(form: ICotomyRestSubmitForm): Promise<CotomyRestApiResponse>;
+}

package/dist/form.d.ts

@@ -0,0 +1,54 @@
+import { CotomyRestApi, CotomyRestApiResponse, CotomyViewRenderer } from "./api";
+import { CotomyElementWrap } from "./view";
+export declare class CotomyActionEvent extends Event {
+    action: string;
+    constructor(action: string);
+}
+export declare abstract class CotomyFormBase extends CotomyElementWrap {
+    constructor(element: HTMLFormElement | string, css?: string | null);
+    get formId(): string;
+    method(): string;
+    actionUri(): string;
+    get autoComplete(): boolean;
+    set autoComplete(value: boolean);
+    reload(): void;
+    get builded(): boolean;
+    build(): this;
+    submit(): void;
+    protected abstract submitAsync(e: Event): Promise<void>;
+    action(handle: ((event: CotomyActionEvent) => void | Promise<void>) | string): this;
+}
+export declare class CotomyQueryForm extends CotomyFormBase {
+    constructor(element: HTMLFormElement | string, css?: string | null);
+    method(): string;
+    protected submitAsync(e: Event): Promise<void>;
+}
+export declare class CotomyApiForm extends CotomyFormBase {
+    private _apiClient;
+    private _unauthorizedHandler;
+    constructor(element: HTMLFormElement | string, css?: string | null);
+    apiClient(): CotomyRestApi;
+    actionUri(): string;
+    get identifier(): string | undefined;
+    protected setIncrementedId(response: CotomyRestApiResponse): void;
+    get identifierInputs(): CotomyElementWrap[];
+    get identifierString(): string;
+    get autoIncrement(): boolean;
+    method(): string;
+    formData(): globalThis.FormData;
+    protected submitAsync(e: Event): Promise<void>;
+    protected submitToApiAsync(formData: globalThis.FormData): Promise<CotomyRestApiResponse>;
+    unauthorized(handle: (response: CotomyRestApiResponse) => void): this;
+}
+export declare class CotomyFillApiForm extends CotomyApiForm {
+    private _fillers;
+    constructor(element: HTMLFormElement | string, css?: string | null);
+    filler(type: string, callback: (input: CotomyElementWrap, value: any) => void): this;
+    build(): this;
+    protected submitToApiAsync(formData: globalThis.FormData): Promise<CotomyRestApiResponse>;
+    reload(): void;
+    loadActionUri(): string;
+    renderer(): CotomyViewRenderer;
+    loadAsync(): Promise<CotomyRestApiResponse>;
+    protected fillAsync(response: CotomyRestApiResponse): Promise<void>;
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { CotomyInvalidFormDataBodyException, CotomyResponseJsonParseException, CotomyRestApi, CotomyRestApiResponse, CotomyViewRenderer } from "./api";
+export type { CotomyActionEvent, CotomyApiForm, CotomyFillApiForm, CotomyFormBase, CotomyQueryForm } from "./form";
+export type { CotomyPageController, CotomyUrl } from "./page";
+export type { CotomyElementWrap, CotomyMetaElement, CotomyWindow } from "./view";

package/dist/index.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.Cotomy=t():e.Cotomy=t()}(this,()=>(()=>{"use strict";var e={};return e.default})());

package/dist/page.d.ts

@@ -0,0 +1,24 @@
+import { CotomyFormBase } from "./form";
+import { CotomyElementWrap } from "./view";
+export declare class CotomyUrl {
+    static location(): CotomyUrl;
+    private _url;
+    constructor(url?: string | null);
+    private current;
+    get url(): string;
+    get path(): string;
+    get segments(): string[];
+    get query(): string;
+    get parameters(): {
+        [key: string]: string;
+    };
+    redirect(): void;
+}
+export declare class CotomyPageController {
+    private static _instance;
+    static set<T extends CotomyPageController = CotomyPageController>(type: new () => T): T;
+    protected setForm<T extends CotomyFormBase = CotomyFormBase>(form: T): T;
+    protected initializeAsync(): Promise<void>;
+    get body(): CotomyElementWrap;
+    protected get uri(): CotomyUrl;
+}

package/dist/view.d.ts

@@ -0,0 +1,194 @@
+export declare class CotomyElementWrap {
+    protected static createHTMLElement(html: string): HTMLElement;
+    static create<T extends CotomyElementWrap = CotomyElementWrap>(html: string, type?: typeof CotomyElementWrap): T;
+    static first<T extends CotomyElementWrap = CotomyElementWrap>(selector: string, type?: typeof CotomyElementWrap): T;
+    static find<T extends CotomyElementWrap = CotomyElementWrap>(selector: string, type?: typeof CotomyElementWrap): T[];
+    static byId<T extends CotomyElementWrap = CotomyElementWrap>(id: string, type?: typeof CotomyElementWrap): T;
+    static contains(selector: string): boolean;
+    static empty<T extends CotomyElementWrap = CotomyElementWrap>(type?: typeof CotomyElementWrap): T;
+    private _element;
+    private _parentElement;
+    private _removed;
+    constructor(element: string | HTMLElement, css?: string | null);
+    private _scopeId;
+    get scopeId(): string;
+    get scopedSelector(): string;
+    get stylable(): boolean;
+    useScopedCss(css: string): this;
+    static readonly LISTEN_LAYOUT_EVENTS_ATTRIBUTE: string;
+    listenLayoutEvents(): this;
+    get id(): string | null | undefined;
+    setId(id: string): this;
+    get element(): HTMLElement;
+    get tagname(): string;
+    is(selector: string): boolean;
+    get empty(): boolean;
+    get attached(): boolean;
+    get readonly(): boolean;
+    set readonly(readonly: boolean);
+    get value(): string;
+    set value(val: string);
+    get text(): string;
+    set text(text: string);
+    get html(): string;
+    set html(html: string);
+    convertUtcToLocal(format?: string, recursive?: boolean): this;
+    setFocus(): void;
+    get visible(): boolean;
+    get enabled(): boolean;
+    set enabled(value: boolean);
+    remove(): void;
+    clone(): CotomyElementWrap;
+    clean(): void;
+    get width(): number;
+    set width(width: number);
+    get height(): number;
+    set height(height: number);
+    get innerWidth(): number;
+    get innerHeight(): number;
+    get outerWidth(): number;
+    get outerHeight(): number;
+    get scrollHeight(): number;
+    get scrollWidth(): number;
+    get scrollTop(): number;
+    get position(): {
+        top: number;
+        left: number;
+    };
+    get absolutePosition(): {
+        top: number;
+        left: number;
+    };
+    get screenPosition(): {
+        top: number;
+        left: number;
+    };
+    get rect(): {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    get innerRect(): {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    get outerRect(): {
+        top: number;
+        left: number;
+        width: number;
+        height: number;
+    };
+    get padding(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    get margin(): {
+        top: number;
+        right: number;
+        bottom: number;
+        left: number;
+    };
+    get inViewport(): boolean;
+    get isAboveViewport(): boolean;
+    get isBelowViewport(): boolean;
+    get isLeftViewport(): boolean;
+    get isRightViewport(): boolean;
+    hasAttribute(name: string): boolean;
+    attribute(name: string): string | null | undefined;
+    setAttribute(name: string, value?: string | number | undefined): this;
+    removeAttribute(name: string): void;
+    hasClass(cls: string): boolean;
+    addClass(cls: string): this;
+    removeClass(cls: string): this;
+    setElementStyle(name: string, value: string): this;
+    removeElementStyle(name: string): this;
+    get computedStyle(): CSSStyleDeclaration;
+    style(name: string): string;
+    get parent(): CotomyElementWrap;
+    get parents(): CotomyElementWrap[];
+    hasChildren(selector?: string): boolean;
+    children<T extends CotomyElementWrap = CotomyElementWrap>(selector?: string, type?: typeof CotomyElementWrap): T[];
+    firstChild<T extends CotomyElementWrap = CotomyElementWrap>(selector?: string, type?: typeof CotomyElementWrap): T;
+    lastChild<T extends CotomyElementWrap = CotomyElementWrap>(selector?: string, type?: typeof CotomyElementWrap): T;
+    closest<T extends CotomyElementWrap = CotomyElementWrap>(selector: string, type?: typeof CotomyElementWrap): T;
+    find<T extends CotomyElementWrap = CotomyElementWrap>(selector: string, type?: typeof CotomyElementWrap): T[];
+    first<T extends CotomyElementWrap = CotomyElementWrap>(selector?: string, type?: typeof CotomyElementWrap): T;
+    prepend(prepend: CotomyElementWrap): this;
+    append(target: CotomyElementWrap): this;
+    appends(targets: CotomyElementWrap[]): this;
+    appendTo(target: CotomyElementWrap): this;
+    appendBefore(append: CotomyElementWrap): this;
+    appendAfter(append: CotomyElementWrap): this;
+    trigger(event: string, e?: Event | null): this;
+    on(event: string, handle: (e: Event) => void | Promise<void>): this;
+    once(event: string, handle: (e: Event) => void | Promise<void>): this;
+    off(event: string, handle: (e: Event) => void | Promise<void>): this;
+    click(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    dblclick(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    mouseover(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    mouseout(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    mousedown(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    mouseup(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    mousemove(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    mouseenter(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    mouseleave(handle?: ((e: MouseEvent) => void | Promise<void>) | null): this;
+    dragstart(handle?: ((e: DragEvent) => void | Promise<void>) | null): this;
+    dragend(handle?: ((e: DragEvent) => void | Promise<void>) | null): this;
+    dragover(handle?: ((e: DragEvent) => void | Promise<void>) | null): this;
+    dragenter(handle?: ((e: DragEvent) => void | Promise<void>) | null): this;
+    dragleave(handle?: ((e: DragEvent) => void | Promise<void>) | null): this;
+    drop(handle?: ((e: DragEvent) => void | Promise<void>) | null): this;
+    drag(handle?: ((e: DragEvent) => void | Promise<void>) | null): this;
+    removed(handle: ((e: Event) => void | Promise<void>)): this;
+    keydown(handle?: ((e: KeyboardEvent) => void | Promise<void>) | null): this;
+    keyup(handle?: ((e: KeyboardEvent) => void | Promise<void>) | null): this;
+    keypress(handle?: ((e: KeyboardEvent) => void | Promise<void>) | null): this;
+    change(handle?: ((e: Event) => void | Promise<void>) | null): this;
+    input(handle?: ((e: Event) => void | Promise<void>) | null): this;
+    private static _intersectionObserver;
+    static get intersectionObserver(): IntersectionObserver;
+    inview(handle?: ((e: Event) => void | Promise<void>) | null): this;
+    outview(handle?: ((e: Event) => void | Promise<void>) | null): this;
+    focus(handle?: ((e: FocusEvent) => void | Promise<void>) | null): this;
+    blur(handle?: ((e: FocusEvent) => void | Promise<void>) | null): this;
+    focusin(handle?: ((e: FocusEvent) => void | Promise<void>) | null): this;
+    focusout(handle?: ((e: FocusEvent) => void | Promise<void>) | null): this;
+    filedrop(handle: (files: File[]) => void | Promise<void>): this;
+    resize(handle?: ((e: Event) => void | Promise<void>) | null): this;
+    scroll(handle?: ((e: Event) => void | Promise<void>) | null): this;
+    changelayout(handle?: ((e: Event) => void | Promise<void>) | null): this;
+}
+export declare class CotomyMetaElement extends CotomyElementWrap {
+    static get(name: string): CotomyMetaElement;
+    get content(): string;
+}
+export declare class CotomyWindow {
+    private static _instance;
+    static get instance(): CotomyWindow;
+    private _body;
+    private _mutationObserver;
+    initialize(): void;
+    get initialized(): boolean;
+    get body(): CotomyElementWrap;
+    append(e: CotomyElementWrap): void;
+    moveNext(focused: CotomyElementWrap, shift?: boolean): void;
+    trigger(event: string): void;
+    load(handle: (e: Event) => void | Promise<void>): void;
+    ready(handle: ((e: Event) => void | Promise<void>)): void;
+    on(event: string, handle: (e: Event) => void | Promise<void>): void;
+    resize(handle?: ((event: Event) => void | Promise<void>) | null): void;
+    scroll(handle?: ((event: Event) => void | Promise<void>) | null): void;
+    changeLayout(handle?: ((event: Event) => void | Promise<void>) | null): void;
+    pageshow(handle?: ((event: PageTransitionEvent) => void | Promise<void>) | null): void;
+    get scrollTop(): number;
+    get scrollLeft(): number;
+    get width(): number;
+    get height(): number;
+    get documentWidth(): number;
+    get documentHeight(): number;
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "cotomy",
+  "version": "0.1.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": ["dist"],
+  "scripts": {
+    "build": "webpack --mode=production",
+    "dev": "webpack --watch",
+    "clean": "rm -rf dist",
+    "test": "echo \"(optional) add test runner like vitest or jest\"",
+    "prepare": "npm run build",
+    "release": "npm run clean && npm run build && npm version patch && npm publish",
+    "check": "tsc --noEmit",
+    "lint": "eslint src --ext .ts",
+    "format": "prettier --write src"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "description": "",
+  "devDependencies": {
+    "ts-loader": "^9.5.2",
+    "typescript": "^5.8.3",
+    "webpack": "^5.99.9",
+    "webpack-cli": "^6.0.1"
+  },
+  "dependencies": {
+    "cuid": "^3.0.0",
+    "dayjs": "^1.11.13",
+    "http-status-codes": "^2.3.0",
+    "locale-currency": "^0.0.4"
+  }
+}