Picket

Create large-scale, object-orientated architectures using classes, interfaces, type hinting and more in JavaScript

Learn

Follow the tutorials
Read the documentation
See the code on GitHub

Begin

```
<!DOCTYPE html>
```
```
<html lang="en">
```
```
<head>
```
```
	<meta charset="UTF-8">
```
```
	<title>My Document</title>
```
```
</head>
```
```
<body>
```
```
	
```

	<script src="path/to/picket.js"></script>

```
	<script>
```
```
		start(
```
```
			'MyNamespace.Start',
```
```
			{
```
```
				MyNamespace: '/public/scripts/my',
```

				CoolLibrary: '/public/scripts/vendor/cool-library/dist'

```
			}
```
```
		);
```
```
	</script>
```
```
</body>
```
```
</html>
```

Start.js

define(

'require CoolLibrary.Application',

'require CoolLibrary.Application.Bootstrap.Authenticator',

'require MyNamespace.Application.FrontController',

'require MyNamespace.Application.Bootstrap.Database',

'class MyNamespace.Start',

    'public construct ()': function()

        var application = new CoolLibrary.Application(new MyNamespace.Application.FrontController());

        application.bootstrap([

            new CoolLibrary.Application.Bootstrap.Authenticator(),

We built Picket in order to make writing complex JavaScript more manageable

Scalable

In Picket, each class is defined within one script file. That file is then loaded if any other class specifies it as a dependency meaning you don't have to manage script inclusions.

Language features too are built towards large-scale architectures with a strong dedication to object-orientation. Build code which does not encourage strong-coupling, is changeable and where each element is concerned only with itself.

Testable

Picket was built with testing in mind. Object-orientation, coupled with dependency injection and the ability to mock classes and interfaces allow you to test each individual element of your code without side-effects from other classes. This allows you to easily write code that is tested from top to bottom.

Predictable

Everything you do in Picket is type-safe meaning that properties and constants will hold what you expect them to hold; methods and events will recieve and provide what you expect. In truth, Picket will throw an error if this is ever not the case.

This means you can code confidently knowing that whenever something is wrong, you'll know about it immediately.

Simple namespaced classes with inheritance

Classes and their location are defined in a simple elegant way, as is their relationship to their parents.

```
define(
```
```
 
```
```
'class My.Child extends My.Parent',
```
```
{
```
```
	
```
```
	// ...
```
```
	
```
```
});
```

Interfaces and abstract classes

Interfaces can be defined and implemented, creating a contract between related classes and doing away with tight coupling.

```
define(
```
```
 
```
```
'interface My.IInterface',
```
```
[
```
```
	
```
```
	'public doSomething ()',
```

	'public doSomethingElse (number) -> string'

```
	
```
```
]);
```

Private and protected members

Class members are defined as public, private or protected to ensure that you can write code that keeps its internal workings hidden.

```
'private myValue (string)': null,
```
```
 
```

'public setMyValue (string)': function(value)

```
{
```
```
	this.myValue('_' + value);
```
```
}
```

Type Hinting

Properties, methods, events and constants all define rules regarding what types of variable they are prepared to deal with. Picket ensures that any badly-typed value is caught immediately.

'public myMethod (Date) -> string': function(date)

myObject.myMethod(new Date()); // Returns string

myObject.myMethod('November 30th'); // Errors - invalid argument

Optional arguments and default values

Method arguments can be defined as optional or be defined alongside a default value which is used if the user chooses to omit one.

'public myMethod (string = Example, number?)': function(string, optionalNumber)

```
myObject.myMethod(); // Valid
```

myObject.myMethod('Other example'); // Valid

myObject.myMethod('Other example', 10); // Valid

Method overloading

Multiple methods with the same name but different argument type signatures can be defined allowing for a complex variety of permutations whilst not complicating the implementation.

'public compareDate (Date) -> boolean': function(date){},

'public compareDate (number, number, number) -> boolean': function(year, month, day){}

Class events

Classes can define events in order to declare information to other classes. Other classes can choose to bind to these events, if they are interested.

eventObject.bind('change', 'handleChangeEvent');

Constants

Classes can define constants; properties that do not change value through the life of the program.

```
'public constant TAU (number)': 6.28
```

Auto file loading

Each class defines its dependencies and these are all loaded behind the scenes before any instance of the class is instantiated.

```
define(
```
```
 
```
```
'require My.Application',
```
```
'require My.Application.Controller',
```
```
 
```
```
'class My.Start',
```
```
{
```
```
	
```
```
	'public construct ()': function()
```
```
	{
```

		new My.Application(new My.Application.Controller()).run();

```
	}
```
```
	
```
```
});
```

Reflection API

Picket has a thorough set of reflection classes which allows your code to inspect details of classes and interfaces and their members. This allows you to, for example, check the class name of an object or check whether its third argument of a given method is optional.

var reflectionClass = new Reflection.Class(myObject);

reflectionClass.getName(); // Class name

reflectionClass.getMethods('myMethod')[0].getArguments()[2].isOptional(); // Boolean