amateras 0.5.0 → 0.7.0

package/src/core.ts

@@ -1,114 +0,0 @@
-import './global';
-import './node';
-import { Signal } from "#structure/Signal";
-import { $Element, type $Event } from "#node/$Element";
-import { $Node, type $NodeContentResolver, type $NodeContentTypes } from '#node/$Node';
-import { _instanceof, isString, isFunction, _Object_assign, isObject, isNull, _Object_entries, _Object_defineProperty, forEach, isNumber, _Array_from, isUndefined, _bind, _null } from '#lib/native';
-import { $HTMLElement } from '#node/$HTMLElement';
-import { _document } from '#lib/env';
-import { toArray } from '#lib/toArray';
-
-const nodeNameMap: {[key: string]: Constructor<$Node>} = {}
-const _stylesheet = new CSSStyleSheet();
-
-export function $<F extends (...args: any[]) => $NodeContentResolver<$Node>, N extends number>(number: N, fn: F, ...args: Parameters<F>): Repeat<ReturnType<F>, N>;
-export function $<F extends (...args: any[]) => $NodeContentResolver<$Node>>(fn: F, ...args: Parameters<F>): ReturnType<F>;
-export function $<T extends Constructor<$Node>, P extends ConstructorParameters<T>, N extends number>(number: N, construct: T, ...args: P): Repeat<InstanceType<T>, N>;
-export function $<T extends Constructor<$Node>, P extends ConstructorParameters<T>>(construct: T, ...args: P): InstanceType<T>;
-export function $(nodes: NodeListOf<Node | ChildNode>): $Node[];
-export function $<N extends $Node>($node: N, ...args: any[]): N;
-export function $<N extends $Node>($node: N | null | undefined, ...args: any[]): N | null | undefined;
-export function $<H extends HTMLElement>(element: H, ...args: any[]): $HTMLElement<H>;
-export function $<H extends HTMLElement>(element: H | null | undefined, ...args: any[]): $HTMLElement<H> | null | undefined;
-export function $<E extends Element>(element: E, ...args: any[]): $Element<E>;
-export function $<E extends Element>(element: E | null | undefined, ...args: any[]): $Element<E> | null | undefined;
-export function $<N extends Node | EventTarget>(node: N, ...args: any[]): $Node;
-export function $<N extends Node | EventTarget>(node: N | null | undefined, ...args: any[]): $Node | null | undefined;
-export function $<K extends TemplateStringsArray>(string: K, ...values: any[]): $NodeContentTypes[];
-export function $<K extends keyof HTMLElementTagNameMap, N extends number>(number: N, tagname: K): Repeat<$HTMLElement<HTMLElementTagNameMap[K]>, N>;
-export function $<K extends keyof HTMLElementTagNameMap>(tagname: K): $HTMLElement<HTMLElementTagNameMap[K]>;
-export function $<Ev extends $Event<$Element, Event>>(event: Ev): Ev['currentTarget']['$'];
-export function $<N extends number>(number: N, tagname: string): Repeat<$HTMLElement<HTMLElement>, N>;
-export function $(tagname: string): $HTMLElement<HTMLElement>
-export function $(resolver: string | number | null | undefined | Element | HTMLElement | $Node | Function | TemplateStringsArray | Event | NodeListOf<Node | ChildNode>, ...args: any[]) {
-    if (isNull(resolver) || isUndefined(resolver)) return null;
-    if (_instanceof(resolver, $Node)) return resolver;
-    if (isString(resolver) && nodeNameMap[resolver]) return new nodeNameMap[resolver](...args);
-    if (isFunction(resolver)) 
-        if (resolver.prototype?.constructor) return new resolver.prototype.constructor(...args); 
-        else return resolver(...args);
-    if (resolver instanceof Array) {
-        const iterate = args.values();
-        return resolver.map(str => [str ?? undefined, iterate.next().value]).flat().filter(item => item);
-    }
-    if (_instanceof(resolver, Node) && _instanceof(resolver.$, $Node)) return resolver.$;
-    if (_instanceof(resolver, Event)) return $(resolver.currentTarget as Element);
-    if (isNumber(resolver)) return _Array_from({length: resolver}).map(_ => $(args[0], ...args.slice(1)));
-    if (_instanceof(resolver, HTMLElement)) return new $HTMLElement(resolver);
-    if (_instanceof(resolver, Element)) return new $Element(resolver);
-    if (_instanceof(resolver, Node)) return new $Node(resolver as any);
-    if (_instanceof(resolver, NodeList)) return _Array_from(resolver).map($)
-    return new $HTMLElement(resolver);
-}
-
-export namespace $ {
-    export const stylesheet = _stylesheet;
-    _document.adoptedStyleSheets.push(_stylesheet);
-    export const style = _bind(_stylesheet.insertRule, _stylesheet);
-    type SignalProcess<T> = T extends Array<any> ? {} : T extends object ? { [key in keyof T as `${string & key}$`]: SignalFunction<T[key]> } : {};
-    export type SignalFunction<T> = {signal: Signal<T>, set: (newValue: T | ((oldValue: T) => T)) => SignalFunction<T>} & (() => T) & SignalProcess<T>;
-    export const signal = <T>(value: T): SignalFunction<T> => {
-        const signal = new Signal<T>(value);
-        const signalFn = function () { return signal.value(); }
-        _Object_assign(signalFn, {
-            signal,
-            set(newValue: T) { return signal.value(newValue), signalFn; }
-        })
-        if (isObject(value) && !isNull(value)) {
-            for (const [key, val] of _Object_entries(value)) {
-                const val$ = $.signal(val);
-                val$.signal.subscribe(newValue => { value[key as keyof typeof value] = newValue; signal.emit() });
-                _Object_defineProperty(signalFn, `${key}$`, {value: val$});
-            }
-        }
-        return signalFn as unknown as SignalFunction<T>
-    }
-
-    export type ComputeFunction<T> = ({(): T}) & { signal: Signal<T> };
-    export const compute = <T>(process: () => T): ComputeFunction<T> => {
-        let subscribed = false;
-        const signalFn: SignalFunction<any> = signal(_null);
-        const computeFn = () => {
-            if (!subscribed) return signalFn.set(subscribe())();
-            else return signalFn.set(process())();
-        }
-        const subscribe = () => {
-            const signalHandler = (signal: Signal<any>) => { 
-                signal.subscribe(() => signalFn.set(process())) 
-            }
-            Signal.listeners.add(signalHandler);
-            const result = process();
-            Signal.listeners.delete(signalHandler);
-            subscribed = true;
-            return result;
-        }
-        _Object_assign(computeFn, { signal: signalFn.signal });
-        return computeFn as ComputeFunction<T>
-    }
-
-    type assign = {
-        (resolver: [nodeName: string, $node: Constructor<$Node>][]): $;
-        (nodeName: string, $node: Constructor<$Node>): $;
-    }
-    export const assign: assign = (resolver: string | [nodeName: string, $node: Constructor<$Node>][], $node?: Constructor<$Node>) => {
-        if (isString(resolver)) $node && (nodeNameMap[resolver] = $node);
-        else forEach(resolver, ([nodeName, $node]) => nodeNameMap[nodeName] = $node);
-        return $;
-    }
-
-    export const span = (content: string) => $('span').content(content);
-}
-
-export type $ = typeof $;
-globalThis.$ = $;
-_Object_assign($, {toArray})

package/src/index.ts

@@ -1,3 +0,0 @@
-import '#core';
-export * from '#core';
-export * from '#structure/Signal';

package/src/lib/assign.ts

@@ -1,38 +0,0 @@
-import { Signal } from "../structure/Signal";
-import { _instanceof, _Object_defineProperty, forEach, isUndefined } from "./native";
-
-export const assign = (target: any, {set, get, fn}: { 
-    set?: string[], 
-    get?: string[], 
-    fn?: string[]
-}) => {
-    const [GET, SET, FN] = ['get', 'set', 'fn'] as const;
-    const filterAndMap = (type: 'get' | 'set' | 'fn', arr: string[] | undefined) => arr?.map(prop => [type, prop]) ?? []
-    const list = [...filterAndMap(GET, get), ...filterAndMap(SET, set), ...filterAndMap(FN, fn)] as [string, string][];
-    forEach(list, ([type, prop]) => 
-        _Object_defineProperty(target.prototype, prop, {
-            ...(type === GET ? {
-                get() { return this.node[prop as any] }
-            } : {
-                writable: true,
-                ...(type === SET ? {
-                    // set
-                    value(this, args: any) {
-                        if (!arguments.length) return this.node[prop];
-                        let set = (value: any) => !isUndefined(value) && (this.node[prop] = value);
-                        if (_instanceof(args, Signal)) args = args.subscribe(set).value();
-                        set(args)
-                        return this;
-                    }
-                } : {
-                    // fn
-                    value(this, ...args : any[]) {
-                        let result = this.node[prop](...args)
-                        return isUndefined(result) ? this : result;
-                    }
-                })
-            }),
-
-        })
-    )
-}

package/src/lib/assignHelper.ts

@@ -1,18 +0,0 @@
-import type { $Node } from "#node/$Node";
-import { assign } from "./assign";
-import { _Object_entries, _Object_getOwnPropertyDescriptors, forEach } from "./native";
-
-export const assignHelper = (object: Constructor<EventTarget>, target: Constructor<$Node>, tagname?: string) => {
-    const [set, get, fn] = [[], [], []] as [string[], string[], string[]]
-    // assign native object properties to target
-    forEach(_Object_entries(_Object_getOwnPropertyDescriptors(object.prototype)), ([prop, value]) => {
-        if (!(prop in target.prototype)) {
-            if (value.get && !value.set) get.push(prop);
-            else if (value.value) fn.push(prop);
-            else if (value.get && value.set) set.push(prop);
-        }
-    })
-    assign(target, {set, get, fn})
-    // register tagname
-    if (tagname) $.assign(tagname, target)
-}

package/src/lib/chain.ts

@@ -1,13 +0,0 @@
-import { isUndefined } from "./native";
-
-export const chain: chain = <T, R, V>(_this: T, args: IArguments | null, get: (() => R) | null, value: V, set: (value: Exclude<V, undefined>) => any) => 
-    args && get && !args.length 
-    ? get()
-    : isUndefined(value) 
-        ? _this 
-        : (set(value as any), _this);
-
-interface chain {
-    <T, V>(_this: T, args: null, get: null, value: V, set: (value: Exclude<V, undefined>) => any): T
-    <T, R, V>(_this: T, args: IArguments, get: (() => R), value: V, set: (value: Exclude<V, undefined>) => any): T | R
-}

package/src/lib/debounce.ts

@@ -1,7 +0,0 @@
-export const debounce = () => {
-    let timer: ReturnType<typeof setTimeout>;
-    return (fn: Function, timeout: number) => {
-        if (timer) clearTimeout(timer);
-        timer = setTimeout(fn, timeout);
-    }
-}

package/src/lib/env.ts

@@ -1,2 +0,0 @@
-// window and document
-export const _document = document;

package/src/lib/native.ts

@@ -1,40 +0,0 @@
-// Value
-export const _null = null;
-export const _undefined = undefined;
-// Object
-export const _Object_fromEntries = Object.fromEntries;
-export const _Object_entries = Object.entries;
-export const _Object_assign = Object.assign;
-export const _Object_values = Object.values;
-export const _Object_defineProperty = Object.defineProperty;
-export const _Object_getOwnPropertyDescriptors = Object.getOwnPropertyDescriptors;
-// Array
-export const _Array_from = Array.from;
-export const forEach: forEach = <T>(arr: any, fn: any, thisArgs?: any) => arr.forEach(fn, thisArgs);
-// type check
-export const _typeof = (target: any, type: 'string' | 'number' | 'object' | 'boolean' | 'function' | 'bigint' | 'symbol' | 'undefined') => typeof target === type;
-export const equal = <T, V extends T>(target: T, ...args: V[]): target is V => !!args.find(a => a === target);
-export const isString = (target: any): target is string => _typeof(target, 'string');
-export const isBoolean = (target: any): target is boolean => _typeof(target, 'boolean');
-export const isNumber = (target: any): target is number => _typeof(target, 'number');
-export const isObject = (target: any): target is object => _typeof(target, 'object');
-export const isFunction = (target: any): target is Function => _typeof(target, 'function');
-export const isUndefined = (target: any): target is undefined => target === undefined;
-export const isNull = (target: any): target is null => target === _null;
-export const isArray = Array.isArray;
-export const _instanceof = <T extends (abstract new (...args: any[]) => any)[]>(target: any, ...instance: T): target is InstanceType<T[number]> => !!instance.find(i => target instanceof i);
-// JSON
-export const _JSON_stringify = JSON.stringify;
-export const _JSON_parse = JSON.parse;
-// String
-export const startsWith = (target: string, ...str: string[]) => !!str.find(s => target.startsWith(s));
-// Function
-export const _bind = (target: Function, obj: Object) => target.bind(obj);
-interface forEach {
-    <T>(arr: Array<T>, fn: (value: T, index: number, array: Array<T>) => any, thisArgs?: any): void;
-    <T>(set: Set<T>, fn: (value: T, index: number, set: Set<T>) => any, thisArgs?: any): void;
-    <K, V>(set: Map<K, V>, fn: (value: V, key: K, index: number, map: Map<K, V>) => any, thisArgs?: any): void;
-    <N extends Node>(set: NodeListOf<N>, fn: (value: N, index: number, parent: NodeListOf<N>) => any, thisArgs?: any): void;
-}
-// Promise
-export const _Promise = Promise;

package/src/lib/randomId.ts

@@ -1,9 +0,0 @@
-import { _Array_from } from "./native";
-
-const LOWER = 'abcdefghijklmnopqrstuvwxyz';
-const UPPER = LOWER.toUpperCase();
-export const randomId = (options?: {length?: number, lettercase?: 'any' | 'lower' | 'upper'}): string => { 
-    options = {length: 5, lettercase: 'any', ...options};
-    const char = options.lettercase === 'any' ? LOWER + UPPER : options.lettercase === 'lower' ? LOWER : UPPER;
-    return _Array_from({length: options.length as number}, (_, i) => char[Math.round(Math.random() * char.length)]).join(''); 
-}

package/src/lib/sleep.ts

@@ -1,3 +0,0 @@
-import { _Promise } from "./native";
-
-export const sleep = async (ms: number) => new _Promise(resolve => setTimeout(resolve, ms));

package/src/lib/toArray.ts

@@ -1,9 +0,0 @@
-import { _instanceof, _Object_assign } from "./native";
-
-export const toArray = <T>(item: OrArray<T>): T[] => _instanceof(item, Array) ? item : [item];
-
-declare module '#core' {
-    export namespace $ {
-        export function toArray<T>(item: OrArray<T>): T[];
-    }
-}

package/src/lib/trycatch.ts

@@ -1,17 +0,0 @@
-import { _instanceof, _JSON_stringify, _null, _Object_assign } from "./native";
-
-export const trycatch = <D>(callback: () => D): Result<D, Error> => {
-    try {
-        return [callback(), _null];
-    } catch (err) {
-        return [_null, _instanceof(err, Error) ? err : new Error(_JSON_stringify(err))];
-    }
-}
-
-_Object_assign($, {trycatch})
-
-declare module '#core' {
-    export namespace $ {
-        export function trycatch <D>(callback: () => D): Result<D, Error>
-    }
-}

package/src/node.ts

@@ -1,10 +0,0 @@
-import { $HTMLElement } from '#node/$HTMLElement';
-import { assignHelper } from '#lib/assignHelper';
-import { $Element } from '#node/$Element';
-import { $Node, $Text } from '#node/$Node';
-
-assignHelper(EventTarget, $Node);
-assignHelper(Node, $Node);
-assignHelper(Text, $Text);
-assignHelper(Element, $Element);
-assignHelper(HTMLElement, $HTMLElement);