@mulsense/xnew 0.1.0

package/dist/types/audio/synthesizer.d.ts

@@ -0,0 +1,68 @@
+type Envelope = {
+    amount: number;
+    ADSR: [number, number, number, number];
+};
+type LFO = {
+    amount: number;
+    type: OscillatorType;
+    rate: number;
+};
+type OscillatorOptions = {
+    type?: OscillatorType;
+    envelope?: Envelope | null;
+    LFO?: LFO | null;
+};
+type FilterOptions = {
+    type?: BiquadFilterType;
+    Q?: number;
+    cutoff?: number;
+    envelope?: Envelope | null;
+    LFO?: LFO | null;
+};
+type AmpOptions = {
+    envelope?: Envelope | null;
+    LFO?: LFO | null;
+};
+type ReverbOptions = {
+    time?: number;
+    mix?: number;
+};
+type DelayOptions = {
+    time?: number;
+    feedback?: number;
+    mix?: number;
+};
+type SynthProps = {
+    oscillator?: OscillatorOptions | null;
+    filter?: FilterOptions | null;
+    amp?: AmpOptions | null;
+};
+type SynthEffects = {
+    bmp?: number | null;
+    reverb?: ReverbOptions | null;
+    delay?: DelayOptions | null;
+};
+export declare function synthesizer(props?: SynthProps, effects?: SynthEffects): Synthesizer;
+declare class Synthesizer {
+    oscillator: OscillatorOptions;
+    filter: FilterOptions;
+    amp: AmpOptions;
+    bmp: number;
+    reverb: ReverbOptions;
+    delay: DelayOptions;
+    options: {
+        bmp: number;
+    };
+    static initialize(): void;
+    constructor({ oscillator, filter, amp }?: SynthProps, { bmp, reverb, delay }?: SynthEffects);
+    static keymap: {
+        [key: string]: number;
+    };
+    static notemap: {
+        [key: string]: number;
+    };
+    press(frequency: number | string, duration?: number | string | null, wait?: number): {
+        release: () => void;
+    };
+}
+export {};

package/dist/types/basics/Accordion.d.ts

@@ -0,0 +1,20 @@
+import { xnew } from '../core/xnew';
+export declare function AccordionFrame(frame: xnew.Unit, {}?: {}): {
+    toggle(): void;
+    open(): void;
+    close(): void;
+};
+export declare function AccordionButton(button: xnew.Unit, {}?: {}): void;
+export declare function AccordionBullet(bullet: xnew.Unit, { type }?: {
+    type?: string;
+}): {
+    transition(status: number): void;
+} | undefined;
+export declare function AccordionContent(content: xnew.Unit, { open, duration, easing }?: {
+    open?: boolean;
+    duration?: number;
+    easing?: string;
+}): {
+    readonly status: number;
+    transition(status: number): void;
+};

package/dist/types/basics/Block.d.ts

@@ -0,0 +1,24 @@
+import { xnew } from '../core/xnew';
+export declare function Modal(self: xnew.Unit, { duration, easing }?: {
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    open(): void;
+    close(): void;
+};
+export declare function Accordion(self: xnew.Unit, { open, duration, easing }?: {
+    open?: boolean | undefined;
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    open(): void;
+    close(): void;
+    toggle(): void;
+};
+export declare function Tab(self: xnew.Unit, { duration, easing }?: {
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    assign(name: string, component: Function): void;
+    select(name: string): void;
+};

package/dist/types/basics/Bullet.d.ts

@@ -0,0 +1,7 @@
+import { xnew } from '../core/xnew';
+export declare function BulletArrow(self: xnew.Unit, { rotate, color }?: {
+    rotate?: number;
+    color?: string;
+}): {
+    rotate(rotate: number, transition?: number, easing?: string): void;
+};

package/dist/types/basics/ControlPanel.d.ts

@@ -0,0 +1,7 @@
+import { xnew } from '../core/xnew';
+export declare function ControlPanel(self: xnew.Unit, {}?: {}): {
+    group(name: string): void;
+    button(name: string, component: Function, props?: any): void;
+    range(name: string, component: Function, props?: any): void;
+    select(name: string): void;
+};

package/dist/types/basics/Controller.d.ts

@@ -0,0 +1,28 @@
+import { xnew } from '../core/xnew';
+export declare function VirtualStick(self: xnew.Unit, { size, fill, fillOpacity, stroke, strokeOpacity, strokeWidth, strokeLinejoin }?: {
+    size?: number | undefined;
+    fill?: string | undefined;
+    fillOpacity?: number | undefined;
+    stroke?: string | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeLinejoin?: string | undefined;
+}): void;
+export declare function VirtualDPad(self: xnew.Unit, { size, fill, fillOpacity, stroke, strokeOpacity, strokeWidth, strokeLinejoin }?: {
+    size?: number | undefined;
+    fill?: string | undefined;
+    fillOpacity?: number | undefined;
+    stroke?: string | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeLinejoin?: string | undefined;
+}): void;
+export declare function VirtualButton(self: xnew.Unit, { size, fill, fillOpacity, stroke, strokeOpacity, strokeWidth, strokeLinejoin }?: {
+    size?: number | undefined;
+    fill?: string | undefined;
+    fillOpacity?: number | undefined;
+    stroke?: string | undefined;
+    strokeOpacity?: number | undefined;
+    strokeWidth?: number | undefined;
+    strokeLinejoin?: string | undefined;
+}): void;

package/dist/types/basics/Event.d.ts

@@ -0,0 +1,3 @@
+import { xnew } from '../core/xnew';
+export declare function ResizeEvent(self: any): void;
+export declare function UserEvent(self: xnew.Unit): void;

package/dist/types/basics/File.d.ts

@@ -0,0 +1 @@
+export declare function File(data: string, filename: string, mimeType?: string): void;

package/dist/types/basics/Input.d.ts

@@ -0,0 +1,2 @@
+import { xnew } from '../core/xnew';
+export declare function InputFrame(frame: xnew.Unit, {}?: {}): void;

package/dist/types/basics/Modal.d.ts

@@ -0,0 +1,11 @@
+import { xnew } from '../core/xnew';
+export declare function ModalFrame(frame: xnew.Unit, {}?: {}): {
+    close(): void;
+};
+export declare function ModalContent(content: xnew.Unit, { duration, easing, background }?: {
+    duration?: number;
+    easing?: string;
+    background?: string;
+}): {
+    transition(status: number): void;
+};

package/dist/types/basics/Navigation.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/basics/Panel.d.ts

@@ -0,0 +1,6 @@
+import { xnew } from '../core/xnew';
+export declare function PanelFrame(frame: xnew.Unit): void;
+export declare function PanelGroup(group: xnew.Unit, { name, open }?: {
+    name?: string;
+    open?: boolean;
+}): void;

package/dist/types/basics/Popup.d.ts

@@ -0,0 +1,8 @@
+import { xnew } from '../core/xnew';
+export declare function Modal(self: xnew.Unit, { duration, easing }?: {
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    open(): void;
+    close(): void;
+};

package/dist/types/basics/ResizeEvent.d.ts

@@ -0,0 +1 @@
+export declare function ResizeEvent(self: any): void;

package/dist/types/basics/Screen.d.ts

@@ -0,0 +1,13 @@
+import { xnew } from '../core/xnew';
+export declare function Screen(screen: xnew.Unit, { width, height, fit }?: {
+    width?: number | undefined;
+    height?: number | undefined;
+    fit?: string | undefined;
+}): {
+    readonly canvas: any;
+    resize(width: number, height: number): void;
+    readonly scale: {
+        x: number;
+        y: number;
+    };
+};

package/dist/types/basics/SubWIndow.d.ts

@@ -0,0 +1,6 @@
+import { xnew } from '../core/xnew';
+export declare function DragFrame(frame: xnew.Unit, { x, y }?: {
+    x?: number;
+    y?: number;
+}): void;
+export declare function DragTarget(target: xnew.Unit, {}?: {}): void;

package/dist/types/basics/Tab.d.ts

@@ -0,0 +1,12 @@
+import { xnew } from '../core/xnew';
+export declare function TabFrame(frame: xnew.Unit, { select }?: {
+    select?: number | undefined;
+}): void;
+export declare function TabButton(button: xnew.Unit, {}?: {}): {
+    select(): void;
+    deselect(): void;
+};
+export declare function TabContent(self: xnew.Unit, {}?: {}): {
+    select(): void;
+    deselect(): void;
+};

package/dist/types/basics/TabView.d.ts

@@ -0,0 +1,18 @@
+import { xnew } from '../core/xnew';
+export declare function TabFrame(frame: xnew.Unit, { select, duration, easing }?: {
+    select?: number | undefined;
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    tabs: import("../core/unit").Unit[];
+    contents: import("../core/unit").Unit[];
+    select(index: number): void;
+};
+export declare function TabButton(self: xnew.Unit): {
+    select(): void;
+    deselect(): void;
+};
+export declare function TabContent(self: xnew.Unit): {
+    select(): void;
+    deselect(): void;
+};

package/dist/types/basics/Tabs.d.ts

@@ -0,0 +1,8 @@
+import { xnew } from '../core/xnew';
+export declare function Tabs(self: xnew.Unit, { duration, easing }?: {
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    content(name: string, component: Function, props?: any): void;
+    select(name: string): void;
+};

package/dist/types/basics/Transition.d.ts

@@ -0,0 +1,17 @@
+import { xnew } from '../core/xnew';
+export declare function Modal(self: xnew.Unit, { duration, easing }?: {
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    open(): void;
+    close(): void;
+};
+export declare function Accordion(self: xnew.Unit, { open, duration, easing }: {
+    open?: boolean | undefined;
+    duration?: number | undefined;
+    easing?: string | undefined;
+}): {
+    open(): void;
+    close(): void;
+    toggle(): void;
+};

package/dist/types/basics/UserEvent.d.ts

@@ -0,0 +1,2 @@
+import { xnew } from '../core/xnew';
+export declare function UserEvent(self: xnew.Unit): void;

package/dist/types/basics/WorkSpace.d.ts

@@ -0,0 +1,16 @@
+import { xnew } from '../core/xnew';
+interface Position {
+    x: number | null | undefined;
+    y: number | null | undefined;
+}
+interface Transform {
+    position: Position | null | undefined;
+    rotation: number | null | undefined;
+    scale: number | null | undefined;
+}
+export declare function WorkSpace(self: xnew.Unit, attributes?: any): {
+    readonly transform: Transform;
+    move(transform: Transform): void;
+    update(): void;
+};
+export {};

package/dist/types/core/map.d.ts

@@ -0,0 +1,34 @@
+declare class MapEx<Key, Value> {
+    protected map: Map<Key, Value>;
+    get size(): number;
+    forEach(callback: (value: Value, key: Key, map: Map<Key, Value>) => any): void;
+    clear(): void;
+}
+export declare class MapSet<Key, Value> extends MapEx<Key, Set<Value>> {
+    has(key: Key, value?: Value): boolean;
+    get(key: Key): Set<Value> | undefined;
+    keys(): IterableIterator<Key>;
+    add(key: Key, value: Value): MapSet<Key, Value>;
+    delete(key: Key, value?: Value): boolean;
+}
+export declare class MapMap<Key1, Key2, Value> extends MapEx<Key1, Map<Key2, Value>> {
+    has(key1: Key1, key2?: Key2): boolean;
+    set(key1: Key1, key2: Key2, value: Value): MapMap<Key1, Key2, Value>;
+    get(key1: Key1): Map<Key2, Value> | undefined;
+    get(key1: Key1, key2: Key2): Value | undefined;
+    keys(): IterableIterator<Key1>;
+    keys(key1: Key1): IterableIterator<Key2>;
+    delete(key1: Key1, key2?: Key2): boolean;
+}
+export declare class MapMapMap<Key1, Key2, Key3, Value> extends MapEx<Key1, MapMap<Key2, Key3, Value>> {
+    has(key1: Key1, key2?: Key2, key3?: Key3): boolean;
+    set(key1: Key1, key2: Key2, key3: Key3, value: Value): MapMapMap<Key1, Key2, Key3, Value>;
+    get(key1: Key1): MapMap<Key2, Key3, Value> | undefined;
+    get(key1: Key1, key2: Key2): Map<Key3, Value> | undefined;
+    get(key1: Key1, key2: Key2, key3: Key3): Value | undefined;
+    keys(): IterableIterator<Key1>;
+    keys(key1: Key1): IterableIterator<Key2>;
+    keys(key1: Key1, key2: Key2): IterableIterator<Key3>;
+    delete(key1: Key1, key2?: Key2, key3?: Key3): boolean;
+}
+export {};

package/dist/types/core/time.d.ts

@@ -0,0 +1,27 @@
+export declare class Ticker {
+    static animation: number | null;
+    static callbacks: Set<Function>;
+    static previous: number;
+    static ticker(): void;
+    static set(callback: (time: number) => void): void;
+    static clear(callback: (time: number) => void): void;
+}
+export declare class Timer {
+    private timeout;
+    private transition;
+    private delay;
+    private loop;
+    private id;
+    private time;
+    private offset;
+    private status;
+    private visibilitychange?;
+    private ticker;
+    constructor(timeout: Function, transition: Function | null, delay: number, loop?: boolean);
+    clear(): void;
+    elapsed(): number;
+    start(): void;
+    stop(): void;
+    private _start;
+    private _stop;
+}

package/dist/types/core/unit.d.ts

@@ -0,0 +1,105 @@
+import { MapSet, MapMapMap } from './map';
+declare const LIFECYCLE_EVENTS: readonly ["start", "update", "stop", "finalize"];
+type LifecycleEvent = typeof LIFECYCLE_EVENTS[number];
+interface Context {
+    stack: Context | null;
+    key: string;
+    value: any;
+}
+interface Snapshot {
+    unit: Unit | null;
+    context: Context | null;
+    element: HTMLElement | SVGElement | null;
+}
+interface Capture {
+    checker: (unit: Unit) => boolean;
+    execute: (unit: Unit) => any;
+}
+interface UnitInternal {
+    root: Unit;
+    parent: Unit | null;
+    children: Unit[];
+    target: Object | null;
+    props?: Object;
+    nextNest: {
+        element: HTMLElement | SVGElement;
+        position: InsertPosition;
+    };
+    baseElement: HTMLElement | SVGElement;
+    currentElement: HTMLElement | SVGElement;
+    baseContext: Context | null;
+    baseComponent: Function | null;
+    components: Function[];
+    captures: Capture[];
+    state: string;
+    tostart: boolean;
+    upcount: number;
+    resolved: boolean;
+    defines: Record<string, any>;
+    system: Record<LifecycleEvent, Function[]>;
+}
+export declare class Unit {
+    [key: string]: any;
+    _: UnitInternal;
+    static roots: Unit[];
+    constructor(target: Object | null, component?: Function | string, props?: Object);
+    get element(): HTMLElement | SVGElement;
+    start(): void;
+    stop(): void;
+    finalize(): void;
+    reboot(): void;
+    get components(): Function[];
+    on(type: string, listener: Function, options?: boolean | AddEventListenerOptions): Unit;
+    off(type?: string, listener?: Function): Unit;
+    emit(type: string, ...args: any[]): void;
+    static initialize(unit: Unit): void;
+    static finalize(unit: Unit): void;
+    static nest(unit: Unit, tag: string): HTMLElement | SVGElement | null;
+    static extend(unit: Unit, component: Function, props?: Object): void;
+    static start(unit: Unit, time: number): void;
+    static stop(unit: Unit): void;
+    static update(unit: Unit, time: number): void;
+    static ticker(time: number): void;
+    static reset(): void;
+}
+export declare class UnitScope {
+    static current: Unit | null;
+    static contexts: Map<Unit | null, Context>;
+    static initialize(unit: Unit | null, context: Context | null): void;
+    static finalize(unit: Unit): void;
+    static set(unit: Unit, context: Context): void;
+    static get(unit: Unit | null): Context | null;
+    static execute(snapshot: Snapshot | null, func: Function, ...args: any[]): any;
+    static snapshot(unit?: Unit | null): Snapshot | null;
+    static stack(unit: Unit, key: string, value: any): void;
+    static trace(unit: Unit, key: string): any;
+}
+export declare class UnitComponent {
+    static components: MapSet<Unit, Function>;
+    static units: MapSet<Function, Unit>;
+    static finalize(unit: Unit): void;
+    static add(unit: Unit, component: Function): void;
+    static find(component: Function): Unit[];
+}
+export declare class UnitEvent {
+    static units: MapSet<string, Unit>;
+    static listeners: MapMapMap<Unit, string, Function, [HTMLElement | SVGElement, (...args: any[]) => void]>;
+    static on(unit: Unit, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
+    static off(unit: Unit, type?: string, listener?: Function): void;
+    static emit(unit: Unit, type: string, ...args: any[]): void;
+    static sublisteners: MapMapMap<Unit | null, string, Function, [HTMLElement | SVGElement | Window | Document, (...args: any[]) => void]>;
+    static subon(unit: Unit | null, target: HTMLElement | SVGElement | Window | Document, type: string, listener: Function, options?: boolean | AddEventListenerOptions): void;
+    static suboff(unit: Unit | null, target: HTMLElement | SVGElement | Window | Document | null, type?: string, listener?: Function): void;
+}
+export declare class UnitPromise {
+    private promise;
+    constructor(executor: (resolve: (value: any) => void, reject: (reason?: any) => void) => void);
+    then(callback: Function): UnitPromise;
+    catch(callback: Function): UnitPromise;
+    finally(callback: Function): UnitPromise;
+    static promises: MapSet<Unit, UnitPromise>;
+    static get(unit: Unit): Promise<any[]>;
+    static finalize(unit: Unit): void;
+    static execute(unit: Unit, promise?: Promise<any>): UnitPromise;
+}
+export {};

package/dist/types/core/util.d.ts

@@ -0,0 +1 @@
+export declare function isPlainObject(object: any): boolean;

package/dist/types/core/xnew.d.ts

@@ -0,0 +1,9 @@
+import { Unit } from './unit';
+export declare namespace xnew {
+    type Unit = InstanceType<typeof Unit>;
+}
+export interface xnewtype {
+    (...args: any[]): Unit;
+    [key: string]: any;
+}
+export declare const xnew: xnewtype;

package/dist/types/index.d.ts

@@ -0,0 +1,47 @@
+import { ResizeEvent } from './basics/ResizeEvent';
+import { UserEvent } from './basics/UserEvent';
+import { Screen } from './basics/Screen';
+import { InputFrame } from './basics/Input';
+import { ModalFrame, ModalContent } from './basics/Modal';
+import { TabFrame, TabButton, TabContent } from './basics/Tab';
+import { AccordionFrame, AccordionButton, AccordionBullet, AccordionContent } from './basics/Accordion';
+import { PanelFrame, PanelGroup } from './basics/Panel';
+import { DragFrame, DragTarget } from './basics/SubWIndow';
+import { VirtualStick, VirtualDPad, VirtualButton } from './basics/Controller';
+import { Unit } from './core/unit';
+import { xnewtype as basetype } from './core/xnew';
+import { synthesizer } from './audio/synthesizer';
+declare const basics: {
+    Screen: typeof Screen;
+    UserEvent: typeof UserEvent;
+    ResizeEvent: typeof ResizeEvent;
+    ModalFrame: typeof ModalFrame;
+    ModalContent: typeof ModalContent;
+    AccordionFrame: typeof AccordionFrame;
+    AccordionButton: typeof AccordionButton;
+    AccordionBullet: typeof AccordionBullet;
+    AccordionContent: typeof AccordionContent;
+    TabFrame: typeof TabFrame;
+    TabButton: typeof TabButton;
+    TabContent: typeof TabContent;
+    PanelFrame: typeof PanelFrame;
+    PanelGroup: typeof PanelGroup;
+    InputFrame: typeof InputFrame;
+    DragFrame: typeof DragFrame;
+    DragTarget: typeof DragTarget;
+    VirtualStick: typeof VirtualStick;
+    VirtualDPad: typeof VirtualDPad;
+    VirtualButton: typeof VirtualButton;
+};
+declare const audio: {
+    synthesizer: typeof synthesizer;
+};
+interface xnewtype extends basetype {
+    basics: typeof basics;
+    audio: typeof audio;
+}
+declare namespace xnew {
+    type Unit = InstanceType<typeof Unit>;
+}
+declare const xnew: xnewtype;
+export default xnew;

package/dist/types/xnew.d.ts

@@ -0,0 +1,8 @@
+import { Unit } from './core/unit';
+export interface xnewtype extends Function {
+    [key: string]: any;
+}
+export declare namespace xnew {
+    type Unit = InstanceType<typeof Unit>;
+}
+export declare const xnew: xnewtype;