fix: bugs (#12)

* fix: fix stack-tracking parse bug

* chore: update readme and help message

* fix(tagged-template): support array substitution

* chore: add type-check command

* perf: add option to forceIntegrate

Author: whatasoda

README.md

@@ -100,13 +100,17 @@ const createFileInformationMap = typeshot.registerTypeDefinition((createTypeFrag
 });
 ```
 
-`typeshot.registerTypeDefinition` is a core API to create custom type definitions. It receives a function to describe type definition and returns a function to instantiate type definition.
+`typeshot.registerTypeDefinition` is a core API to create custom type definitions. It receives a function to describe type definition and returns a function to instantiate type definition. `typeshot` converts returned value of the describer function into type definitions by parsing the value down to `TypeFragment` and usual values and evaluating them. You can see how `typeshot` evaluates `TypeFragment` and values, by enabling a CLI Option `-E`/`--emitIntermediateFiles`.
 
-The describer function receives a utility function called `createTypeFragment` and arguments which come from the instantiator function.
+The describer function receives a utility function called `createTypeFragment` and rest arguments which come from the instantiator function. There are two steps to instantiate type definitions, the first step is to pass arguments that the describer function requires, and the second step is to specify type format and type name.
 
-`typeshot` converts returned value of the describer function into type definitions by parsing the value down to `TypeFragment` and usual values and evaluating them.
-
-You can see how `typeshot` evaluates `TypeFragment` and values, by enabling a CLI Option `-E`/`--emitIntermediateFiles`.
+In this example, it passes `paths` to describer function and specifies to output the instance as interface named `FileInformationMap`. Make sure to use `typeshot.print` to commit instances to the result.
+```ts
+typeshot.print`
+// Hello, I'm comment.
+export ${createFileInformationMap(paths).interface('FileInformationMap')}
+`;
+```
 
 #### `TypeFragment`
 `TypeFragment` is a special object which contains information to connect values and types.
@@ -122,7 +126,7 @@ const fragment = createTypeFragment<{ [K in typeof p]: FileType[typeof extname]
 
 Note that the names of type query target must match with the keys of object at the argument.
 
-### Intersection Types
+#### Intersection Types
 As the example does, you can merge `TypeFragment` into a one object. Merged object is evaluated as an intersection type. In this example, it's internally evaluated as like this:
 ```ts
 & { [K in './foo/bar.ts']: FileType['.ts'] }
@@ -164,9 +168,9 @@ type Example = ${example().literal()};
 This example will be evaluated into `type Example = 'foo' | 'bar' | 'baz';`.
 
 ### `print`
-To commit type definition instance to result, you need to use `typeshot.print`. It's accepts Tagged Template Literal.
+`typeshot.print` is a tag function to commit type definition instance to result.
 
-As the example does, you can specify type format and name. You can specify extra strings to add comments, modifiers, etc.
+As the example does, it accepts extra contents to add comments, modifiers, etc.
 ```ts
 typeshot.print`
 // Hello, I'm comment.

package.json

@@ -5,6 +5,7 @@
   "main": "index.js",
   "scripts": {
     "build": "rimraf ./lib && tsc -p tsconfig.lib.json && cp package.json README.md LICENSE ./lib",
+    "type-check": "tsc --noEmit -p tsconfig.lib.json",
     "test": "jest",
     "prepare": "mkdir -p node_modules/typeshot && echo \"export * as m from '../../src';\" > node_modules/typeshot/index.d.ts && echo \"module.exports = require('../../src')\" > node_modules/typeshot/index.js"
   },

src/cli/bin.ts

@@ -141,9 +141,47 @@ export const parseCLIOptions = (argv: string[]) => {
 const exitWithHelp = (error?: string) => {
   if (error) console.log(error);
   console.log(`
-typeshot
+SYNOPSIS
+typeshot [--outFile <path> | --outDir <path>] [--basePath <path>] [--rootDir <dir>] [--project <path>]
+          [--prettierConfig <path>] [--systemModule <path>] [--maxParallel <count>] [--emitIntermediateFiles]
+          [--inputFile <path> | [--] <path>...]
 
-Help:
+OPTIONS
+        <path>...
+            input file paths
+
+        -h, --help
+            display this message
+
+        -i, --inputFile
+            input file path
+
+        -o, --outFile
+            output file path, make sure to use with --inputFile
+
+        -O, --outDir
+            output directory path
+
+        -b, --basePath
+            base path to resolve relative paths, default value is process.cwd()
+
+        -p, --project
+            tsconfig path, default value is tsconfig.json
+
+        --rootDir
+            root directory to resolve output file path with outDir, basePath is used if omitted
+
+        --prettierConfig
+            prettier config path
+
+        --systemModule
+            see README.md about detail, default value is 'typescript'
+
+        --maxParallel
+            max number of subprocess, default value is 3
+
+        -E, --emitIntermediateFiles
+            whether to emit intermediate files, default value is false
 `);
   process.exit(error ? 1 : 0);
 };

src/program/intermediate-type/create-template.ts

@@ -1,7 +1,7 @@
 import ts from 'typescript';
 import { getNodeByStack } from '../../utils/ast';
 import { AstTemplate } from '../../utils/ast-template';
-import { CodeStack } from '../../utils/stack-tracking';
+import { TypeFragmentInfo } from '../type-definition';
 
 interface TemplateSector {
   types: FragmentAstTemplate[];
@@ -34,21 +34,29 @@ export class FragmentAstTemplate extends AstTemplate<string, [dependencies: Map<
 }
 
 export const createFragmentTemplate = (
-  fragmentId: string,
-  stack: CodeStack,
+  fragmentInfo: TypeFragmentInfo,
   sourceFile: ts.SourceFile,
   sourceText: string,
 ): FragmentTemplate => {
-  const { nodePath } = getNodeByStack(stack, sourceFile, ts.isCallExpression);
+  const { nodePath } = getNodeByStack(fragmentInfo.stack, sourceFile, ts.isCallExpression);
   const nearestCallExpression = nodePath[nodePath.length - 1];
   if (!nearestCallExpression.typeArguments || nearestCallExpression.typeArguments.length !== 1) {
     const length = nearestCallExpression.typeArguments?.length || 0;
     throw new RangeError(
-      `Invalid Type Argument Range: 'createTypeFragment' requires 1 type argument, but received ${length} at '${fragmentId}'`,
+      `Invalid Type Argument Range: 'createTypeFragment' requires 1 type argument, but received ${length} at '${fragmentInfo.id}'`,
     );
   }
 
   const node = nearestCallExpression.typeArguments[0];
+  if (fragmentInfo.forceIntegrate) {
+    return {
+      solubleSigs: null,
+      solubleTypes: new FragmentAstTemplate(node, sourceText).wrap('(', ')'),
+      insolubleSigs: null,
+      insolubleTypes: null,
+    };
+  }
+
   const { soluble: S, insoluble: I } = parseFragmentTypeNode(undefined, node, sourceText);
   return {
     solubleSigs: S.sigs.length ? new FragmentAstTemplate(null).append(S.sigs) : null,

src/program/intermediate-type/create-type-text.ts

@@ -116,5 +116,5 @@ const finalizeIntermediateTypeText = (
     result.push(`{${nestedInsolubleSigs.join('')}}`);
   }
 
-  return result.join(' & ');
+  return result.join(' & ') || '{}';
 };

src/program/type-definition.ts

@@ -4,12 +4,16 @@ import { TypeInstance } from '../typeshot/type-instance';
 import { getNodeByPosition, getNodeByStack, getSourceFileByStack } from '../utils/ast';
 import { FragmentTemplate, createFragmentTemplate } from './intermediate-type/create-template';
 import { evaluateIntermediateTypeNode } from './intermediate-type/evaluate-type-node';
+import { TypeFragmentInfoInit } from '../typeshot/register-type-definition';
 
-type FragmentInfo = CodeStack;
+export interface TypeFragmentInfo extends TypeFragmentInfoInit {
+  id: string;
+  stack: CodeStack;
+}
 export interface TypeDefinitionInfo {
   id: string;
   stack: CodeStack;
-  fragments: Map<string, FragmentInfo>;
+  fragments: Map<string, TypeFragmentInfo>;
 }
 
 export class TypeDefinition {
@@ -32,8 +36,8 @@ export class TypeDefinition {
     this.sourceFile = getSourceFileByStack(definition.stack, getSourceFile);
     [this.start, this.end] = varidateTypeDefinitionInfo(definition, this.sourceFile);
     this.sourceText = this.sourceFile.getFullText();
-    definition.fragments.forEach((stack, id) => {
-      this.fragmentTempaltes.set(id, createFragmentTemplate(id, stack, this.sourceFile, this.sourceText));
+    definition.fragments.forEach((fragment, id) => {
+      this.fragmentTempaltes.set(id, createFragmentTemplate(fragment, this.sourceFile, this.sourceText));
     });
   }
 

src/typeshot/printer.ts

@@ -3,7 +3,7 @@ import { reduceTaggedTemplate } from '../utils/tagged-template';
 import { SourceTrace } from './source-trace';
 import { isTypeInstance, TypeInstance } from './type-instance';
 
-export type PrinterSubtitution = string | number | boolean | undefined | null | TypeInstance;
+export type PrinterSubtitution = string | number | boolean | undefined | null | TypeInstance | PrinterTemplate;
 export type PrinterTemplate = (string | TypeInstance | SourceTrace)[];
 
 const stringifySubstitution = (substitution: PrinterSubtitution): PrinterTemplate[number] => {

src/typeshot/register-type-definition.ts

@@ -4,9 +4,15 @@ import { withStackTracking } from '../utils/stack-tracking';
 import { createTypeInstanceFactory, TypeInstanceFactory } from './type-instance';
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export type CreateTypeFragment = <_>(deps: FragmentDependencies) => Readonly<Fragment>;
-export type Fragment = Record<symbol, FragmentDependencies>;
+export type CreateTypeFragment = <_>(
+  deps: FragmentDependencies,
+  options?: TypeFragmentInfoInit,
+) => Readonly<TypeFragment>;
+export type TypeFragment = Record<symbol, FragmentDependencies>;
 export type FragmentDependencies = Record<string, any>;
+export interface TypeFragmentInfoInit {
+  forceIntegrate?: boolean;
+}
 
 export const registerTypeDefinition: {
   <T extends any[]>(factory: (createTypeFragment: CreateTypeFragment, ...args: T) => any): {
@@ -24,17 +30,14 @@ export const registerTypeDefinition: {
 
   return (...args): TypeInstanceFactory => {
     const { fragments } = definitionInfo;
-    const createTypeFragment: CreateTypeFragment = withStackTracking(
-      (fragmentStack, dependencies): Fragment => {
-        // TODO: put some comment
-        const fragmentId = `fragment@${fragmentStack.composed}`;
-        if (!fragments.has(fragmentId)) {
-          fragments.set(fragmentId, fragmentStack);
-        }
+    const createTypeFragment: CreateTypeFragment = withStackTracking((fragmentStack, dependencies, options = {}) => {
+      const fragmentId = `fragment@${fragmentStack.composed}`;
+      if (!fragments.has(fragmentId)) {
+        fragments.set(fragmentId, { ...options, id: fragmentId, stack: fragmentStack });
+      }
 
-        return Object.assign(Object.create(null), { [Symbol(fragmentId)]: dependencies });
-      },
-    );
+      return Object.assign(Object.create(null), { [Symbol(fragmentId)]: dependencies });
+    });
 
     const value = factory(createTypeFragment, ...args);
     return createTypeInstanceFactory(definitionId, value);

src/utils/__tests__/tagged-template.test.ts

@@ -25,5 +25,14 @@ describe('reduceTaggedTemplate', () => {
       expect(result).toEqual(prev);
       expect(stringify).not.toBeCalled();
     }
+
+    {
+      const stringify = jest.fn(() => '');
+      const arr = [...acc];
+      const result = reduceTaggedTemplate(acc, ['-', '_'], [arr], stringify);
+      expect(result).toBe(acc);
+      expect(result).toEqual(['foo1bar', bar, 'baz', '-', 'foo1bar', bar, 'baz', '_']);
+      expect(stringify).not.toBeCalled();
+    }
   });
 });

src/utils/stack-tracking.ts

@@ -5,29 +5,30 @@ export interface CodeStack {
   col: number;
 }
 
-const parseStack = (stack: string = '', depth: number): CodeStack => {
+const parseStack = (stack: string, depth: number): CodeStack => {
   if (!stack) throw new Error('Invalid Stack Information: make sure to run with node');
-  stack = stack.replace(/^Error:\s+\n/, '');
-  for (let i = depth; stack && i > 0; i--) {
-    stack = stack.slice(stack.indexOf('\n') + 1);
+  let cursor = 0;
+  for (let i = depth + 1; stack && i > 0; i--) {
+    cursor = stack.indexOf('\n', cursor) + 1;
   }
-  stack = stack.replace(/^\s+at\s.+\((.+)\)$/m, '$1');
+  // Ignore the case if the stack doesn't include any new line
+  const composed = stack
+    .slice(cursor + /* '____at_' ('_'=' ') */ 7, stack.indexOf('\n', cursor))
+    .replace(STACK_PARENTHESES, '');
 
   if (!stack) throw new Error('Invalid Stack Information: invalid depth');
-  const tailingNewLineIndex = stack.indexOf('\n');
-  const composed = tailingNewLineIndex === -1 ? stack : stack.slice(0, tailingNewLineIndex);
   const [filename, line, col] = composed.split(':');
-
   return { composed, filename, line: ~~line, col: ~~col };
 };
+const STACK_PARENTHESES = /(^.+\(|\)$)/g;
 
-const getCachedStack = (stack: string = '', depth: number, cacheStore: Map<string, CodeStack>) => {
-  const result = parseStack(stack, depth);
-  const cached = cacheStore.get(result.composed);
-  return cached || result;
-};
-
+const target = Object.create(null) as { stack: string };
+const cacheStore = new Map<string, CodeStack>();
 export const withStackTracking = <T, U extends any[]>(func: (stack: CodeStack, ...args: U) => T) => {
-  const cacheStore = new Map<string, CodeStack>();
-  return (...args: U) => func(getCachedStack(new Error().stack, 1, cacheStore), ...args);
+  return (...args: U) => {
+    Error.stackTraceLimit = 2;
+    Error.captureStackTrace(target);
+    Error.stackTraceLimit = 10;
+    return func(cacheStore.get(target.stack) || parseStack(target.stack, 1), ...args);
+  };
 };