npm i @jcstdio/jc-utils
# or
yarn add @jcstdio/jc-utils
# or
pnpm i @jcstdio/jc-utils

// 如：
import { isBoolean } from '@jcstdio/jc-utils'

import { EventEmitter } from '@jcstdio/jc-utils'

export declare class EventEmitter {
    private _events;
    private _maxListeners;
    constructor();
    /**
     * 将 `listener` 函数添加到名为 `event` 的事件的 listeners 数组的末尾。
     * - 不检查是否已经添加了 `listener`。
     * - 多次调用传递 `event` 和  `listener` 的相同组合将导致多次添加和调用 `listener` 。
     * @param event 时间名
     * @param listener 订阅该事件的监听器函数
     * @returns 返回对 `EventEmitter`的引用，以便可以链接调用。
     * @since v0.0.19 重大变化：当添加新的监听器到监听器数组时，将自己发出 `newListener` 事件
     */
    addListener(event: string | symbol, listener: (...args: any[]) => void): this;
    /**
     * 添加 listener, addListener 的同名方法
     * @param event 事件名
     * @param listener 订阅该事件的监听器函数
     */
    on(event: string | symbol, listener: (...args: any[]) => void): this;
    /**
     * 为名为 event 的事件添加 一次性 的 listener 函数。
     * 下次 event 被触发时，该 listener 被移除，然后被调用。
     * @param event 事件名字符串
     * @param listener 事件回调函数
     * @returns 返回对 `EventEmitter`的引用，以便可以链接调用。
     */
    once(event: string | symbol, listener: Function): this;
    /**
     * 从名为 event 的事件的侦听器数组中移除指定的 listener。
     * @param event 事件名
     * @param listener 事件监听器函数（事件的订阅者函数）
     * @returns 返回对 `EventEmitter`的引用，以便可以链接调用。
     */
    removeListener(event: string | symbol, listener: (...args: any[]) => void): this;
    /**
     * 从名为 event 的事件的侦听器数组中移除指定的 listener。 removeListener 的同名方法
     * @param event
     * @param listener
     */
    off(event: string | symbol, listener: (...args: any[]) => void): this;
    /**
     * 移除所有的 Listener
     * @param event 事件名
     * @returns 返回对 `EventEmitter`的引用，以便可以链接调用。
     */
    removeAllListeners(event?: string | symbol): this;
    /**
     * 获取所有事件名
     * @returns 事件名数组
     * @since v0.0.19 新增该方法
     */
    eventNames(): Array<string | symbol>;
    /**
     * 设定最大 Listener 数量
     * @param n 最大 Listener 数量
     */
    set maxListeners(n: number);
    /**
     * 获取最大 Listener 数量
     * - 默认情况下，任何单个事件最多可以注册10个侦听器。可以使用emitter.setMaxListeners(n)方法为单个EventEmitter实例更改此限制。
     */
    get maxListeners(): number;
    /**
     * 设定最大 Listener 数量
     * - setter maxListeners 的方法形式
     * @param n 最大 Listener 数量
     * @return 返回对 `EventEmitter`的引用，以便可以链接调用。
     */
    setMaxListeners(n: number): this;
    /**
     * 获取最大 Listener 数量
     * - 默认情况下，任何单个事件最多可以注册10个侦听器。可以使用emitter.setMaxListeners(n)方法为单个EventEmitter实例更改此限制。
     * - getter maxListeners 的方法形式
     */
    getMaxListeners(): number;
    /**
     * 返回名为 `event` 的事件的侦听器数组的副本。
     *
     * @param event 一个表示事件（key）的字符串
     * @returns 事件回调
     */
    listeners(event: string | symbol): Function[];
    /**
     * 返回名为 `eventName` 的事件的侦听器数组的副本，包括任何包装(如由 `.once()` 创建的包装)。
     * @param event
     * @returns
     */
    rawListeners(event: string | symbol): Function[];
    /**
     * 事件发生器
     *
     * - 若指定事件不存在，则返回 flase
     * - 反之，则执行指定事件的所有回调，并返回true
     *
     * @param event 事件名字符串（key）
     * @param args 事件回调的参数
     * @returns 表示事件是否存在的布尔值
     */
    emit(event: string | symbol, ...args: any[]): boolean;
    /**
     * 返回侦听名为eventName的事件的侦听器数量。如果提供了listener，它将返回在事件的侦听器列表中找到该侦听器的次数。
     *
     * 当指定的事件不存在时返回值为0
     * @param event 监听的事件名
     * @param listener 事件处理函数
     * @returns 指定事件的现有监听器的数量
     * @since v0.0.19 允许指定特定的监听器函数（listener）进行统计
     * ```ts
     * import { EventEmitter } from '@jcstdio/jc-utils'
     *
     * const myEmitter = new EventEmitter();
     * myEmitter.on('event', () => {});
     * myEmitter.on('event', () => {});
     * console.log(myEmitter.listenerCount('event'));
     * // Prints: 2
     * ```
     */
    listenerCount(event: string | symbol, listener?: Function): number;
    /**
     * 将 `listener` 函数添加到名为 `event` 的事件的 listeners 数组的开头。
     * - 不检查是否已经添加了 `listener`。
     * - 多次调用传递“事件名称”和 `listener` 的相同组合将导致多次添加和调用 `listener`。
     * @param event 事件名
     * @param listener 事件回调函数
     * @returns 返回对 `EventEmitter`的引用，以便可以链接调用。
     */
    prependListener(event: string | symbol, listener: Function): this;
    /**
     * 将名为 `event` 的事件的 **一次性** 的 `listener` 函数添加到 listeners 数组的`_beginning_ ` 中。
     * 下次 `event` 事件被触发时，该 监听器 被移除，然后被调用。
     * @param event
     * @param listener 监听器回调函数
     */
    prependOnceListener(event: string | symbol, listener: Function): this;
    /**
     * 此符号应用于安装一个监听器，仅用于监控`'error'`事件。在调用常规的`'error'`侦听器之前，调用使用此符号安装的侦听器。
     *
     * 使用此符号安装侦听器不会改变发出 `'error'` 事件后的行为，因此，如果没有安装常规的 `'error'` 侦听器，进程仍会崩溃。
     */
    static readonly errorMonitor: unique symbol;
    static readonly captureRejectionSymbol: unique symbol;
    /**
     * 设置或获取所有发射器的默认 captureRejection 值。
     */
    static captureRejections: boolean;
    /**
     * @since v0.0.19 新增 defaultMaxListeners，表示默认的最大监听器数量
     */
    static defaultMaxListeners: number;
}

import { StateManager } from '@jcstdio/jc-utils'
const stateManager = new StateManager<{
    value:number
}>({ value: 0, });
const sideEffec1 = (state: { value: any; }) => {
    console.log('我是 sideEffec1 ，状态被更新，当前状态值为：', state.value);
}
const sideEffec2 = () => {
  console.log('我是 sideEffec2 ，执行顺序为执行 “subscribe” 方法的顺序。')
}
// 设置状态更新后的回调，可以采用链式调用
stateManager
  .subscribe(sideEffec1)
  .subscribe(sideEffec2)
// 更新你的状态
console.log('------- 第一次改变状态 -------');
stateManager.state = { value: 1 };
console.log('\n------- 第二次改变状态 -------');
stateManager
  .unsubscribe(sideEffec2)  // 取消状态发生改变时订阅的 sideEffec2。
  .state = { value: 2 };    // 指挥执行没有被取消的订阅

------- 第一次改变状态 -------
我是 sideEffec1 ，状态被更新，当前状态值为： 1
我是 sideEffec2 ，执行顺序为执行 “subscribe” 方法的顺序。
------- 第二次改变状态 -------
我是 sideEffec1 ，状态被更新，当前状态值为： 2

// JQuery
$(".btn1").click(function(){
  $("p").slideUp();
});
$("button").click(function(){
$("p").slideDown();
});

<template>
<ul @click="$event=>callBack()" ref="ulRef">
  <li>1</li>
  <li>2</li>
  <li>3</li>
  <li>4</li>
  <li>5</li>
</ul>
</template>
<script setup lang="ts">
import { getCurrentInstance, ref } from 'vue';
import type { ComponentInternalInstance } from 'vue;
import { slideUp, slideDown, slideToggle } from '@jcstdio/jc-utils'
const that = getCurrentInstance() as ComponentInternalInstance;
let callBack: () => void;
onMounted(()=>{
  const ulRef; = that.refs.ulRef as HTMLElement;
  callBack = () => {
    slideToggle(navRef);
  };
})
</script>

import { Logger } from '@jcstdio/jc-utils'
const logger = new Logger('')
logger.trace('trace')
logger.debug('debug')
logger.info('info')
logger.success('success')
logger.warn('warn')
logger.error('error')
logger.fatal('fatal')
logger.level1('level1')
logger.level2('level2')
logger.level3('level3')
logger.gradient('geadientText')

import { IniConfig } from '@jcstdio/jc-utils'

declare class IniConfig {
    private _filePath;
    private _conf;
    constructor(_filePath?: string);
    get value(): Record<string, Record<string, any>>;
    load(obj: Record<string, Record<string, any>>): void;
    readSync<T>(filePath?: string): this;
    static format<U = Record<string, Record<string, any>>>(obj: U): string;
    private _farmat;
    writeSync(filePath?: string): void;
    addSection<V extends Record<string, any>>(section: string, records: V): this;
    addRecord<V>(section: string, key: string, value: V): this;
    getSection(section?: string): Record<string, any>;
    get(section?: string, key?: string): any;
    private __str__;
    print(): this;
}

import { getEnvs } from '@jcstdio/jc-utils'

declare function getEnvs<T>(envFilePath: string, regExp?: RegExp, parse?: (right: string) => T): Record<string, T>;

import { Cookies } from '@jcstdio/jc-utils'
let cookies = new Cookies();

declare class Cookies {
    /**
     * 添加新的 cookie
     * @param name cookie 名称
     * @param value cookie 值
     * @param options cookie 选项
     */
    set(name: string, value: string, options?: {
        expires?: number;
        path?: string;
    }): void;
    /**
     * 获取指定名称的 cookie
     * @param name cookie 名称
     * @returns cookie 值
     */
    get(name: string): string | undefined;
    /**
     * 删除指定名称的 cookie
     * @param name cookie 名称
     */
    remove(name: string): void;
    /**删除所有的 cookie*/
    clear(): void;
    /**
     * 返回所有 cookie 键值对构成的 Map
     * @returns cookie 键值对构成的 Map
     */
    getMap(): Map<string, string>;
    /**
     * 返回指定 cookie 是否存在
     * @param name cookie 名称
     * @returns 是否存在
     */
    has(name: string): boolean;
    /**
     * 将指定 cookie 键值对写入 localStorage
     * @param name cookie 名称
     */
    copyToLocal(name: string): void;
    /**
     * 将指定 cookie 键值对写入 localStorage，并从 cookie 中删除
     * @param name cookie 名称
     */
    moveToLocal(name: string): void;
    /**
     * 从 localStorage 读取指定键值对，改写到 cookie，并从 localStorage  中删除
     * @param name cookie 名称
     */
    moveFromLocal(name: string): void;
    /**
     * 从 localStorage 读取指定键值对，改写到 cookie
     * @param name cookie 名称
     */
    copyFromLocal(name: string): void;
}

import { copy } from '@jcstdio/jc-utils'
// 浅拷贝
const obj1 = {a: 1, b: {c: 2}};
const shallowCopyObj1 = copy.shallowCopy(obj1);
console.log(shallowCopyObj1); // {a: 1, b: {c: 2}}
console.log(shallowCopyObj1.b === obj1.b); // true
// 使用 deepCopy 方法深拷贝 （递归复制嵌套对象实现）
const obj2 = {a: 1, b: {c: 2}};
const deepCopyObj2 = copy.deepCopy(obj2);
console.log(deepCopyObj2); // {a: 1, b: {c: 2}}
console.log(deepCopyObj2.b === obj2.b); // false
// 使用 serializeCopy 方法深拷贝 （使用JSON序列化和反序列化实现）
const obj3 = {a: 1, b: {c: 2}};
const serializeCopyObj3 = copy.serializeCopy(obj3);
console.log(serializeCopyObj3); // {a: 1, b: {c: 2}}
console.log(serializeCopyObj3.b === obj3.b); // false

// vite.config.ts
import { wrapperEnv } from '@jcstdio/jc-utils'
const ENV_DIR = path.join(__dirname, "envs");
export default defineConfig(({ command, mode }) => {
  const env = loadEnv(mode, ENV_DIR, "");
  const viteEnv = wrapperEnv(env);
  console.log((`[vite config] viteEnv founded: ${JSON.stringify(viteEnv)}`));
  return {
    // vite configs
  // ...
  }
})

import { arithmeticProgression } from '@jcstdio/jc-utils'
arithmeticProgression(1,9,3);    // [ 1, 3, 5, 7, 9 ]
arithmeticProgression(9,1,3);    // [ 9, 7, 5, 3, 1 ]
arithmeticProgression(-9,-1,3);  // [ -9, -7, -5, -3, -1 ]
arithmeticProgression(-1,-9,3);  // [ -1, -3, -5, -7, -9 ]
arithmeticProgression(-1,-9,0);  // [ -1, -9 ]
arithmeticProgression(1,1,3);    // [ 1, 1, 1, 1, 1 ]

declare function range(x: number): number[];
declare function range(x: [number]): number[];
declare function range(x: [number, number]): number[];
declare function range(x: [number, number, number]): number[];

import { range } from '@jcstdio/jc-utils'
range([0, 3]);    // [0，1，2]
range(3);         // 相当于 range([0, 3])，[0，1，2]
range([3]);       // 相当于 range(3)，   [0，1，2]
range([4, 8, 1]); // [4, 5, 6, 7]， 其中最后一个数表示间隔
range([4, 8, 2]); // [4, 6]
range([4, 8]);    // 相当于 range([4, 8, 1])，[4, 5, 6, 7]

import { regIp } from '@jcstdio/jc-utils'

declare function regTestAll(regs: RegExp[], text: string, debug?: boolean): boolean;

declare function regTestAny(regs: RegExp[], text: string, debug?: boolean): boolean;

declare class ListNode<T> {
    value: T;
    next: ListNode<T> | null;
    prev: ListNode<T> | null;
    constructor(value: T);
}
declare class LinkedList<T> {
    private _head;
    private _tail;
    private _count;
    constructor(...params: T[]);
    /**获取头节点*/
    get head(): ListNode<T>;
    /**获取尾节点*/
    get tail(): ListNode<T>;
    /**链表的长度*/
    get length(): number;
   /**
    * 在链表尾部添加节点
    * @param value 节点的值
    */
    push(value: T): void;
    /**
   * append 的别名方法
   * @param value 节点的值
   */
    append(value: T): void;
    /**
   * 在链表头部添加节点
   * @param value 节点的值
   */
    pushLeft(value: T): void;
    /**
   * addpenLeft的别名方法
   * @param value 节点的值
   */
    appendLeft(value: T): void;
    /**
   * 删除链表尾部节点
   * @returns 被删除的节点的值
   */
    pop(): T | null;
    /**
   * 在链表头部添加节点
   * @param value 节点的值
   */
    unshift(value: T): void;
    /**
   * 清空链表
   */
    clear(): void;
    /**
   * 删除指定节点
   * @param node 要删除的节点
   * @returns 被删除的节点的值
   */
    remove(node: ListNode<T>): T | null;
    /**
   * 删除指定位置的节点
   * @param index 要删除的节点的位置
   * @returns 被删除的节点的值
   */
    drop(index: number): T | null;
    /**
   * 对该链表进行切片，返回新的 LinkedList
   * @param start 切片的起始元素索引（包含）
   * @param end 切片的结束元素索引（不包含）
   */
    slice(start: number, end: number): LinkedList<T>;
    /**
   * 如果LinkedList元素都为 number 时，用于与另外一个 LinkedList 元素对应相加，得到新的LinkedList返回。
   * 如果 LinkedList 元素都为 string 时，则返回对应字符串元素拼接组成的新LinkedList
   * @param list 要相加或拼接对应元素的 LinkedList
   * @returns 相加或拼接对应元素后的新 LinkedList
   */
    add(list: LinkedList<T>): LinkedList<T>;
    /**
   * 获取指定位置的节点的值
   * @param index 节点的位置
   * @returns 节点的值
   */
    get(index: number): T | null;
    /**
   * 判断链表中是否包含指定的值
   * @param value 要查找的值
   * @returns 是否包含指定的值
   */
    includes(value: T): boolean;
    /**
   * includes 的别名方法
   * @param value 要查找的值
   * @returns 是否包含指定的值
   */
    contains(value: T): boolean;
    /**
   * 过滤链表中的节点
   * @param callback 过滤函数
   * @returns 过滤后的链表
   */
    filter(callback: (value: T) => boolean): LinkedList<T>;
    /**
   * 映射链表中的节点
   * @param callback 映射函数
   * @returns 映射后的链表
   */
    map<U>(callback: (value: T) => U): LinkedList<U>;
    private _quickSort;
    /**
   * 对链表进行快速排序
   */
    sort(): void;
    /**
   * 对链表元素进行反转
   */
    reverse(): void;
}

declare class List<T> {
    private _list;
    constructor(...params: T[]);
    get value(): LinkedList<T>;
    set value(list: LinkedList<T>);
   /**
     * 在列表尾部添加元素
     * @param value 元素的值
     */
    push(value: T): void;
    /**
     * 在内部，如果LinkedList元素都为 number 时，用于与另外一个 LinkedList 元素对应相加，得到新的LinkedList返回。 如果 LinkedList 元素都为 string 时，则返回对应字符串元素拼接组成的新LinkedList
     */
    add(value: LinkedList<T>): void;
    /**
     * append的别名方法
     * @param value 元素的值
     */
    append(value: T): void;
    /**
     * 在列表头部添加元素
     * @param value 元素的值
     */
    unshift(value: T): void;
    /**
     * addpenLeft的别名方法
     * @param value 元素的值
     */
    appendLeft(value: T): void;
    /**
     * 删除列表尾部元素
     * @returns 被删除的元素的值
     */
    pop(): T | null;
    /**
     * 清空列表
     */
    clear(): void;
    /**
     * 删除指定位置的元素
     * @param index 要删除的元素的位置
     * @returns 被删除的元素的值
     */
    remove(index: number): T | null;
    /**
     * 获取指定位置的元素的值
     * @param index 元素的位置
     * @returns 元素的值
     */
    get(index: number): T | null;
    /**
     * 判断列表中是否包含指定的值
     * @param value 要查找的值
     * @returns 是否包含指定的值
     */
    includes(value: T): boolean;
    /**
     * contains的别名方法
     * @param value 要查找的值
     * @returns 是否包含指定的值
     */
    contains(value: T): boolean;
    /**
     * 过滤列表中的元素
     * @param callback 过滤函数
     * @returns 过滤后的列表
     */
    filter(callback: (value: T) => boolean): List<T>;
    /**
     * 映射列表中的元素
     * @param callback 映射函数
     * @returns 映射后的列表
     */
    map<U>(callback: (value: T) => U): List<U>;
    /**
     * 获取指定范围内的元素组成的新列表
     * @param start 起始位置（包含）
     * @param end 结束位置（不包含）
     * @returns 新列表
     */
    slice(start: number, end: number): List<T>;
    /**
     * 纯基于整数位置的索引，用于按位置选择。
     * @param index 元素的位置
     * @returns 元素的值
     */
    iloc(index: number): T | null;
    /**
     * 所有元素为number时，用于求和，所有元素为string时用于字符串拼接
     * @returns 求和或字符串拼接的结果
     */
    sum(): number | string;
    /**
     * 所有元素为number时返回最小值
     * @returns 最小值
     */
    min(): number | null;
    /**
     * 所有元素为number时返回最大值
     * @returns 最大值
     */
    max(): number | null;
    /**
     * 所有元素为number时返回平均值
     * @returns 平均值
     */
    mean(): number | null;
    /**
     * 所有元素为number时返回样本标准差
     * @returns 样本标准差
     */
    std(): number | null;
    /**
     * 所有元素为number时返回无偏方差
     * @returns 无偏方差
     */
    var(): number | null;
    /**
     * 所有元素为number时返回所有该LinkedList元素绝对值构成的新LinkedList
     * @returns 所有元素绝对值构成的新LinkedList
     */
    abs(): List<number>;
    /**
     * 就地排序
     */
    sort(): void;
    /**
     * 列表的长度
     */
    get length(): number;
    /**
     * 列表的长度
     * - length 的同名 Getter.
     */
    get size(): number;
    /**
     * 实现该类的迭代器
     */
    [Symbol.iterator](): Iterator<T>;
}

declare class Series {
    private _data;
    private _index;
    private columns;
    private dtypes;
    constructor(data: any[], options?: {
        columns?: any[];
        dtypes?: any[];
        index?: any[];
    });
    get shape(): number[];
    get size(): number;
    get data(): any[];
    /**返回序列和其他元素的加法(二元运算符add)*/
    add(other: Series, options?: any): Series;
    /**返回 Series 和其他元素的减法(二元运算符sub)*/
    sub(other: Series, options?: any): Series;
    /**返回 Series 和其他元素的乘法运算(二元运算符mul)*/
    mul(other: Series, options?: any): Series;
    /**返回 Series 和其他元素的浮点除法(二元运算符truediv)*/
    div(other: Series, options?: any): Series;
    /**返回 Series 和其他元素的模(二元运算符mod)*/
    mod(other: Series, options?: any): Series;
    /**返回级数和其他元素的指数幂(二元运算符pow)*/
    pow(other: Series, options?: any): Series;
    /**舍入 Series 中的浮点值*/
    round(dp: number, options?: any): Series;
    /**检查 Series 中的所有值是否都小于某个值*/
    lt(other: any, options?: any): boolean;
    /**返回 Series 和其他元素的大于(二元运算符gt)*/
    gt(other: Series, options?: any): Series;
    /**按元素返回小于或等于of的 Series 和other(二元运算符le)*/
    le(other: Series, options?: any): Series;
    /**检查 Series 中的所有值是否都大于或等于某个值*/
    ge(other: any, options?: any): boolean;
    /**返回不等于系列和其他元素的值(二元运算符ne)*/
    ne(other: Series, options?: any): Series;
    /**返回等于系列和其他元素的值(二元运算符eq)*/
    eq(other: Series, options?: any): Series;
    /**对Series中的每个值调用函数*/
    apply(callable: Function, options?: any): Series;
    /**将Series的值映射到函数或对象*/
    map(callable: Function): Series;
    /**返回删除了缺失值的新Series*/
    dropNa(options?: any): Series;
    /**使用指定的方法填充NaN值*/
    fillNa(options?: any): Series;
    /**检测缺失值*/
    isNa(): boolean;
    /**替换值*/
    replace(oldValue: any, newValue: any, options?: any): Series;
    /**返回Series和其他Series之间的逻辑或*/
    or(other: Series): Series;
    /**返回Series和其他Series之间的逻辑与*/
    and(other: Series): Series;
    /**返回对Series值进行排序的整数索引*/
    argSort(options?: any): any[];
    /**返回 Series 中最小值的位置*/
    argMin(): number;
    /**返回 Series 中最大值的位置*/
    argMax(options?: any): number;
    /**按值排序*/
    sortValues(options?: any): Series;
    /**
    将系列打印到控制台。
    注意：这个方法的实现还有些问题，待之后想办法改改。
    */
    print(...params: any[]): void;
}

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

interface User {
  name: string;
  age: number;
  email: string;
}
type UserWithoutEmail = Omit<User, 'email'>;

{
  name: string;
  age: number;
}

declare function omit<T, K extends keyof T>(obj: T, key: K): Omit<T, K>;

declare const noop: (...params: any) => void;
declare const pass: (param?: string) => void;

/**
 * 对一个字符串进行 Base64 编码
 * @param str 一个字符串
 * @returns 进行 Base64 编码后的字符串
 */
export declare function strEncodeBase64(str: string): string;

/**
 * 将一个使用 Base64 编码后的字符串还原为原字符串
 * @param str 一个字符串
 * @returns Base64 解码 后的字符串
 */
export declare function strBase64Decode(str: string): string;

export declare function addThing(thingName: string, begin?: number): boolean;

import { addThing } from '@jcstdio/jc-utils/id'
addThing('student'); // 添加了 student 作为事物，也就是相当于新建了一个 student 的分类
addThing('staff'); // 添加了 staff 作为事物，也就是相当于新建了一个 staff 的分类

export declare function getNewItemId(thingName: string, idType?: IDType): string | number;

import { getNewItemId } from '@jcstdio/jc-utils/id'
const id = getNewItemId('student');

declare type IDType = 'number' | 'string' | 'simple' | 'baseb4';

export declare function load(from?: string): Promise<boolean>;
/**
 * 保存到本地存储
 * @param path — 如果指定了此参数，且在服务端环境，则会保存到以该参数为路径的位置而非 localstorage，否则保存到localstorage
 * - 你可以通过 setStorageKey 方法设置存储键
 */
export declare function save(path?: string): Promise<boolean>;
/**
 * 新建事物
 * @param thingName 事物名
 * @param begin id 计数起始
 * @returns 是否新建成功
 */

declare type IDType = 'number' | 'string' | 'simple' | 'baseb4';
/**获取 LOCAL STORAGE 键 */
export declare function getStorageKey(): string;
/**
 * 设置 LOCAL STORAGE 键
 * @param key 存储键字符串
 */
export declare function setStorageKey(key: string): string;
/**
 * 从本地存储中加载
 * @param {undefined|string} from 如果指定了此参数且在服务端环境，则从该参数表示的路径加载数据而不是 localstorage
 */
export declare function load(from?: string): Promise<boolean>;
/**
 * 保存到本地存储
 * @param path — 如果指定了此参数，且在服务端环境，则会保存到以该参数为路径的位置而非 localstorage，否则保存到localstorage
 * - 你可以通过 setStorageKey 方法设置存储键
 */
export declare function save(path?: string): Promise<boolean>;
/**
 * 新建事物
 * @param thingName 事物名
 * @param begin id 计数起始
 * @returns 是否新建成功
 */
export declare function addThing(thingName: string, begin?: number): boolean;
/**
 * 删除事物
 * @param thingName 事物名
 * @returns 删除成功则返回 true，反之返回 false
 */
export declare function dropThing(thingName: string): boolean;
/**
 * 返回事物是否存在
 * @param thingName 事物名
 * @since v0.0.19
 */
export declare function hasThing(thingName: string): boolean;
/**
 * 指定事件是否已有指定ID
 * @param {string} thingName 事件名
 * @param {number | string} id ID值
 * @param { IDType }idType ID类型
 * @returns { boolean } 如果有，则返回 true，否则返回 false
 */
export declare function hasID(thingName: string, id: number | string, idType?: IDType, raiseWarn?: boolean): boolean;
/**
 * 为指定事物申请一个新 ID
 * @param thingName 事物名
 * @returns id 字符串
 */
export declare function getNewItemId(thingName: string, idType?: IDType): string | number;
/**
 * 获取某个事物当前的ID
 * @param thingName 事物名
 * @returns 最后给出的一个 id
 */
export declare function getCurrentId(thingName: string, idType?: IDType): string | number;
/**
 * 获取某个事物当前已经给出的 id 数量
 * @param thingName 事物名
 * @returns 某个事物当前已经给出的 id 数量
 */
export declare function countIds(thingName: string): number;

/**
 * 为 Array 创建代理
 * - 可以进行负数索引
 * - 删除指定索引处的元素不留下空位
 * @param target 被代理的目标对象
 * @returns 代理后的对象
 */
declare function createArrayProxy<T>(target: Array<T>): ArrayProxy<T>;

import { createArrayProxy } from '@jcstdio/jc-utils';
let arProxy1 = createArrayProxy([0,1,2,'3'])
console.log('arProxy1 =',arProxy1);
console.log('---------- 测试索引 ----------');
console.log('ar[1] =',arProxy1[1]);
console.log('ar[0] =',arProxy1[0]);
console.log('ar[0] =',arProxy1[-1]);
console.log('ar[-1] =',arProxy1[-1]);
console.log('ar[-2] =',arProxy1[-2]);
console.log('ar[-3] =',arProxy1[-3]);
console.log('---------- 测试length属性 ----------');
console.log('.length =',arProxy1.length);
console.log('---------- 测试 pop、push 等方法 ----------');
arProxy1.pop()
console.log('ar.pop() =',arProxy1);
arProxy1.push(3)
console.log('ar.push(3) =',arProxy1);
arProxy1.forEach((item)=>{
    console.log('item =',item);
})
console.log('---------- 测试 delete ----------');
console.log('delete arProxy1[1]:');
delete arProxy1[1]
console.log(arProxy1);
console.log('---------- 测试扩展的方法 ----------');
arProxy1.drop(2);
console.log('ar.drop(2) =',arProxy1);
console.log('print方法输出 arProxy2:');
const arProxy2 = createArrayProxy([
    0,
    [1,2,3,{}],
    {a:1,b:[1,2,3]},
    3
])
arProxy2.print()
console.log('---------- 测试 delete ----------');
console.log('delete arProxy2[1]:');
delete arProxy2[1]
console.log(arProxy2);

arProxy1 = [ 0, 1, 2, '3' ]
---------- 测试索引 ----------
ar[1] = 1
ar[0] = 0
ar[0] = 3
ar[-1] = 3
ar[-2] = 2
ar[-3] = 1
---------- 测试length属性 ----------
.length = 4
---------- 测试 pop、push 等方法 ----------
ar.pop() = [ 0, 1, 2 ]
ar.push(3) = [ 0, 1, 2, 3 ]
---------- 测试迭代器 ----------
item = 0
item = 1
item = 2
item = 3
---------- 测试 delete ----------
delete arProxy1[1]:
[ 0, 2, 3 ]
---------- 测试扩展的方法 ----------
ar.drop(2) = [ 0, 2 ]
print方法输出 arProxy2:
[ 0, [ 1, 2, 3, {} ], { a: 1, b: [ 1, 2, 3 ] }, 3 ]
---------- 测试 delete ----------
delete arProxy2[1]:
[ 0, { a: 1, b: [ 1, 2, 3 ] }, 3 ]

import type { RequiredKeys } from '@jcstdio/jc-utils/ts'