Example: <ts.TextChange>{ span: 'something', newText: 'foo!' };

The Object Literal's properties cannot be renamed because it is being cast to an external type.
This should be added to the renaming heuristic.

Check the type that an object is being cast to and add it to the cast from: to dictionary.

For instance, with PropertyAssignments, we just want to rename name.

 interface PropertyAssignment extends ObjectLiteralElement {
        _propertyAssignmentBrand: any;
        name: DeclarationName;
        questionToken?: Node;
        initializer: Expression;
    }

original:

function getFileAndName(): { fileName: string, qname: string } {
    var fileName = 'hello';
    var blah = 'world';
    return { fileName, qname: blah };
}

renaming:

function getFileAndName(): { $: string, _: string } {
    var fileName = 'hello';
    var blah = 'world';
    return { fileName, _: a };
}

blah gets renamed to a even though it is not a property name because it is an identifier node.

in a PropertyAssignment:
initializer: Expression; but Expression might be an Identifier

Possible fix: Check if (<any>node).name exists, if so, compare to child. If node.name === child, we can rename?

Something like:

var x = <any>Some_Class; will result in an emit that looks like var x = undefined;

This is likely due to the fact that there is no specific type information associated with an any type.

This issue is related to #53.

Possible ways to approach this:

• Throw an error to the user telling them to type their program more specifically.
• Show the user a warning about using explicit any casting, and emit the object being cast as is, or unsafely rename it.

Because the alphabet is $, _, 0 - 9, a - z, A - Z, some property names that are generated begin with a number, which is invalid.

Fix: Add a check to see if the generated property name's first character begins with a number.

require('source-map-support').install(); throws an error.
args._ throws an error (ts2dart main.ts line 331)

args wasn't typed to minimist.ParsedArgs

args.destination throws error. destination is a property that comes from a named option; we have no idea of knowing how many named options there will be. Had to update the typings for ParsedArgs in minimist.d.ts to:

export interface ParsedArgs {
                       _: string[];
                       [key: string]: any;
        }

try {
} catch(e) {
 e.name; // breakage, need to cast e to Error, otherwise, e is of type any: (<Error>e).name
}

most seem to be typing related problems. have better error message + handling

/// <reference path="../typings/foo.d.ts"/> not making it into the minified output.

A shorthand assignment is when an object literal is created without explicitly writing the property name using the name: expression syntax.

An example:

var title = "hello world";
var author = "Foo Bar";
var obj = { title, author }; 

is the same as writing

var obj = {title: title, author: author};

We would like to desugar this ourselves when we are in the visit step. If we see a node with SyntaxKind.ShorthandPropertyAssignment, rewrite the identifier like so, and check if the name of the property can be renamed.

property_name_identifier: expression_being_assigned

Difficulty: Between easy and medium

import base = require('./base');

base.ts

export class Foo {
   . . .
}

base is some object that represents the base module. base.Foo is seen as a property access expression but we don't want to rename the Foo class name.

Possible routes:

• Forbid import * from 'foo' syntax
• Detect import * from 'foo' and understand foo is a "module" bundle object in subsequent uses of foo
• Rename all identifiers (like class names, etc.)
• See if TypeScript has some sort of type/symbol information for modules

If you intend for your TypeScript code to be used as an external library (in the case that you have a public API), exports cannot be renamed. Private properties should still be renameable, however.

At the moment, there is no support for this.

Based on SHA ffbbb47

Pushing an object of a given type to an array field causes all properties of that type to no longer be minified.

Input:

export class Foo {
  private _foolist:Array<Foo>;
  add(f:Foo) {
    this._foolist.push(f);
  }
}

Output:

export class Foo {
  private _foolist:Array<Foo>;
  add(f:Foo) {
    this._foolist.push(f);
  }
}

If I change the array to be an array of string instead, here is the nicely-renamed output

export class Foo {
  private $:Array<string>;
  _(f:string) {
    this.$.push(f);
  }
}

thanks for this, I have been looking for it! Great job!

I am considering to write a TS pre/post processor which should take care of at least following actions:

• Conditional compilation (known from other languages)
• Minified name to unminified name mapping (i.e. for usage in string references to properties).
• Eventually other actions such as
  • joining all the same namespaces / modules which are using the single class per file pattern to just single file in order to prevent resulting code to be polluted by many namespace/module definitions (as it is now).
  • maybe handy, but I am not sure how much at this time
    • Minified to unminified library file mappings (something like C header file generation)
    • Unminified to minified library linking

The preprocessor should be implemented like that:

the preprocessor.ts must be included in the TS project. It will "virtually" pollute the main object with following statements:

$DEFINE = function $DEFINE(statement: string) {...};
$IFDEF = function $IFDEF(statement: string) {...};
$IFNDEF = function $IFNDEF(statement: string) {...};
$ELSE = function $ELSE(statement: string) {...};
$ENDIF = function $ENDIF() {...};

If we are talking mainly about minification, something like this would be great:
$LIBRARY = function $LIBRARY(libname: string)
It should take all classes from the same module and put them to the single library file or take classes from various namespaces / modules and make a single library source code file from it. The main reason would be to try to avoid a lot of repetitive namespace/module definitions in the compiled code.

I am still looking for the way how to reference minified property by a string so I came with this concept:
$MINIFIEDNAME = function $MINIFIEDNAME(name: string, object: any);
As previous statements are I would say straightforward this one I guess requires deeper explanation.
The function returns the original unminified variable/object/property name defined in string but after minification the preprocessor will take the resultant object parameter and will replace whole definition in the code by the minified name. The syntax looks really horrible so I am still trying to find a better way, how to define this in order to look nicer.

Let me give you an example:

// original .ts class definition:
class Test {
   protected _computedValue: number;
   protected _someName: number;
   public set someName(value: number) {
      this._someName = value;
      this[$MINIFIEDNAME('_computedValue', this._computedValue)] = value + 3;
      console.log('Property ' + $MINIFIEDNAME('someName', this.someName) + ' was changed');
   }
}

// minified .ts:
class a {
   protected a: number;
   protected b: number;
   public set c(a: number) {
      this.b = a;
      console.log('Property ' + $MINIFIEDNAME('someName', this.b) + ' was changed');
      this[$MINIFIEDNAME('_computedValue', this.a)] = a + 3;      
      console.log('Property ' + $MINIFIEDNAME('someName', this.a) + ' was changed');
   }
}

// postprocessed .ts (before compilation):
class a {
   protected a: number;
   protecte b: number;
   public set c(a: number) {
      this.b = a;
      console.log('Property ' + 'b' + ' was changed');
      this['a'] = a + 3;
      console.log('Property ' + 'a' + ' was changed');
   }
}

The Pre-Post processor will be included in the build process like this:

Unminified program -> Preprocessor -> Clean code without DEFS/IFDEFS/LIBRARIES -> Minifier -> Minimized code -> MinPreprocessor -> String names replaced -> Compiler -> Compiled JS and .map to generated lib files -> Postprocessor-> Compiled JS with maps to original source code

It will preprocess all TS files in the project (eventually defined folder walked through recursively) before and after minification step in order to:

Before minification:

• Remove the preprocessor.ts from the target compilation
• Remove all the code defined (and including) $IF ans so on
• Join all related files to specified library/libraries

Calls minifier to do his job

After minification:

• Replaces all occurences of $MINFIELDNAME ... by the minified name of the variable / object / property string

Calls compiler to do his job

Post processing:

• remaps all compiler generated map files to match the original source code (because of joined libraries) in order to be possible to debug it.

Main requirements:

• don't modify the typescript compiler
• the preprocessor directives must be a valid TS code as the Dev IDE must be able to recognize without any additional changes to the Dev IDE itself (it would be great to have syntax highlighting for preprocessor directives but it is not that important)
• if the preprocessor is not included in the build process the code must be still valid and must work in the same way as the processed code (even while it will be slower)
• support for "changed source" compilation - compile just those files which were changed

Any comments and recommendations are welcome. Especially ideas, how to exactly implement it in order to be compatible with existing build systems.

instead of emitting as private X(), private methods are being emitted like so: privateX

From Rado:

As discussed object literal destructuring cannot be handled well, because it contains a property 
declaration or access (things we rename) and a local variable expression (something we leave to
 uglifyJS).

var {a} = foo;

is sugar for

var a = foo.a;
which should be renamed to

var a = foo.$
but there is no way to do that while keeping the sugar.

Similarly for property declaration {a} is sugar for {a: a} and we rename that to {$: a}. 
For now I suggest we detect these and throw an error.

I passed a bunch of files without the .ts and the end to minifier.renameProgram, and it ran without warning, producing no output.

minifier.renameProgram([
'./foo'
]);

/// <reference path ='../../typings/source-map/source-map.d.ts' />
import SourceMap = require('source-map');

var x: SourceMap.Mapping = {
    original: { line: 0, column: 0 },
    generated: { line: 0, column: 0 },
    source: ''
}

line and column are incorrectly being renamed. They are of type SourceMap.Position.

Some of the work to address this is on branch: https://github.com/angular/ts-minify/tree/nested-obj-literals.

not working as expected ;-;

Hello,

I'm looking for minify tool which can obfuscate whole my project.
I need to rename all variables, methods, properties and classes names (including "export" ones).

I'm trying to use ts-minify but currently have these problem:

1. "Symbol information could not be extracted"
   I have this error near:

export function x(let el: Element) {
el.className = "xx"; // here
}

do I need to load ES5 library for ts-minify?

2. If I set fastFail to false, error (1) goes out (!) but I see another error:
   "Error: ts-minify does not support accepting both internal and external types at a use site
   Symbol name: Dialog"

I have class Dialog:

export class Dialog {
..
}

and use it in this way (in other files):

import {Dialog} from "dir/dialog"

What am I doing wrong? TSC sees no problems in such code.

3. Exports are not being renamed...
   I pass all linked to each other files as one array to renameProgram() method, so I expect ts-minify knows anything about classes and can rename them in all the files.
   I want to rename anything except one API class I specify (and its public methods). All other classes are internal, tough they have "export" keyword.
   How to pass API class name to ts-minify and let ts-minify to rename everything except it?

I will be very appreciated for any help :)

Running the minifier through ts2dart produces this interesting renaming dictionary...

lastGeneratedPropName isn't being updated in one of the if clauses

Parameter properties need to be desguared, or handled otherwise:

class Animal {
    constructor(private name: string) { 
        console.log(name);
    }
}

is sugar for

class Animal {
    private name: string;
    constructor(name: string) { 
        this.name = name;
    }
}

name is a property that, if renamed in the parameter property declaration, also needs to be renamed in the constructor body if used.

An explicity any cast (<any>some_var) detracts from the TypeScript API's ability to correctly deduce type information.

• TypeScript objects not being typed to classes/interfaces defined in typescript.d.ts (in want of more generic/flexible types)
  • ie: n: ts.ModifiersArray vs n: {flags: number} in base.ts line 61
• Typing problems - if maybeVisitTypeArguments takes a type not externally declared, typeArguments get renamed, but adding a more strict typing like ts.ExpressionWithTypeArguments brings up an error when passed something like an object of type ts.CallExpression
  • error TS2345: Argument of type 'CallExpression' is not assignable to parameter of type 'ExpressionWithTypeArguments'.

Breakage, in cases like these:

return {fileName, qname};

function getFileAndName(): { fileName: string, qname: string } // rename properties here? {
    var fileName = 'hello';
    var qname = 'world';
    return { fileName, qname }; // ShortPropertyAssignment
}

A TypeLiteral node is comprised of

• First Punctuation
• SyntaxList
• CloseBraceToken

SyntaxListis where the interesting bit could happen:

• PropertySignature
  • Identifier
  • ColonToken
  • StringKeyword

Another scenario:

function getFileAndName(): { fileName: string, qname: string } {
    var fileName = 'hello';
    var blah = 'world';
    return { fileName, qname: blah };
}

The current algorithm contextEmit will rename qname and blah because they are both identifiers, when we only want to rename qname.

Example illustrating this example:

class Foo {
  constructor(public bar: string) { // bar is correctly renamed
    this.bar = bar; // bar is correctly renamed
    console.log(bar); // bar will not be renamed, we would have to rename bar here as well
  }
}