v2.0.0

.gitattributes

@@ -1,2 +1 @@
 * text eof=lf
-*.png binary

.npmignore

@@ -1,15 +0,0 @@
-.vscode/
-coverage/
-docs/
-node_modules/
-src/
-tests/
-.editorconfig
-.gitattributes
-.gitignore
-.travis.yml
-jest.json
-tsconfig.build.json
-tsconfig.json
-tslint.json
-yarn.lock

.travis.yml

@@ -9,7 +9,6 @@ env:
 script:
   - if [ "$JOB" = "lint" ]; then yarn run lint; fi
   - if [ "$JOB" = "test" ]; then yarn run test-ci; fi
-  - if [ "$JOB" = "build" ]; then yarn run build; fi
   - if [ "$JOB" = "test-coverage" ]; then yarn run test-coverage-ci && yarn run coverage-ci; fi
 
 cache:
@@ -22,8 +21,6 @@ matrix:
   include:
     - node_js: "stable"
       env: JOB=lint
-    - node_js: "stable"
-      env: JOB=build
     - node_js: "stable"
       env: JOB=test-coverage
 

CHANGELOG.md

@@ -10,6 +10,26 @@ All changes to this project will be documented in this file.
 > - 🏠 [Internal]
 > - 💅 [Polish]
 
+## Unreleased
+
+#### 💥 Breaking Change
+- package
+  - all elements are pure object now
+  - use `dts.emit(dts_element)` instead of `dts_element.emit()`
+  - use `dts.create_element(options)` instead of `new dts.Element(options)`
+- advanced
+  - remove curry-relative functions since it should not be a part of DOM library
+
+#### 🚀 New Feature
+- comments
+  - support `single-line-comment` and `multi-line-comment` element, or using `comments` field in every element
+- parsers
+  - support parsing TypeScript syntax into `dts-element` ( `dts.parse()` ), useful for restructuring types
+
+#### 🏠 Internal
+- package
+  - rewrite using TypeScript Printer API
+
 ## v1.3.0 (2017-05-10)
 
 #### 🚀 New Feature

README.md

@@ -9,16 +9,11 @@ A DOM library for generation TypeScript declaration (.d.ts) files
 [Changelog](https://github.com/ikatyang/dts-element/blob/master/CHANGELOG.md) - [Examples](https://github.com/ikatyang/dts-element/tree/master/tests/) - [Documentation](https://ikatyang.github.io/dts-element/)
 
 ## Features
-
 - reusable
   - `FunctionDeclaration`: it can be method or function based on where it is.
   - `VariableDeclaration`: it can be property or variable based on where it is.
-- clonable
-  - `element.clone(is_deep_clone: boolean = false)`
-  - `element.copy(element: Element, is_deep_copy: boolean = false)`
-- advanced
-  - `create_curried_function_interfaces()`
-  - `create_curried_function_types()` [[example](#curried-function-types)]
+- parsable
+  - parsing TypeScript syntax into `dts-element` using `dts.parse()`, useful for restructuring types
 
 ## Installation
 
@@ -36,138 +31,62 @@ yarn add dts-element
 
 ## Usage
 
-#### normal
-
-Sample
+Code
 
 ```ts
 import * as dts from 'dts-element';
 
-const interface_MyInterface = new dts.InterfaceDeclaration({
+const getThing = dts.create_function_declaration({
+  name: 'getThing',
+  type: dts.create_function_type({
+    parameters: [
+      dts.create_parameter_declaration({
+        name: 'x',
+        type: dts.number_type,
+      }),
+    ],
+    return: dts.void_type,
+  }),
+});
+
+const MyInterface = dts.create_interface_declaration({
   name: 'MyInterface',
   jsdoc: 'This is my nice interface',
-  members: [
-    new dts.ObjectMember({
-      owned: new dts.FunctionDeclaration({
-        name: 'getThing',
+  type: dts.create_object_type({
+    members: [
+      dts.create_object_member({
         optional: true,
-        type: new dts.FunctionType({
-          parameters: [
-            new dts.Parameter({
-              name: 'x',
-              type: dts.number_type,
-            }),
-          ],
-          return: dts.void_type,
-        }),
+        owned: getThing,
       }),
-    }),
-  ],
+    ],
+  }),
 });
 
-const namespace_SomeNamespace = new dts.NamespaceDeclaration({
+const SomeNamespace = dts.create_namespace_declaration({
   name: 'SomeNamespace',
-  children: [interface_MyInterface],
-});
-
-const doucment = new dts.Document({
-  children: [namespace_SomeNamespace],
+  members: [MyInterface],
 });
 
-console.log(doucment.emit());
+console.log(dts.emit(
+  dts.create_top_level_element({
+    members: [SomeNamespace],
+  }),
+));
 ```
 
 Output
 
 ```ts
 declare namespace SomeNamespace {
-  /**
-   * This is my nice interface
-   */
-  interface MyInterface {
-    getThing?(x: number): void;
-  }
+    /**
+      * This is my nice interface
+      */
+    interface MyInterface {
+        getThing?(x: number): void;
+    }
 }
 ```
 
-#### curried-function-types
-
-Sample
-
-```ts
-import * as dts from 'dts-element';
-
-const name = 'adjust';
-const placeholder = new dts.BasicType({name: 'PH'});
-
-const generic_T = new dts.GenericType({name: 'T'});
-const generic_U = new dts.GenericType({name: 'U'});
-
-// <T, U>(fn: (v: T) => U, index: number, array: T[]) => (T | U)[]
-const function_type = new dts.FunctionType({
-  generics: [generic_T, generic_U],
-  parameters: [
-    new dts.Parameter({
-      name: 'fn',
-      type: new dts.FunctionType({
-        parameters: [
-          new dts.Parameter({name: 'v', type: generic_T}),
-        ],
-        return: generic_U,
-      }),
-    }),
-    new dts.Parameter({name: 'index', type: dts.number_type}),
-    new dts.Parameter({name: 'array', type: new dts.ArrayType({owned: generic_T})}),
-  ],
-  return: new dts.ArrayType({owned: new dts.UnionType({types: [generic_T, generic_U]})}),
-});
-
-const types = dts.create_curried_function_types({name, type: function_type, placeholder});
-const document = new dts.Document({children: types});
-
-console.log(document.emit());
-```
-
-Output
-
-```ts
-type adjust = adjust_000;
-type adjust_000 = {
-  <T, U>(fn: (v: T) => U, index: number, array: T[]): adjust_111<T, U>;
-  <T, U>(fn: (v: T) => U, _index: PH, array: T[]): adjust_101<T, U>;
-  <T>(_fn: PH, index: number, array: T[]): adjust_011<T>;
-  <T>(_fn: PH, _index: PH, array: T[]): adjust_001<T>;
-  <T, U>(fn: (v: T) => U, index: number): adjust_110<T, U>;
-  (_fn: PH, index: number): adjust_010;
-  <T, U>(fn: (v: T) => U): adjust_100<T, U>;
-};
-type adjust_001<T> = {
-  <U>(fn: (v: T) => U, index: number): adjust_111<T, U>;
-  (_fn: PH, index: number): adjust_011<T>;
-  <U>(fn: (v: T) => U): adjust_101<T, U>;
-};
-type adjust_010 = {
-  <T, U>(fn: (v: T) => U, array: T[]): adjust_111<T, U>;
-  <T>(_fn: PH, array: T[]): adjust_011<T>;
-  <T, U>(fn: (v: T) => U): adjust_110<T, U>;
-};
-type adjust_011<T> = {
-  <U>(fn: (v: T) => U): adjust_111<T, U>;
-};
-type adjust_100<T, U> = {
-  (index: number, array: T[]): adjust_111<T, U>;
-  (_index: PH, array: T[]): adjust_101<T, U>;
-  (index: number): adjust_110<T, U>;
-};
-type adjust_101<T, U> = {
-  (index: number): adjust_111<T, U>;
-};
-type adjust_110<T, U> = {
-  (array: T[]): adjust_111<T, U>;
-};
-type adjust_111<T, U> = (T | U)[];
-```
-
 ## Development
 
 ```sh