import { ComponentSchema } from "../interfaces/ComponentInterfaces"; /** Copy function definition */ export type TypeCopyFunction = (src: T, dest: T) => T /** Clone function definition */ export type TypeCloneFunction = (value: T) => T /** Base Interface for prop type */ export interface PropTypeDefinition { /** Name of the prop. */ name: string; /** Default value. */ default?: D; /** Copy Function */ copy: TypeCopyFunction; /** Clone Function */ clone: TypeCloneFunction; } /** * * @author Fernando Serrano, Robert Long */ export interface PropType extends PropTypeDefinition { /** Mark the prop as type. */ isType: true; } export type NumberPropType = PropType export type BooleanPropType = PropType export type StringPropType = PropType export type ArrayPropType = PropType export type RefPropType = PropType export type JSONPropType = PropType export const copyValue = (src: T, dest: T): T => { dest = src; return src; }; export const cloneValue = (value: T): T => value; export const copyArray = (src?: T[], dest?: T[]): T[] => { dest = [...src]; return dest; }; export const cloneArray = (value: T[]): T[] => value && value.slice(); export const copyJSON = (src: any, dest: any): any => JSON.parse(JSON.stringify(src)); export const cloneJSON = (value: any): any => JSON.parse(JSON.stringify(value)); export const copyCopyable = (src: T, dest: T): T => { if (!src) { return src; } if (!dest) { return (src as any).clone(); } return (dest as any).copy(src); }; export const cloneClonable = (value: T): T => value && (value as any).clone(); /** Create a Type * * @author Fernando Serrano, Robert Long * @param typeDefinition Definition of the type which will be used to create the type * @returns Props Type created with given type definition. */ export function createType (typeDefinition: PropTypeDefinition): PropType { const mandatoryProperties = ['name', 'copy', 'clone']; const undefinedProperties = mandatoryProperties.filter(p => { return !typeDefinition[p]; }); if (undefinedProperties.length > 0) { throw new Error( `createType expects a type definition with the following properties: ${undefinedProperties.join(', ')}` ); } (typeDefinition as any).isType = true; return typeDefinition as PropType; } /** * Standard types. * **NOTE:** Use ref for attaching objects to this entity unless you want to make the object clonable. * * @author Fernando Serrano, Robert Long */ export const Types = { Number: createType({ name: 'Number', default: 0, copy: copyValue, clone: cloneValue }), Boolean: createType({ name: 'Boolean', default: false, copy: copyValue, clone: cloneValue }), String: createType({ name: 'String', default: '', copy: copyValue, clone: cloneValue }), Array: createType({ name: 'Array', default: [], copy: copyArray, clone: cloneArray }), Ref: createType({ name: 'Ref', default: undefined, copy: copyValue, clone: cloneValue }), JSON: createType({ name: 'JSON', default: null, copy: copyJSON, clone: cloneJSON }), Vector3Type: createType({ name: 'Vector3', default: [0, 0, 0], copy: copyCopyable, clone: cloneClonable }), Vector2Type: createType({ name: 'Vector2', default: [0, 0], copy: copyCopyable, clone: cloneClonable }), QuaternionType: createType({ name: 'Quaternion', default: [0, 0, 0], copy: copyCopyable, clone: cloneClonable }) }; /** * * @author Fernando Serrano, Robert Long */ export const fromEntries = (Object as any).fromEntries || ( iterable => [...iterable].reduce((obj, [key, val]) => { obj[key] = val; return obj; }, {}) ); const capitalize = (s: string) => s[0].toUpperCase() + s.slice(1); export function types( defaults: object = {value: {type: Types.Ref}} ): ComponentSchema { return fromEntries( Object.entries(defaults).map( (name, value) => [name, {type: Types[capitalize(typeof value)] || Types.Ref, default: value}] ) ); }