🎩 Pojopoly

Pojopoly realizes class-like typed polymorphism for POJO (Plain Old JavaScript Object).

``ts
// Protocol (like superclass)
const [pKey, sKey] = [Symbol('MyApp.Listable'), 'type'];
export type Listable = DefProtocolMarker;

export interface ListableImpl {
list(): T[];
}

// NOTE: This example use namespace but you have not to use.
export namespace Listable {
// boilerplate code

export function list(listable: Listable): T[] {
return v(listable).list();
}
}
`

`ts
// Implementation (like subclass)
export type ArrayObj = {
type: 'array-obj';
ary: T[];
} & Listable;

class ImplListableForArrayObj extends //...
{
static subtypeId = 'array-obj';

list(): T[] {
return this.v.ary;
}
}
Listable.registerImpl(ImplListableForArrayObj);
`

`ts
// Usage
// NOTE: ArrayObj file must be already executed
const createArrayObj = (items: T[]): ArrayObj => ({
type: 'array-obj',
ary: items,
});
const aryObj = createArrayObj([1, 2, 3]);
console.log(Listable.list(aryObj)); // [1, 2, 3]
`

When to Use Pojopoly

- You need polymorphism for state object that contain only JSON-serializable data, such as those used in Redux.
- You want to define functions with the Open-Closed Principle while working with POJO objects.

Example & Usage

$3

`ts
import {
DefProtocolMarker,
ImplBase,
generateRegisterImpl,
getImpl,
} from 'pojopoly';

//
// Define protocol (like superclass)
//

const drawableKey = Symbol('MyApp.Drawable');
const subtypeKey = 'kind';
type Drawable = DefProtocolMarker;
// DefProtocolMarker generates {?: {/* Some info /}} for type annotation.
// Practically, Drawable is {}.

interface DrawableImpl {
draw(ctx: CanvasRenderingContext2D): CanvasRenderingContext2D;
}

namespace Drawable {
export const registerImpl = generateRegisterImpl(drawableKey);

function v(drawable: Drawable): DrawableImpl {
return getImpl(drawableKey, subtypeKey, drawable);
}

export function draw(
drawable: Drawable,
ctx: CanvasRenderingContext2D
): CanvasRenderingContext2D {
return v(drawable).draw(ctx);
}
}

//
// Define types (like subclass fields)
//

type Drawer = (
| {
kind: 'circle';
pos: {x: number; y: number};
radius: number;
}
| {
kind: 'rect';
pos: {x: number; y: number};
size: {x: number; y: number};
}
) &
Drawable; // Intersect Marker for type annotation

//
// Define implements (like subclasses methods)
//

class ImplDrawerForCircle
extends ImplBase
implements DrawableImpl
{
static subtypeId = 'circle';

draw(ctx: CanvasRenderingContext2D): CanvasRenderingContext2D {
const {pos, radius} = this.v; // circle
ctx.beginPath();
ctx.arc(pos.x, pos.y, radius, 0, 2 * Math.PI);
ctx.stroke();
return ctx;
}
}
Drawable.registerImpl(ImplDrawerForCircle);

class ImplDrawerForRect
extends ImplBase
implements DrawableImpl
{
static subtypeId = 'rect';

draw(ctx: CanvasRenderingContext2D): CanvasRenderingContext2D {
const {pos, size} = this.v; // rect
ctx.beginPath();
ctx.rect(pos.x, pos.y, size.x, size.y);
ctx.stroke();
return ctx;
}
}
Drawable.registerImpl(ImplDrawerForRect);

//
// usage
//

const ctx = null as any as CanvasRenderingContext2D;
const drawerRect: Drawer = {
kind: 'rect',
pos: {x: 1, y: 2},
size: {x: 11, y: 12},
};
Drawable.draw(drawerRect, ctx);
`

$3

`ts
import {
DefProtocolMarker,
ImplBase,
generateRegisterImpl,
getImpl,
} from 'pojopoly';

//
// Define protocol
//

const [pKey, sKey] = [Symbol('MyApp.Listable'), 'type'];
type Listable = DefProtocolMarker;
// Add generics to DefProtocolMarker for type annotation.

interface ListableImpl {
list(): T[];
}

namespace Listable {
export const registerImpl = generateRegisterImpl>(pKey);

function v(listable: Listable): ListableImpl {
return getImpl>(pKey, sKey, listable);
}

export function list(listable: Listable): T[] {
return v(listable).list();
}
}

//
// Define subtype and implementation
//

// array-obj

type ArrayObj = {
type: 'array-obj';
ary: T[];
} & Listable;

namespace ArrayObj {
export function create(ary: T[]): ArrayObj {
return {type: 'array-obj', ary};
}
}

class ImplListableForArrayObj
extends ImplBase>
implements ListableImpl
{
static subtypeId = 'array-obj';

list(): T[] {
return this.v.ary;
}
}
Listable.registerImpl(ImplListableForArrayObj);

// record-obj

type RecordObj = {
type: 'record-obj';
rec: Record;
} & Listable<[K, V]>;

namespace RecordObj {
export function create(
rec: Record
): RecordObj {
return {type: 'record-obj', rec};
}
}

class ImplListableForRecordObj
extends ImplBase>
implements ListableImpl<[K, V]>
{
static subtypeId = 'record-obj';

list(): [K, V][] {
return Object.entries(this.v.rec) as [K, V][];
}
}
Listable.registerImpl(ImplListableForRecordObj);

//
// usage
//

const ary = ArrayObj.create([1, 2, 3]);
const rec = RecordObj.create({a: 1, b: 2, c: 3});

const listOfAry = Listable.list(ary); // number[]
const listOfRec = Listable.list(rec); // ["a" | "b" | "c", number][]

console.log(listOfAry); // [1, 2, 3]
console.log(listOfRec); // [["a", 1], ["b", 2], ["c", 3]]
`

$3

`ts
import {ImplBase, generateRegisterImpl, getImpl} from 'pojopoly';

//
// Types are already defined without protocol marker
//

type Item = ArrayObj | MapObj;

type ArrayObj = {
type: 'array-obj';
ary: T[];
};

type MapObj = {
type: 'map-obj';
map: Map;
};

//
// Define protocol. Use already defined type instead of ProtocolMarker.
//

const [pKey, sKey] = [Symbol('MyApp.Listable'), 'type'];

interface ListableImpl {
list(): T[];
}

namespace Listable {
export const registerImpl = generateRegisterImpl>(pKey);

function v(item: Item): ListableImpl {
return getImpl(pKey, sKey, item);
}

export function list(listable: Item): T[] {
return v(listable).list();
}
}

//
// Define implements
//

class ImplListableForArrayObj
extends ImplBase>
implements ListableImpl
{
static subtypeId = 'array-obj';

list(): T[] {
return this.v.ary;
}
}
Listable.registerImpl(ImplListableForArrayObj);

class ImplListableForMapObj
extends ImplBase>
implements ListableImpl
{
static subtypeId = 'map-obj';

list(): V[] {
return [...this.v.map.values()];
}
}
Listable.registerImpl(ImplListableForMapObj);

//
// usage
//

const ary: ArrayObj = {
type: 'array-obj',
ary: [1, 2, 3],
};
const map: MapObj = {
type: 'map-obj',
map: new Map([
['a', '1'],
['b', '2'],
['c', '3'],
]),
};

const listOfAry = Listable.list(ary); // number[]
const listOfMap = Listable.list(map); // string[]

console.log(listOfAry); // [1, 2, 3]
console.log(listOfMap); // ["1", "2", "3"]
`

$3

`ts
import {
DefProtocolMarker,
ImplBase,
generateRegisterImpl,
getImpl,
} from 'pojopoly';

//
// Define protocol
//

// Listable

const [pKeyListable, sKeyListable] = [Symbol('MyApp.Listable'), 'type'];
type Listable = DefProtocolMarker<
typeof pKeyListable,
typeof sKeyListable,
[T]
>;

interface ListableImpl {
list(): T[];
}

namespace Listable {
export const registerImpl =
generateRegisterImpl>(pKeyListable);

function v(listable: Listable): ListableImpl {
return getImpl>(pKeyListable, sKeyListable, listable);
}

export function list(listable: Listable): T[] {
return v(listable).list();
}
}

// Printable

const [pKeyPrintable, sKeyPrintable] = [Symbol('MyApp.Printable'), 'type'];
export type Printable = DefProtocolMarker<
typeof pKeyPrintable,
typeof sKeyPrintable
>;

export interface PrintableImpl {
print(): string;
}

export namespace Printable {
export const registerImpl =
generateRegisterImpl(pKeyPrintable);

function v(Printable: Printable): PrintableImpl {
return getImpl(pKeyPrintable, sKeyPrintable, Printable);
}

export function print(Printable: Printable): string {
return v(Printable).print();
}
}

//
// Define subtype and implementation
//

type ArrayObj = {
type: 'array-obj';
ary: T[];
} & Listable &
Printable;

namespace ArrayObj {
export function create(ary: T[]): ArrayObj {
return {type: 'array-obj', ary};
}
}

class ImplListableForArrayObj
extends ImplBase>
implements ListableImpl
{
static subtypeId = 'array-obj';

list(): T[] {
return this.v.ary;
}
}
Listable.registerImpl(ImplListableForArrayObj);

class ImplPrintableForArrayObj
extends ImplBase>
implements PrintableImpl
{
static subtypeId = 'array-obj';

print(): string {
return ArrayObj(${this.v.ary});
}
}
Printable.registerImpl(ImplPrintableForArrayObj);

//
// usage
//

const ary = ArrayObj.create([1, 2, 3]);

const listOfAry = Listable.list(ary); // number[]
const printableAry = Printable.print(ary); // string

console.log(listOfAry); // [1, 2, 3]
console.log(printableAry); // ArrayObj(1, 2, 3)
`

Install

`bash
npm install --save pojopoly
``