@zhin.js/schema 0.0.14

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 凉菜
+
+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,78 @@
+# @zhinjs/schema
+zhin配置声明
+## 声明number
+```javascript
+Schema.number()
+```
+## 声明string
+```javascript
+Schema.string()
+```
+## 声明boolean
+```javascript
+Schema.boolean()
+```
+## 声明date
+```javascript
+Schema.date()
+```
+## 声明regexp
+```javascript
+Schema.regexp()
+```
+## 声明object
+1. Record<string,string>
+```javascript
+Schema.dict(
+    Schema.string()
+)
+```
+2. Record<string,number>
+```javascript
+Schema.dict(
+    Schema.number()
+)
+```
+3. Record<string,Date>
+```javascript
+Schema.dict(
+    Schema.date()
+)
+```
+4. Record<string,number[]>
+```javascript
+Schema.dict(
+    Schema.list(
+        Schema.number()
+    )
+)
+```
+5. Record<string,{foo:string,bar:number[]}[]>
+```javascript
+Schema.dict(
+    Schema.list(
+        Schema.object({
+            foo:Schema.string(),
+            bar:Schema.list(Schema.number())
+        })
+    )
+)
+```
+## 声明array
+1. string[]
+```javascript
+Schema.array(
+    Schema.string()
+)
+```
+2. {foo:number,bar:string}[]
+
+```javascript
+Schema.array(
+    Schema.object({
+        foo:Schema.number(),
+        bar:Schema.string()
+    })
+)
+```
+

package/lib/index.d.ts

@@ -0,0 +1,119 @@
+export class Schema<S = any, T = S> {
+    meta: Schema.Meta<S, T>;
+    options: Schema.Options;
+    [Symbol.toStringTag]: string;
+    constructor(meta: Schema.Meta<S, T>, options?: Schema.Options);
+    static fromJSON<S, T>(json: Schema.JSON<S, T>): Schema<S, T>;
+    toJSON(): Record<string, any>;
+    [Symbol.unscopables](): {
+        options: boolean;
+        meta: boolean;
+    };
+    /** 设置是否必填 */
+    required(): this;
+    /** 是否隐藏 */
+    hidden(): this;
+    /** 设置描述 */
+    description(description: string): this;
+    /** 设置渲染组件 */
+    component(component: string): this;
+    /** 设置默认值 */
+    default(defaultValue: T extends {} ? Partial<T> : T | (() => T)): this;
+    /** 设置选项列表 */
+    option(list: Schema.Option<T>[]): this;
+    /** 设置是否允许多选 */
+    multiple(): this;
+    /** 设置数值最小值，类型是string时，标识最小长度 */
+    min(min: number): this;
+    /** 设置数值最大值，类型是string时，标识最大长度 */
+    max(max: number): this;
+    /** 设置百分比步长 */
+    step(step: number): this;
+    /** 声明一个数字类型 */
+    static number(key?: string): Schema<number>;
+    /** 声明一个百分比类型 */
+    static percent(key?: string): Schema<number>;
+    /** 声明一个字符串类型 */
+    static string(key?: string): Schema<string>;
+    /** 声明一个布尔类型 */
+    static boolean(key?: string): Schema<boolean>;
+    /** 声明一个正则类型 */
+    static regexp(key?: string): Schema<string | RegExp, RegExp>;
+    /** 声明一个日期类型 */
+    static date(key?: string): Schema<number | Date, Date>;
+    /** 声明一个字典类型 */
+    static dict<X extends Schema>(inner: X, key?: string): Schema<Schema.Dict<X>, Schema.Dict<X>>;
+    /** 声明一个列表类型 */
+    static list<X extends Schema>(inner: X, key?: string): Schema<Schema.Types<X>[], Schema.Types<X>[]>;
+    /**
+     * 声明一个数组类型
+     * @deprecated use list instead
+     * */
+    static array<X extends Schema>(inner: X, key?: string): Schema<Schema.Types<X>[], Schema.Types<X>[]>;
+    /** 声明一个对象类型 */
+    static object<X extends {}>(dict: X, key?: string): Schema<Schema.Object<X>, Schema.Object<X>>;
+    /** 声明一个元组类型 */
+    static tuple<X extends readonly any[]>(list: X, key?: string): Schema<Schema.Tuple<X>>;
+    /** 声明一个联合类型 */
+    static union<X extends readonly any[]>(list: X, key?: string): Schema<Schema.Union<X>, Schema.Union<X>>;
+    /** 声明一个交叉类型 */
+    static intersect<X extends readonly any[]>(list: X, key?: string): Schema<Schema.Intersect<X>, Schema.Intersect<X>>;
+    /** 声明一个常量 */
+    static const<X extends string | number | boolean>(value: X, key?: string): Schema<X, X>;
+    /** 声明一个任意类型 */
+    static any(key?: string): Schema<any, any>;
+    /** 声明一个空类型 */
+    static never(key?: string): Schema<never, never>;
+    static resolve<T extends string>(type: T): Schema.Formatter | undefined;
+    static extend<T extends string>(type: T, formatter: Schema.Formatter): void;
+}
+export interface Schema<S = any> {
+    (value?: S): S;
+}
+export namespace Schema {
+    const formatters: Map<string, Formatter>;
+    type Formatter<S = any, T = S> = (this: Schema, value: S) => T;
+    type JSON<S = any, T = S> = Meta<S, T> & {
+        dict?: Record<string, JSON>;
+        inner?: JSON;
+        list?: JSON[];
+    };
+    interface Meta<S = any, T = S> {
+        key?: string;
+        hidden?: boolean;
+        type?: string;
+        default?: T extends {} ? Partial<T> : T | (() => T);
+        required?: boolean;
+        options?: Option[];
+        multiple?: boolean;
+        description?: string;
+        component?: string;
+        min?: number;
+        max?: number;
+        step?: number;
+    }
+    interface Options {
+        dict?: Record<string, Schema>;
+        inner?: Schema;
+        list?: readonly Schema[];
+    }
+    type Types<T> = T extends Schema<infer S, infer T> ? T : never;
+    type Union<T extends readonly any[]> = T extends readonly [infer L, ...infer R] ? Types<L> | Union<R> : never;
+    type Intersect<T extends readonly any[]> = T extends readonly [infer L, ...infer R] ? Types<L> & Intersect<R> : unknown;
+    type Dict<T> = {
+        [key: string]: Partial<Types<T>>;
+    } & Record<string, any>;
+    type Object<X extends {}> = {
+        [K in keyof X]?: Types<X[K]>;
+    };
+    type Tuple<X extends readonly any[]> = X extends readonly [infer L, ...infer R] ? [Types<L>, ...Tuple<R>] : [];
+    function checkDefault<T>(schema: Schema, value: T, fallback?: T): T;
+    type Option<T = any> = T extends Array<infer R> ? R | {
+        label: string;
+        value: R;
+    } : T;
+    function formatOptionList<T>(list: Schema.Option<T>[]): (Option<T> | {
+        label: Option<T> & string;
+        value: Option<T> & string;
+    })[];
+}

package/lib/index.js

@@ -0,0 +1,394 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Schema = void 0;
+class Schema {
+    constructor(meta, options = {}) {
+        this.meta = meta;
+        this.options = options;
+        this[_a] = 'Schema';
+        const _this = this;
+        const schema = function (value) {
+            const formatter = Schema.resolve(_this.meta.type);
+            if (!formatter)
+                throw new Error(`type ${_this.meta.type} not found`);
+            return formatter.call(_this, value);
+        };
+        return new Proxy(schema, {
+            get(target, p, receiver) {
+                return Reflect.get(_this, p, receiver);
+            },
+            set(target, p, value, receiver) {
+                return Reflect.set(_this, p, value, receiver);
+            }
+        });
+    }
+    static fromJSON(json) {
+        const { dict, inner, list, ...meta } = json;
+        const options = {};
+        if (dict)
+            options.dict = Object.fromEntries(Object.entries(dict).map(([key, value]) => [key, Schema.fromJSON(value)]));
+        if (inner)
+            options.inner = Schema.fromJSON(inner);
+        if (list)
+            options.list = list.map(item => Schema.fromJSON(item));
+        return new Schema(meta, options);
+    }
+    toJSON() {
+        var _b, _c;
+        return Object.fromEntries(Object.entries({
+            ...this.meta,
+            default: typeof this.meta.default === 'function' ? this.meta.default() : this.meta.default,
+            inner: (_b = this.options.inner) === null || _b === void 0 ? void 0 : _b.toJSON(),
+            list: (_c = this.options.list) === null || _c === void 0 ? void 0 : _c.map((item) => item.toJSON()),
+            dict: this.options.dict ? Object.fromEntries(Object.entries(this.options.dict || {}).map(([key, value]) => [key, value.toJSON()])) : undefined,
+        }).filter(([key, value]) => typeof value !== 'undefined'));
+    }
+    [(_a = Symbol.toStringTag, Symbol.unscopables)]() {
+        return {
+            options: true,
+            meta: true
+        };
+    }
+    /** 设置是否必填 */
+    required() {
+        this.meta.required = true;
+        return this;
+    }
+    /** 是否隐藏 */
+    hidden() {
+        this.meta.hidden = true;
+        return this;
+    }
+    /** 设置描述 */
+    description(description) {
+        this.meta.description = description;
+        return this;
+    }
+    /** 设置渲染组件 */
+    component(component) {
+        this.meta.component = component;
+        return this;
+    }
+    /** 设置默认值 */
+    default(defaultValue) {
+        this.meta.default = defaultValue;
+        return this;
+    }
+    /** 设置选项列表 */
+    option(list) {
+        this.meta.options = Schema.formatOptionList(list);
+        return this;
+    }
+    /** 设置是否允许多选 */
+    multiple() {
+        if (this.meta.type !== 'list')
+            throw new Error('multiple only support list type');
+        this.meta.multiple = true;
+        return this;
+    }
+    /** 设置数值最小值，类型是string时，标识最小长度 */
+    min(min) {
+        this.meta.min = min;
+        return this;
+    }
+    /** 设置数值最大值，类型是string时，标识最大长度 */
+    max(max) {
+        this.meta.max = max;
+        return this;
+    }
+    /** 设置百分比步长 */
+    step(step) {
+        this.meta.step = step;
+        return this;
+    }
+    /** 声明一个数字类型 */
+    static number(key) {
+        return new Schema({ key, type: "number" });
+    }
+    /** 声明一个百分比类型 */
+    static percent(key) {
+        return new Schema({ key, type: "percent" })
+            .component("slider")
+            .min(0)
+            .max(1)
+            .step(0.01);
+    }
+    /** 声明一个字符串类型 */
+    static string(key) {
+        return new Schema({ key, type: "string" });
+    }
+    /** 声明一个布尔类型 */
+    static boolean(key) {
+        return new Schema({ key, type: "boolean" });
+    }
+    /** 声明一个正则类型 */
+    static regexp(key) {
+        return new Schema({ key, type: "regexp" });
+    }
+    /** 声明一个日期类型 */
+    static date(key) {
+        return new Schema({ key, type: "date" }).component("date-picker");
+    }
+    /** 声明一个字典类型 */
+    static dict(inner, key) {
+        return new Schema({ key: key, type: "dict" }, { inner });
+    }
+    /** 声明一个列表类型 */
+    static list(inner, key) {
+        return new Schema({ key: key, type: "list" }, { inner });
+    }
+    /**
+     * 声明一个数组类型
+     * @deprecated use list instead
+     * */
+    static array(inner, key) {
+        return Schema.list(inner, key);
+    }
+    /** 声明一个对象类型 */
+    static object(dict, key) {
+        return new Schema({ key: key, type: "object" }, { dict });
+    }
+    /** 声明一个元组类型 */
+    static tuple(list, key) {
+        return new Schema({ key: key, type: "tuple" }, { list });
+    }
+    /** 声明一个联合类型 */
+    static union(list, key) {
+        return new Schema({ key: key, type: "union" }, { list });
+    }
+    /** 声明一个交叉类型 */
+    static intersect(list, key) {
+        return new Schema({ key: key, type: "intersect" }, { list });
+    }
+    /** 声明一个常量 */
+    static const(value, key) {
+        return new Schema({ key: key, type: "const", default: value });
+    }
+    /** 声明一个任意类型 */
+    static any(key) {
+        return new Schema({ key, type: 'any' });
+    }
+    /** 声明一个空类型 */
+    static never(key) {
+        return new Schema({ key, type: 'never' });
+    }
+    static resolve(type) {
+        return Schema.formatters.get(type);
+    }
+    static extend(type, formatter) {
+        Schema.formatters.set(type, formatter);
+    }
+}
+exports.Schema = Schema;
+(function (Schema) {
+    Schema.formatters = new Map();
+    function checkDefault(schema, value, fallback = value) {
+        const isEmpty = (value) => {
+            if (typeof value === "undefined")
+                return true;
+            if (typeof value === "string" && value === "")
+                return true;
+            if (typeof value === "object" && value === null)
+                return true;
+            if (Array.isArray(value) && value.length === 0)
+                return true;
+            if (value instanceof Date && isNaN(value.getTime()))
+                return true;
+            return value && typeof value === 'object' && Reflect.ownKeys(value).length === 0;
+        };
+        if (isEmpty(value)) {
+            if (typeof schema.meta.default === "function") {
+                value = schema.meta.default();
+            }
+            else {
+                value = schema.meta.default || fallback;
+            }
+        }
+        const validateType = (schema, value) => {
+            var _b, _c;
+            switch (schema.meta.type) {
+                case "string":
+                    if (!['string', 'undefined'].includes(typeof value))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a string`);
+                    break;
+                case "number":
+                    if (!['number', 'undefined'].includes(typeof value))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a number`);
+                    break;
+                case "boolean":
+                    if (!['boolean', 'undefined'].includes(typeof value))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a boolean`);
+                    break;
+                case "regexp":
+                    if (!['string', 'undefined'].includes(typeof value) && !(value instanceof RegExp))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a RegExp|string`);
+                    break;
+                case "date":
+                    if (!['number', 'undefined'].includes(typeof value) && !(value instanceof Date))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a Date|number`);
+                    if (value instanceof Date && isNaN(value.getTime()))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a valid Date`);
+                    break;
+                case "object":
+                case "dict":
+                    if (!['object', 'undefined', 'null'].includes(typeof value))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a object`);
+                    break;
+                case "array":
+                case 'list':
+                    if (typeof value !== 'undefined' && !Array.isArray(value))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a list`);
+                    break;
+                case "tuple":
+                    if (typeof value !== 'undefined' && !Array.isArray(value))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a valid tuple`);
+                    break;
+                case "union":
+                    if (typeof value !== 'undefined' && !((_b = schema.options.list) === null || _b === void 0 ? void 0 : _b.some(item => {
+                        try {
+                            item(value);
+                            return true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    })))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a valid union`);
+                    break;
+                case "intersect":
+                    if (typeof value !== 'undefined' && !((_c = schema.options.list) === null || _c === void 0 ? void 0 : _c.every(item => {
+                        try {
+                            item(value);
+                            return true;
+                        }
+                        catch {
+                            return false;
+                        }
+                    })))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a valid intersect`);
+                    break;
+                case "const":
+                    if (typeof value !== 'undefined' && value !== schema.meta.default)
+                        throw new TypeError(`${schema.meta.key || 'value'} is not const`);
+                    break;
+                case "percent":
+                    if (typeof value !== 'undefined' && (typeof value !== 'number' || value < 0 || value > 1))
+                        throw new TypeError(`${schema.meta.key || 'value'} is not a valid percent`);
+                    break;
+                case "any":
+                    break;
+                case "never":
+                    throw new TypeError(`${schema.meta.key || 'value'} is never`);
+                default:
+                    throw new TypeError(`${schema.meta.key || 'value'} is not a valid type`);
+            }
+        };
+        if (schema.meta.required && typeof value === 'undefined')
+            throw new Error(`${schema.meta.key || 'value'} is required`);
+        validateType(schema, value);
+        return value;
+    }
+    Schema.checkDefault = checkDefault;
+    function formatOptionList(list) {
+        return list.map(item => {
+            if (typeof item === "string") {
+                return {
+                    label: item,
+                    value: item,
+                };
+            }
+            return item;
+        });
+    }
+    Schema.formatOptionList = formatOptionList;
+})(Schema || (exports.Schema = Schema = {}));
+Schema.extend("number", function (value) {
+    value = Schema.checkDefault(this, value);
+    if (this.meta.max && value > this.meta.max)
+        throw new Error(`${this.meta.key || 'value'} is too large`);
+    if (this.meta.min && value < this.meta.min)
+        throw new Error(`${this.meta.key || 'value'} is too small`);
+    return value;
+});
+Schema.extend("string", function (value) {
+    value = Schema.checkDefault(this, value);
+    if (this.meta.max && (value === null || value === void 0 ? void 0 : value.length) > this.meta.max)
+        throw new Error(`${this.meta.key || 'value'} is too long`);
+    if (this.meta.min && (value === null || value === void 0 ? void 0 : value.length) < this.meta.min)
+        throw new Error(`${this.meta.key || 'value'} is too short`);
+    return value;
+});
+Schema.extend("boolean", function (value) {
+    return Schema.checkDefault(this, value);
+});
+Schema.extend("dict", function (value) {
+    value = Schema.checkDefault(this, value, {});
+    return Object.fromEntries(Object.entries(value).map(([key, schema]) => {
+        return [key, this.options.inner(value[key])];
+    }));
+});
+Schema.extend("list", function (value) {
+    value = Schema.checkDefault(this, value, []);
+    return value.map((item) => this.options.inner(item));
+});
+Schema.extend("object", function (value) {
+    value = Schema.checkDefault(this, value, {});
+    return Object.fromEntries(Object.entries(this.options.dict).map(([key, schema]) => {
+        return [key, schema(value[key])];
+    }));
+});
+Schema.extend("tuple", function (value) {
+    value = Schema.checkDefault(this, value, []);
+    return value.map((item, index) => this.options.list[index](item));
+});
+Schema.extend("union", function (value) {
+    value = Schema.checkDefault(this, value, []);
+    for (const schema of this.options.list) {
+        try {
+            return schema(value);
+        }
+        catch (e) { }
+    }
+    throw new Error("union type not match");
+});
+Schema.extend("regexp", function (value) {
+    value = Schema.checkDefault(this, value);
+    if (typeof value === "string") {
+        return new RegExp(value);
+    }
+    return value;
+});
+Schema.extend("intersect", function (value) {
+    value = Schema.checkDefault(this, value, []);
+    for (const schema of this.options.list) {
+        try {
+            value = schema(value);
+        }
+        catch (e) {
+            throw new Error("intersect type not match");
+        }
+    }
+    return value;
+});
+Schema.extend('never', function (value) {
+    throw new Error('never type not match');
+});
+Schema.extend("any", function (value) {
+    return value;
+});
+Schema.extend("date", function (value) {
+    value = Schema.checkDefault(this, value);
+    return new Date(value);
+});
+Schema.extend("const", function (value) {
+    value = Schema.checkDefault(this, value);
+    if (value !== this.meta.default) {
+        throw new Error("const value not match");
+    }
+    return value;
+});
+Schema.extend("percent", function (value) {
+    value = Schema.checkDefault(this, value);
+    return value;
+});

package/lib/test.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const str = index_1.Schema.string().default('123')('456');
+console.log(str);
+const num = index_1.Schema.number().default(123)(456);
+console.log(num);
+const bool = index_1.Schema.boolean().default(false)(true);
+console.log(bool);
+const reg = index_1.Schema.regexp().default(/123/)();
+console.log(reg);
+const date = index_1.Schema.date().default(new Date())(new Date().getTime() + 1000 * 60 * 60 * 24);
+console.log(date);
+const percent = index_1.Schema.percent().default(0.5).step(0.1)(0.6);
+console.log(percent);
+const dict = index_1.Schema.dict(index_1.Schema.object({
+    name: index_1.Schema.string().default('123'),
+    age: index_1.Schema.number().default(123),
+    performance: index_1.Schema.array(index_1.Schema.string()).default(['123']).description('爱好')
+}))({
+    zs: {}
+});
+console.log(dict);
+const arr = index_1.Schema.list(index_1.Schema.object({
+    name: index_1.Schema.string().default('123'),
+    age: index_1.Schema.number().default(123)
+}))();
+console.log(arr);
+const obj = index_1.Schema.object({
+    name: index_1.Schema.string().default('123'),
+    age: index_1.Schema.number().default(123)
+})();
+console.log(obj);
+const tuple = index_1.Schema.tuple([
+    index_1.Schema.const('123'),
+    index_1.Schema.const(123)
+])();
+console.log(tuple);
+const union = index_1.Schema.union([
+    index_1.Schema.string().default('123'),
+    index_1.Schema.number().default(123)
+])();
+console.log(union);
+const intersect = index_1.Schema.intersect([
+    index_1.Schema.const('123'),
+    index_1.Schema.string(),
+])('123');
+console.log('intersect', intersect);
+const formatter = index_1.Schema.dict(index_1.Schema.list(index_1.Schema.object({
+    foo: index_1.Schema.string().option(['1', '3']),
+    bar: index_1.Schema.list(index_1.Schema.number()).default([123]).option([
+        {
+            label: '123',
+            value: 123
+        }
+    ])
+})));
+const params = formatter({
+    az: [
+        { foo: '456' }
+    ]
+});
+console.log(JSON.stringify(formatter, null, 2), params);
+const json = {
+    type: 'object',
+    dict: {
+        foo: {
+            type: 'string',
+            default: '123',
+        },
+        bar: {
+            type: 'number',
+            default: 123
+        }
+    }
+};
+const schema = index_1.Schema.fromJSON(json);
+console.log(schema({ foo: '456' }));

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@zhin.js/schema",
+  "version": "0.0.14",
+  "description": "zhin配置声明模块",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zhinjs/zhin.git",
+    "directory": "basic/schema"
+  },
+  "keywords": [
+    "schema",
+    "zhin",
+    "zhinjs"
+  ],
+  "author": "凉菜",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/zhinjs/zhin/issues"
+  },
+  "homepage": "https://github.com/zhinjs/zhin/tree/main/basic/schema#readme",
+  "devDependencies": {
+    "@types/node": "latest",
+    "dtsc": "^2.3.0",
+    "ts-node-dev": "latest",
+    "tsc-alias": "latest",
+    "tsconfig-paths": "latest",
+    "typescript": "latest"
+  },
+  "files": [
+    "/lib/**/*.js",
+    "/lib/**/*.d.ts",
+    "/lib/**/LICENSE"
+  ],
+  "dependencies": {
+    "@zhinjs/shared": "^0.0.7"
+  },
+  "scripts": {
+    "start": "node .",
+    "compile": "tsc --project tsconfig.build.json && tsc-alias -p tsconfig.build.json",
+    "build": "npm run compile && dtsc --project tsconfig.dtsc.json",
+    "dev": "ts-node-dev -r tsconfig-paths/register ./src/test.ts",
+    "pub": "npm publish --access public",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}