From 48d5d572354a9431cdeca00d9f52279899ba62f4 Mon Sep 17 00:00:00 2001 From: Karsten Schmidt Date: Wed, 28 Nov 2018 17:38:53 +0000 Subject: [PATCH] feat(vector-pools): add VecPool, VecArrayList & VecLinkedList --- packages/vector-pools/.npmignore | 11 ++ packages/vector-pools/LICENSE | 201 +++++++++++++++++++++++ packages/vector-pools/README.md | 47 ++++++ packages/vector-pools/package.json | 42 +++++ packages/vector-pools/src/alist.ts | 75 +++++++++ packages/vector-pools/src/api.ts | 21 +++ packages/vector-pools/src/array-list.ts | 64 ++++++++ packages/vector-pools/src/index.ts | 0 packages/vector-pools/src/linked-list.ts | 155 +++++++++++++++++ packages/vector-pools/src/pool.ts | 91 ++++++++++ packages/vector-pools/src/wrap.ts | 19 +++ packages/vector-pools/test/index.ts | 6 + packages/vector-pools/test/tsconfig.json | 10 ++ packages/vector-pools/tsconfig.json | 9 + 14 files changed, 751 insertions(+) create mode 100644 packages/vector-pools/.npmignore create mode 100644 packages/vector-pools/LICENSE create mode 100644 packages/vector-pools/README.md create mode 100644 packages/vector-pools/package.json create mode 100644 packages/vector-pools/src/alist.ts create mode 100644 packages/vector-pools/src/api.ts create mode 100644 packages/vector-pools/src/array-list.ts create mode 100644 packages/vector-pools/src/index.ts create mode 100644 packages/vector-pools/src/linked-list.ts create mode 100644 packages/vector-pools/src/pool.ts create mode 100644 packages/vector-pools/src/wrap.ts create mode 100644 packages/vector-pools/test/index.ts create mode 100644 packages/vector-pools/test/tsconfig.json create mode 100644 packages/vector-pools/tsconfig.json diff --git a/packages/vector-pools/.npmignore b/packages/vector-pools/.npmignore new file mode 100644 index 0000000000..ec83d74c9d --- /dev/null +++ b/packages/vector-pools/.npmignore @@ -0,0 +1,11 @@ +build +coverage +dev +doc +export +src* +test +.nyc_output +tsconfig.json +*.tgz +*.html diff --git a/packages/vector-pools/LICENSE b/packages/vector-pools/LICENSE new file mode 100644 index 0000000000..8dada3edaf --- /dev/null +++ b/packages/vector-pools/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright {yyyy} {name of copyright owner} + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/packages/vector-pools/README.md b/packages/vector-pools/README.md new file mode 100644 index 0000000000..abd92336b2 --- /dev/null +++ b/packages/vector-pools/README.md @@ -0,0 +1,47 @@ +# @thi.ng/vector-pools + +[![npm (scoped)](https://img.shields.io/npm/v/@thi.ng/vector-pools.svg)](https://www.npmjs.com/package/@thi.ng/vector-pools) +![npm downloads](https://img.shields.io/npm/dm/@thi.ng/vector-pools.svg) +[![Twitter Follow](https://img.shields.io/twitter/follow/thing_umbrella.svg?style=flat-square&label=twitter)](https://twitter.com/thing_umbrella) + +This project is part of the +[@thi.ng/umbrella](https://github.com/thi-ng/umbrella/) monorepo. + + + +- [About](#about) +- [Installation](#installation) +- [Dependencies](#dependencies) +- [Usage examples](#usage-examples) +- [Authors](#authors) +- [License](#license) + + + +## About + +TODO... + +## Installation + +```bash +yarn add @thi.ng/vector-pools +``` + +## Dependencies + +- TODO... + +## Usage examples + +```ts +import * as vp from "@thi.ng/vector-pools"; +``` + +## Authors + +- Karsten Schmidt + +## License + +© 2018 Karsten Schmidt // Apache Software License 2.0 diff --git a/packages/vector-pools/package.json b/packages/vector-pools/package.json new file mode 100644 index 0000000000..71edf5da38 --- /dev/null +++ b/packages/vector-pools/package.json @@ -0,0 +1,42 @@ +{ + "name": "@thi.ng/vector-pools", + "version": "0.0.1", + "description": "TODO", + "main": "./index.js", + "typings": "./index.d.ts", + "repository": { + "type": "git", + "url": "https://github.com/thi-ng/umbrella.git" + }, + "homepage": "https://github.com/thi-ng/umbrella/tree/master/packages/vector-pool", + "author": "Karsten Schmidt ", + "license": "Apache-2.0", + "scripts": { + "build": "yarn run clean && tsc --declaration", + "clean": "rm -rf *.js *.d.ts .nyc_output build coverage doc", + "cover": "yarn test && nyc report --reporter=lcov", + "doc": "node_modules/.bin/typedoc --mode modules --out doc src", + "pub": "yarn run build && yarn publish --access public", + "test": "rm -rf build && tsc -p test && nyc mocha build/test/*.js" + }, + "devDependencies": { + "@types/mocha": "^5.2.5", + "@types/node": "^10.12.0", + "mocha": "^5.2.0", + "nyc": "^13.1.0", + "typedoc": "^0.13.0", + "typescript": "^3.1.3" + }, + "dependencies": { + "@thi.ng/api": "^4.2.3", + "@thi.ng/malloc": "^0.2.0", + "@thi.ng/vectors3": "^0.0.1" + }, + "keywords": [ + "ES6", + "typescript" + ], + "publishConfig": { + "access": "public" + } +} \ No newline at end of file diff --git a/packages/vector-pools/src/alist.ts b/packages/vector-pools/src/alist.ts new file mode 100644 index 0000000000..44b6e5796e --- /dev/null +++ b/packages/vector-pools/src/alist.ts @@ -0,0 +1,75 @@ +import { IVector, Vec } from "@thi.ng/vectors3/api"; +import { wrap } from "./wrap"; +import { VecFactory } from "./api"; + +export abstract class AVecList> { + + buffer: Vec; + factory: VecFactory; + + start: number; + capacity: number; + curr: number; + size: number; + estride: number; + cstride: number; + + _free: T[]; + + constructor( + buffer: Vec, + capacity: number, + size: number, + factory: VecFactory = wrap, + cstride = 1, + estride = size, + start = 0) { + + this.buffer = buffer; + this.size = size; + this.factory = factory; + this.cstride = cstride; + this.estride = estride; + this.start = this.curr = start; + this.capacity = capacity; + this._free = []; + } + + abstract [Symbol.iterator](): IterableIterator; + + abstract get length(): number; + + abstract add(): T; + + abstract insert(i: number): T; + + abstract remove(v: T): boolean; + + indices(res: Vec = [], i = 0, local = true) { + const start = this.start; + const estride = this.estride; + if (local) { + for (let v of this) { + res[i++] = (v.i - start) / estride; + } + } else { + for (let v of this) { + res[i++] = v.i; + } + } + return res; + } + + protected alloc() { + let v: T; + if (this._free.length > 0) { + v = this._free.pop(); + } else { + if (this.length < this.capacity) { + v = this.factory(this.buffer, this.size, this.curr, this.cstride); + this.curr += this.estride; + } + } + return v; + } +} diff --git a/packages/vector-pools/src/api.ts b/packages/vector-pools/src/api.ts new file mode 100644 index 0000000000..24a43c120b --- /dev/null +++ b/packages/vector-pools/src/api.ts @@ -0,0 +1,21 @@ +import { IRelease, TypedArray } from "@thi.ng/api/api"; +import { Type } from "@thi.ng/malloc/api"; +import { IVector, Vec } from "@thi.ng/vectors3/api"; + +export interface IVecPool extends IRelease { + + malloc(size: number, type?: Type): TypedArray; + + mallocWrapped(size: number, stride?: number, type?: Type): IVector; + + mallocArray(num: number, size: number, cstride?: number, estride?: number, type?: Type): IVector[]; + + free(vec: IVector | TypedArray): boolean; + + freeAll(); +} + +export type VecFactory = + (buf: Vec, size: number, index: number, stride: number) => IVector; + +export { Type }; diff --git a/packages/vector-pools/src/array-list.ts b/packages/vector-pools/src/array-list.ts new file mode 100644 index 0000000000..9c24347fe8 --- /dev/null +++ b/packages/vector-pools/src/array-list.ts @@ -0,0 +1,64 @@ +import { IVector, Vec } from "@thi.ng/vectors3/api"; +import { AVecList } from "./alist"; +import { VecFactory } from "./api"; + +export class VecArrayList> extends AVecList { + + items: T[]; + + /** + * + * @param buffer + * @param capacity + * @param size + * @param cstride + * @param estride + * @param start + */ + constructor( + buffer: Vec, + capacity: number, + size: number, + factory?: VecFactory, + cstride = 1, + estride = size, + start = 0) { + + super(buffer, capacity, size, factory, cstride, estride, start); + this.items = []; + } + + *[Symbol.iterator]() { + yield* this.items; + } + + get length() { + return this.items.length; + } + + add() { + const v: T = this.alloc(); + if (v) { + this.items.push(v); + } + return v; + } + + insert(i: number) { + if (!this.length && i !== 0) return; + const v: T = this.alloc(); + if (v) { + this.items.splice(i, 0, v); + } + return v; + } + + remove(v: T) { + const idx = this.items.indexOf(v); + if (idx >= 0) { + this._free.push(v); + this.items.splice(idx, 1); + return true; + } + } +} diff --git a/packages/vector-pools/src/index.ts b/packages/vector-pools/src/index.ts new file mode 100644 index 0000000000..e69de29bb2 diff --git a/packages/vector-pools/src/linked-list.ts b/packages/vector-pools/src/linked-list.ts new file mode 100644 index 0000000000..762aae9e4b --- /dev/null +++ b/packages/vector-pools/src/linked-list.ts @@ -0,0 +1,155 @@ +import { IVector, Vec } from "@thi.ng/vectors3/api"; +import { AVecList } from "./alist"; +import { VecFactory } from "./api"; + +export class VecLinkedList> extends AVecList { + + head: T; + tail: T; + closed: boolean; + + protected _length: number; + + /** + * + * @param closed + * @param buffer + * @param capacity + * @param size + * @param factory + * @param cstride + * @param estride + * @param start + */ + constructor( + closed: boolean, + buffer: Vec, + capacity: number, + size: number, + factory?: VecFactory, + cstride = 1, + estride = size, + start = 0) { + + super(buffer, capacity, size, factory, cstride, estride, start); + this.closed = closed; + this.head = null; + this.tail = null; + this._length = 0; + } + + *[Symbol.iterator]() { + if (this._length) { + let v: any = this.head; + const first = v; + do { + yield v; + v = v.next; + } while (v && v !== first); + } + } + + get length() { + return this._length; + } + + add(): T { + const v: any = this.alloc(); + if (v) { + if (this.tail) { + v.prev = this.tail; + (this.tail).next = v; + this.tail = v; + if (this.closed) { + v.next = this.head; + (this.head).prev = v; + } + this._length++; + } else { + this.tail = this.head = v; + v.next = v.prev = this.closed ? v : null; + this._length++; + } + } + return v; + } + + insert(i: number): T { + if (!this._length) { + return i === 0 ? this.add() : undefined; + } + const q: any = this.nth(i); + if (!q) return; + const v: any = this.alloc(); + if (v) { + v.next = q; + v.prev = q.prev; + if (q.prev) { + q.prev.next = v; + } else { + this.head = v; + } + q.prev = v; + this._length++; + } + return v; + } + + remove(vec: T): boolean { + if (this.has(vec)) { + this._length--; + this._free.push(vec); + const v: any = vec; + if (v.prev) { + v.prev.next = v.next; + } + if (this.head === v) { + this.head = this._length ? v.next : null; + } + if (v.next) { + v.next.prev = v.prev; + } + if (this.tail === v) { + this.tail = this._length ? v.prev : null; + } + delete v.prev; + delete v.next; + return true; + } + } + + has(value: T) { + let v: any = this.head; + const first = v; + do { + if (v === value) { + return true; + } + v = v.next; + } while (v && v !== first); + return false; + } + + nth(n: number): T { + if (n < 0) { + n += this._length; + } + if (n < 0 || n >= this._length) { + return; + } + let v; + if (n <= this._length >> 1) { + v = this.head; + while (n-- > 0 && v) { + v = v.next; + } + } else { + v = this.tail; + n = this._length - n - 1; + while (n-- > 0 && v) { + v = v.prev; + } + } + return v; + } +} diff --git a/packages/vector-pools/src/pool.ts b/packages/vector-pools/src/pool.ts new file mode 100644 index 0000000000..8c41846e06 --- /dev/null +++ b/packages/vector-pools/src/pool.ts @@ -0,0 +1,91 @@ +import { TypedArray } from "@thi.ng/api"; +import { isTypedArray } from "@thi.ng/checks/is-typedarray"; +import { + MemPool, + MemPoolOpts, + MemPoolStats, + Type +} from "@thi.ng/malloc"; +import { IVecPool, IVector } from "@thi.ng/vectors3//api"; +import { wrap } from "./wrap"; + +export class VecPool implements + IVecPool { + + pool: MemPool; + + constructor(pool: MemPool); + constructor(buf: number | ArrayBuffer, opts?: Partial); + constructor(pool: any, opts?: Partial) { + this.pool = !(pool instanceof MemPool) ? + new MemPool(pool, opts) : + pool; + } + + stats(): MemPoolStats { + return this.pool.stats(); + } + + malloc(size: number, type: Type = Type.F32): TypedArray { + return this.pool.callocAs(type, size); + } + + mallocWrapped(size: number, stride = 1, type: Type = Type.F32): IVector { + const buf = this.pool.callocAs(type, size * stride); + return wrap(buf, size, 0, stride); + + } + + /** + * Intended to provide individual vector views of a larger + * underlying buffer. Attempts to allocate a single block of + * sufficient memory to hold `num` vectors of `size` elements and if + * successful returns array of vectors mapping the buffer with given + * stride lengths (both component and element strides can be + * provided). + * + * *Note:* Since all result vectors share the same continuous memory + * block, freeing any of them from the pool will invalidate all of + * them. + * + * Also see: + * - `Vec2.mapBuffer()` + * - `Vec3.mapBuffer()` + * - `Vec4.mapBuffer()` + * - `NDArray1.mapBuffer()` + * + * @param num + * @param size + * @param cstride + * @param estride + * @param type + */ + mallocArray(num: number, size: number, cstride = 1, estride = size, type: Type = Type.F32): IVector[] { + const buf = this.malloc(Math.max(cstride, estride, size) * num, type); + if (!buf) return; + const res: IVector[] = []; + for (let i = 0; i < num; i += estride) { + res.push(wrap(buf, size, i, cstride)); + } + return res; + } + + free(vec: IVector | TypedArray) { + const buf = (vec).buf; + return buf ? + isTypedArray(buf) ? + this.pool.free(buf) : + false : + this.pool.free(vec); + } + + freeAll() { + this.pool.freeAll(); + } + + release() { + const res = this.pool.release(); + res && delete this.pool; + return res; + } +} diff --git a/packages/vector-pools/src/wrap.ts b/packages/vector-pools/src/wrap.ts new file mode 100644 index 0000000000..0d2440b396 --- /dev/null +++ b/packages/vector-pools/src/wrap.ts @@ -0,0 +1,19 @@ +import { IVector, Vec } from "@thi.ng/vectors3/api"; +import { gvec } from "@thi.ng/vectors3/gvec"; +import { Vec2 } from "@thi.ng/vectors3/vec2"; +import { Vec3 } from "@thi.ng/vectors3/vec3"; +import { Vec4 } from "@thi.ng/vectors3/vec4"; + +export const wrap = + (buf: Vec, size: number, idx: number, stride: number): IVector => { + switch (size) { + case 2: + return new Vec2(buf, idx, stride); + case 3: + return new Vec3(buf, idx, stride); + case 4: + return new Vec4(buf, idx, stride); + default: + return gvec(buf, size, idx, stride); + } + }; diff --git a/packages/vector-pools/test/index.ts b/packages/vector-pools/test/index.ts new file mode 100644 index 0000000000..b8c58a8837 --- /dev/null +++ b/packages/vector-pools/test/index.ts @@ -0,0 +1,6 @@ +// import * as assert from "assert"; +// import * as vp from "../src/index"; + +describe("vector-pools", () => { + it("tests pending"); +}); diff --git a/packages/vector-pools/test/tsconfig.json b/packages/vector-pools/test/tsconfig.json new file mode 100644 index 0000000000..bcf29ace54 --- /dev/null +++ b/packages/vector-pools/test/tsconfig.json @@ -0,0 +1,10 @@ +{ + "extends": "../../../tsconfig.json", + "compilerOptions": { + "outDir": "../build" + }, + "include": [ + "./**/*.ts", + "../src/**/*.ts" + ] +} diff --git a/packages/vector-pools/tsconfig.json b/packages/vector-pools/tsconfig.json new file mode 100644 index 0000000000..bd6481a5a6 --- /dev/null +++ b/packages/vector-pools/tsconfig.json @@ -0,0 +1,9 @@ +{ + "extends": "../../tsconfig.json", + "compilerOptions": { + "outDir": "." + }, + "include": [ + "./src/**/*.ts" + ] +}