aoye 0.0.1

package/dist/shared/util.d.ts

@@ -0,0 +1,22 @@
+type QueueItem<T> = {
+    v: T;
+    prev?: QueueItem<T>;
+    next?: QueueItem<T>;
+};
+export declare class Queue<T> {
+    _first?: QueueItem<T>;
+    get first(): T;
+    _last?: QueueItem<T>;
+    get last(): T;
+    len: number;
+    push(it: T): void;
+    shift(): T;
+}
+export declare function isNum(char: string): char is "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
+export declare const genKey: (v: string | number) => number;
+export declare class SortMap<T> {
+    data: Record<string | symbol, T[]>;
+    clear(): void;
+    add(key: string | symbol, value: T): void;
+}
+export {};

package/dist/signal/src/__test__/dep-str.d.ts

@@ -0,0 +1,8 @@
+export declare class DepStr {
+    signals: Record<string, any>;
+    constructor(signals: Record<string, any>);
+    /**
+     * a -> b -> c
+     */
+    dep(str: string): void;
+}

package/dist/signal/src/__test__/scope.test.d.ts

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

package/dist/signal/src/__test__/siganl.test.d.ts

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

package/dist/signal/src/__test__/watch.test.d.ts

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

package/dist/signal/src/dfs.d.ts

@@ -0,0 +1,14 @@
+import type { Signal } from './signal';
+import { Line } from './line';
+import { DFSCtxBegin, DFSCtxCompete, Vertex } from './type';
+declare const DefaultDFSOpt: {
+    isUp: boolean;
+    begin: (dfsCtx: DFSCtxBegin) => any;
+    complete: (dfsCtx: DFSCtxCompete) => any;
+    breakStack: Line[];
+    breakLine: Line;
+    breakNode: Signal;
+};
+type DFSOpt = typeof DefaultDFSOpt;
+export declare function dfs(root: Vertex, opt?: Partial<DFSOpt>): void;
+export {};

package/dist/signal/src/global.d.ts

@@ -0,0 +1,21 @@
+import { SortMap } from '../../shared/util';
+import type { Signal } from './signal';
+export declare const G: {
+    /** 原子 signal 更新次数 */
+    version: number;
+    id: number;
+    /** scope 销毁任务序号 */
+    scopeDisposeI: number;
+};
+export declare const dirtyLeafs: SortMap<Signal<any>>;
+export declare enum State {
+    Clean = 0,
+    /** 仅用于 scope 节点是否 abort */
+    ScopeAbort = 32,
+    OutLink = 16,
+    Unknown = 8,
+    Dirty = 4,
+    Check = 2,
+    ScopeReady = 1
+}
+export declare const DirtyState: number;

package/dist/signal/src/index.d.ts

@@ -0,0 +1,27 @@
+import { Scheduler } from './schedule';
+import { Signal } from './signal';
+import { Getter, Mix } from './type';
+export { Scheduler, scheduler } from './schedule';
+export * from './type';
+declare const DefaultCustomSignalOpt: {
+    scheduler: Scheduler;
+    isScope: boolean;
+};
+export type CustomSignalOpt = Partial<typeof DefaultCustomSignalOpt>;
+export type CreateSignal = {
+    <T extends (...args: any[]) => any>(get: T, opt?: CustomSignalOpt): Mix<ReturnType<T>>;
+    <T = any>(value: T, opt?: CustomSignalOpt): Mix<T>;
+};
+export declare const $: CreateSignal;
+export declare const watch: (values: Getter[], watcher: Function, opt?: CustomSignalOpt) => Mix<void>;
+export declare const scope: (fn: () => void) => {
+    (): void;
+    ins: Signal<void>;
+};
+/**
+ * 数据变化时，自定义 触发订阅函数的时机
+ * @param {CustomSignalOpt} opt 配置如下:
+ * @prop scheduler: (runIfDirty, effect) => void 执行 runIfDirty 定制触发 effect 时机
+ * @prop scope: 用于统一释放 effect link 的作用域 默认是 defaultScope 可以全局获取
+ */
+export declare const customSignal: (opt?: CustomSignalOpt) => CreateSignal;

package/dist/signal/src/line.d.ts

@@ -0,0 +1,31 @@
+import type { Signal } from './signal';
+import { Vertex } from './type';
+export declare class Line {
+    static link(v1: Signal, v2: Signal): void;
+    static unlink(line: Line): void;
+    static unlinkRec(line: Line): void;
+    static unlinkEmit(line: Line): void;
+    /** 上游节点 连 link */
+    static emit_line(upstream: Vertex, line: Line): void;
+    /** 下游节点 连 link */
+    static rec_line(downstream: Vertex, line: Line): void;
+    /** 同一节点发出的 两个条线 相连 */
+    static line_line_emit(l1: Line, l2: Line): void;
+    /** 同一节点接收的 两个条线 相连 */
+    static line_line_rec(l1: Line, l2: Line): void;
+    static insert_line_emit(l1: Line, l2: Line, ins: Line): void;
+    static insert_line_rec(l1: Line, l2: Line, ins: Line): void;
+    /** 上游顶点 */
+    upstream: Vertex;
+    /** 上游节点 发出的上一条线 */
+    prevEmitLine: Line;
+    /** 上游节点 发出的下一条线 */
+    nextEmitLine: Line;
+    /** 下游顶点 */
+    downstream: Vertex;
+    /** 下游节点 接收的上一条线 */
+    prevRecLine: Line;
+    /** 下游节点 接收的下一条线 */
+    nextRecLine: Line;
+    constructor();
+}

package/dist/signal/src/priority-queue.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 这是一个优先队列 （满足子节点总是比父节点大）
+ *                    1
+ *
+ *               10          20
+ *
+ *          15    30      25      30
+ *
+ *       17
+ *  现在插入 7 ， 会按广度优先的顺序插入在数组尾部
+ *                    1
+ *
+ *               10          20
+ *
+ *          15    30      25      30
+ *
+ *       17    7
+ * 接着我们只需要将 7  逐层与上门的父节点比较， 7 较小则两者交互，一直让 7 上浮到适合的位置
+ *
+ *                          0
+ *
+ *                    1           2                 2^0 得到第二层第一个索引
+ *
+ *              3       4     5       6            2^0 + 2^1 。。。 + 2^n + x = y
+ *
+ *          7      8
+ * 上浮后我们得到以上的树
+ */
+type IGetIndex = (v: number, max: number) => number | null;
+export declare const leakI: IGetIndex;
+export declare class PriorityQueue<T> {
+    aIsUrgent: (a: T, b: T) => boolean;
+    arr: T[];
+    constructor(aIsUrgent: (a: T, b: T) => boolean);
+    _add(current: T): void;
+    add(...items: T[]): void;
+    goUp: (arr: T[], current: T, len: number) => void;
+    poll(): T;
+    goDown: (arr: T[], i: number) => void;
+    peek(): T;
+    size(): number;
+    logTree(): void;
+}
+export {};

package/dist/signal/src/schedule.d.ts

@@ -0,0 +1,9 @@
+import { ScheduleHandler } from "./type";
+export declare enum Scheduler {
+    Sync = "__Sync_",
+    Layout = "__Layout_",
+    Micro = "__Micro_",
+    Macro = "__Macro_"
+}
+export declare const _scheduler: Record<string | symbol, ScheduleHandler>;
+export declare const scheduler: (key: string | symbol, value: ScheduleHandler) => ScheduleHandler;

package/dist/signal/src/scope.d.ts

@@ -0,0 +1,13 @@
+import { Line } from './line';
+import type { Signal } from './signal';
+import { TaskQueue } from './task';
+/** scope 捕获，引用外部 signal 孤岛 */
+export declare const unTrackIsland: (signal: Signal) => void;
+/** scope 释放，被重新连接的孤岛 */
+export declare const trackIsland: (signal: Signal) => void;
+export declare const markOutLink: (signal: Signal, downstream: Signal) => void;
+export declare const ideScheduler: TaskQueue<import("./type").Task & {
+    index: number;
+}>;
+export declare function handleOneTask(s: Signal, breakStack: Line[]): boolean;
+export declare function unlinkRecWithScope(line: Line): void;

package/dist/signal/src/signal.d.ts

@@ -0,0 +1,42 @@
+import { State } from './global';
+import { Line } from './line';
+import { SignalOpt, Vertex } from './type';
+export declare class Signal<T = any> implements Vertex {
+    private nextValue;
+    /** 为什么是 shallow，因为 pullDeep 会把
+     * 上游节点 get 执行完成，让其可以直接拿到缓存值
+     */
+    private customPull?;
+    version: number;
+    id: number;
+    state: State;
+    /** 当前节点创建时处于的 effect 就是 scope */
+    scope: Signal;
+    recEnd: Line;
+    recStart: Line;
+    emitStart: Line;
+    emitEnd: Line;
+    scheduler: string;
+    value: T;
+    static Pulling: Signal;
+    pull: () => T;
+    constructor(nextValue: T, 
+    /** 为什么是 shallow，因为 pullDeep 会把
+     * 上游节点 get 执行完成，让其可以直接拿到缓存值
+     */
+    customPull?: () => T);
+    static create<T>(nextValue: T, { customPull, isScope, ...rest }: SignalOpt<T>): Signal<T>;
+    DEFAULT_PULL(): T;
+    /**
+     * 递归拉取负责建立以来链
+     */
+    pullRecurse(shouldLink?: boolean): T;
+    pullDeep(): T;
+    get(): T;
+    markDownStreamsDirty(): void;
+    set(v: T): void;
+    run(...args: any[]): any;
+    runIfDirty(): void;
+    isAbort(): number;
+}
+export declare function runWithPulling(fn: Function, signal: Signal | undefined): void;

package/dist/signal/src/task.d.ts

@@ -0,0 +1,12 @@
+import { PriorityQueue } from './priority-queue';
+import { CreateTaskProps, Task } from './type';
+export declare class TaskQueue<T> {
+    callbackAble: CreateTaskProps<T>['callbackAble'];
+    aIsUrgent: CreateTaskProps<T>['aIsUrgent'];
+    constructor(callbackAble: CreateTaskProps<T>['callbackAble'], aIsUrgent: CreateTaskProps<T>['aIsUrgent']);
+    isScheduling: boolean;
+    taskQueue: PriorityQueue<Task & T>;
+    static create<T>({ callbackAble, aIsUrgent }: CreateTaskProps<T>): TaskQueue<Task & T>;
+    pushTask(task: Task & T): void;
+    scheduleTask(): boolean;
+}

package/dist/signal/src/test-hidden-class-transfrom.d.ts

@@ -0,0 +1,17 @@
+export declare class A {
+    static HH: string;
+    value: number;
+    constructor(a?: number);
+    change(value: number): void;
+    get: () => void;
+    get v(): number;
+    set v(v: number);
+}
+export default class {
+    private b;
+    value: number;
+    constructor(b: number, value?: number);
+    change(value: number): void;
+    get: () => void;
+    get v(): number;
+}

package/dist/signal/src/type.d.ts

@@ -0,0 +1,42 @@
+import { Line } from './line';
+import type { Signal } from './signal';
+export type Task = () => any;
+export type CreateTaskProps<T> = {
+    callbackAble: (fn: Function) => any;
+    aIsUrgent: (a: Task & T, b: Task & T) => boolean;
+};
+export type ScheduleHandler = (effects: Signal[]) => any;
+export type SignalOpt<T> = {
+    customPull?: () => T;
+    scheduler?: string;
+    isScope?: boolean;
+};
+export type Vertex = {
+    /** 上游来的最后一条线 */
+    recEnd: Line;
+    recStart: Line;
+    /** 向下游发出的最后一条线 */
+    emitEnd: Line;
+    emitStart: Line;
+};
+export type DFSCtxBegin = {
+    node: Signal;
+    lineFromUp: Line;
+    walkedLine: Line[];
+    notGoDeep?: boolean;
+};
+export type DFSCtxCompete = {
+    node: Signal;
+    lineToDeep: Line;
+    walkedLine: Line[];
+    notGoDeep?: boolean;
+};
+export type Getter<T = any> = {
+    (): T;
+    ins?: Signal;
+};
+export type Mix<T = any> = {
+    (v: T): void;
+    (): T;
+    v: T;
+};

package/dist/signal/src/util.d.ts

@@ -0,0 +1,2 @@
+export declare const ide: typeof requestIdleCallback | typeof setTimeout;
+export declare const now: () => number;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "aoye",
+  "version": "0.0.1",
+  "main": "dist/aoye.cjs.js",
+  "module": "dist/aoye.esm.js",
+  "browser": "dist/aoye.umd.js",
+  "types": "dist/index.d.ts",
+  "devDependencies": {},
+  "scripts": {
+    "ini": "node scripts/init.js",
+    "build": "rm -rf ./dist && rollup -c",
+    "pub": "node scripts/publish.js",
+    "dev": "rollup -c -w",
+    "t": "jest",
+    "tw": "jest --coverage --watch --trace-deprecation"
+  },
+  "files": [
+    "dist"
+  ],
+  "license": "MIT",
+  "keywords": [
+    "aoye",
+    "new-me",
+    "smooth",
+    "cat"
+  ],
+  "author": "smooth-cat",
+  "repository": {
+    "type": "git",
+    "url": "git+git@github.com:smooth-cat/newme.git"
+  },
+  "bugs": {
+    "url": "https://github.com/smooth-cat/newme/issues"
+  },
+  "homepage": "https://github.com/smooth-cat/newme#readme",
+  "description": "a fast signal lib"
+}