wgge 0.0.1

package/core/model/ObjectModel.js

@@ -0,0 +1,97 @@
+import Dictionary from "../Dictionary";
+import ArrayHelper from "../helper/ArrayHelper";
+import ModelBase from "./ModelBase";
+
+export default class ObjectModel extends ModelBase {
+
+	/**
+	 * @type Dictionary<DirtyValue>
+	 */
+	properties;
+
+	constructor(persistent = true) {
+		super(persistent);
+
+		this.properties = new Dictionary();
+		this.properties.addEventListener('add', (e) => this.propertyAdded(e.key, e.value));
+		this.properties.addEventListener('remove', (e) => this.propertyRemoved(e.key, e.old));
+		this.properties.addEventListener('set', (e) => this.propertySet(e.key, e.old, e.value));
+	}
+
+	addProperty(name, property) {
+		return this.properties.add(name, property);
+	}
+
+	propertyAdded(name, property) {
+		this.makeDirty();
+		this.subscribeToOnDirtyEvent(property);
+	}
+
+	propertyRemoved(name, property) {
+		this.makeDirty();
+		this.unsubscribeFromOnDirtyEvent(property);
+	}
+
+	propertySet(name, oldProperty, newProperty) {
+		this.propertyRemoved(name, oldProperty);
+		this.propertyAdded(name, newProperty);
+	}
+
+	clean() {
+		if (super.clean()) {
+			this.properties.forEach((name, property) => property.clean());
+		}
+	}
+
+	restoreState(state) {
+		if (state === null || state === undefined || typeof state !== 'object') {
+			return;
+		}
+		if (state.p) {
+			this.properties.forEach((name, property) => property.restoreState(state.p[name]));
+		}
+		if (state.i !== undefined) {
+			this.restoreStateInternal(state.i);
+		}
+	}
+
+	getState() {
+		if (!this.isPersistent) {
+			return null;
+		}
+
+		const state = {};
+
+		if (this.properties.count() > 0) {
+			const properties = {};
+			this.properties.forEach((name, propertyNode) =>
+				properties[name] = propertyNode.getState()
+			);
+			state.p = properties;
+		}
+
+		const internal = this.getStateInternal();
+		if (internal !== undefined) {
+			state.i = internal;
+		}
+
+		return state;
+	}
+
+	getResourcesForPreload() {
+		const result = this.getResourcesForPreloadInternal();
+		this.properties.forEach(
+			(name, child) => {
+				if (typeof child.getResourcesForPreload === 'function') {
+					result.push(...child.getResourcesForPreload());
+				}
+			}
+		);
+		return ArrayHelper.unique(result).filter((uri) => uri !== null && uri !== '');
+	}
+
+	getResourcesForPreloadInternal() {
+		return [];
+	}
+
+}

package/core/model/collection/ModelNodeCollection.js

@@ -0,0 +1,232 @@
+import NullableNode from "../value/NullableNode";
+import Collection from "../../Collection";
+import ArrayHelper from "../../helper/ArrayHelper";
+import ObjectModel from "../ObjectModel";
+
+export default class ModelNodeCollection extends ObjectModel {
+
+	/**
+	 * @type Collection
+	 */
+	children;
+
+	nodeFactory;
+
+	/**
+	 * @type NullableNode
+	 */
+	selectedNode;
+
+	constructor(nodeFactory = null, persistent = true) {
+		super(persistent);
+
+		this.nodeFactory = nodeFactory;
+		this.children = new Collection();
+		const events = ['add', 'remove', 'change'];
+		events.forEach((event) => this.children.addEventListener(event, (param) => this.triggerEvent(event, param)));
+		this.children.addOnAddListener((child) => this.onChildAdded(child));
+		this.children.addOnRemoveListener((child) => this.onChildRemoved(child));
+		this.childDirtyHandler = (ch) => this.onChildDirty(ch);
+		this.childRequestedRemoveHandler = (ch) => this.remove(ch);
+
+		this.selectedNode = this.addProperty('selectedNode', new NullableNode(null, false));
+
+		this.addEventListener('drag-start', (child) => {
+			this.selectedNode.set(child);
+		});
+		this.addEventListener('drag-drop', (child) => {
+			const node = this.selectedNode.get();
+			const startIndex = this.indexOf(node);
+			const targetIndex = this.indexOf(child);
+			if (startIndex === targetIndex) {
+				return;
+			}
+			this.remove(node);
+			this.insert(node, targetIndex);
+			this.selectedNode.set(node);
+		});
+	}
+
+	asArray() {
+		return this.children.asArray();
+	}
+
+	addMultipleAsArray(children) {
+		return children.map((ch) => this.add(ch));
+	}
+
+	/**
+	 *
+	 * @param {ObjectModel | []} child
+	 * @returns {ObjectModel | [] | any}
+	 */
+	add(child = null) {
+		if (Array.isArray(child)) return this.addMultipleAsArray(child);
+
+		if (!child) {
+			child = this.nodeFactory();
+		}
+		return this.children.add(child);
+	}
+
+	prepend(child) {
+		return this.children.prepend(child);
+	}
+
+	insert(child, index) {
+		return this.children.insert(child, index);
+	}
+
+	remove(child) {
+		return this.children.remove(child);
+	}
+
+	contains(item) {
+		return this.children.contains(item);
+	}
+
+	first() {
+		return this.children.first();
+	}
+
+	last() {
+		return this.children.last();
+	}
+
+	indexOf(node) {
+		return this.children.items.indexOf(node);
+	}
+
+	random() {
+		return ArrayHelper.random(this.children.items);
+	}
+
+	get(i) {
+		return this.children.items[i];
+	}
+
+	count() {
+		return this.children.count();
+	}
+
+	isEmpty() {
+		return (this.count() === 0);
+	}
+
+	find(search) {
+		return this.children.find(search);
+	}
+
+	exists(search) {
+		return this.children.exists(search);
+	}
+
+	filter(search) {
+		return this.children.filter(search);
+	}
+
+	map(transform) {
+		return this.children.map(transform);
+	}
+
+	reduce(callback, initial) {
+		return this.children.reduce(callback, initial);
+	}
+
+	sort(sortFunc) {
+		return this.children.sort(sortFunc);
+	}
+
+	forEach(func) {
+		return this.children.forEach(func);
+	}
+
+	swap(childA, childB) {
+		this.children.swap(childA, childB);
+	}
+
+	clean() {
+		if (this.isDirty) {
+			super.clean();
+			this.children.forEach((child) => child.clean());
+		}
+	}
+
+	cleanAll() {
+		this.clean();
+		this.children.forEach((child) => child.cleanAll());
+	}
+
+	reset() {
+		this.children.reset();
+	}
+
+	addOnAddListener(handler) {
+		this.children.addOnAddListener(handler);
+	}
+
+	removeOnAddListener(handler) {
+		this.children.removeOnAddListener(handler);
+	}
+
+	addOnRemoveListener(handler) {
+		this.children.addOnRemoveListener(handler);
+	}
+
+	removeOnRemoveListener(handler) {
+		this.children.removeOnRemoveListener(handler);
+	}
+
+	/**
+	 *
+	 * @param {ObjectModel} child
+	 */
+	onChildAdded(child) {
+		this.makeDirty();
+		child.addOnDirtyListener(this.childDirtyHandler);
+		child.addEventListener('remove-me', this.childRequestedRemoveHandler);
+	}
+
+	/**
+	 *
+	 * @param {ObjectModel} child
+	 */
+	onChildRemoved(child) {
+		this.makeDirty();
+		child.removeOnDirtyListener(this.childDirtyHandler);
+		child.removeEventListener('remove-me', this.childRequestedRemoveHandler);
+		if (this.selectedNode.equalsTo(child)) {
+			this.selectedNode.set(null);
+		}
+	}
+
+	onChildDirty(child) {
+		this.makeDirty();
+	}
+
+	getStateInternal() {
+		const state = [];
+		this.children.forEach((ch) => state.push(ch.getState()));
+		return state;
+	}
+
+	restoreStateInternal(state) {
+		this.children.reset();
+		if (!this.nodeFactory) {
+			console.log('no factory for restoring ModelNodeCollection');
+			return;
+		}
+		for (let i = 0, max = state.length; i < max; i++) {
+			const child = this.nodeFactory();
+			child.restoreState(state[i]);
+			this.children.add(child);
+		}
+	}
+
+	getResourcesForPreload() {
+		const result = super.getResourcesForPreload();
+		this.children.forEach((ch) => result.push(...ch.getResourcesForPreload()));
+		return ArrayHelper.unique(result);
+	}
+
+}

package/core/model/collection/table/IdentifiedModelNode.js

@@ -0,0 +1,24 @@
+import ObjectModel from "../../ObjectModel";
+import IntValue from "../../value/IntValue";
+
+export default class IdentifiedModelNode extends ObjectModel {
+
+	/**
+	 * @type IntValue
+	 */
+	id;
+
+	constructor(id = 0, persistent = true) {
+		super(persistent);
+
+		this.id = this.addProperty('id', new IntValue(id));
+	}
+
+	equalsTo(ch) {
+		if (super.equalsTo(ch)) return true;
+		if (typeof ch.id !== 'object') return false;
+		if (typeof ch.id.get !== 'function') return false;
+		return this.equalsTo(ch.id.get());
+	}
+
+}

package/core/model/collection/table/ModelNodeTable.js

@@ -0,0 +1,53 @@
+import ModelNodeCollection from "../ModelNodeCollection";
+
+/**
+ * Collection of IdentifiedModelNode that allows search by ID.
+ */
+export default class ModelNodeTable extends ModelNodeCollection {
+
+	getById(id) {
+		if (id === null || id === undefined || id === '') {
+			return null;
+		}
+		if (typeof id === 'object' && id.constructor.name === 'IntValue') {
+			return this.getById(id.get());
+		}
+		const i = Number(id);
+		if (i === Number.NaN || i <= 0) {
+			return null;
+		}
+		return this.children.find((ch) => ch.id.equalsTo(i));
+	}
+
+	get(id) {
+		return this.getById(id);
+	}
+
+	maxId() {
+		if (this.children.count() === 0) {
+			return 0;
+		}
+		return this.children.items.reduce((prev, current) => Math.max(prev, parseInt(current.id.get())), 0);
+	}
+
+	nextId() {
+		return this.maxId() + 1;
+	}
+
+	add(node) {
+		const id = this.nextId();
+		if (!node) {
+			node = this.nodeFactory(id);
+		}
+		node.id.set(id);
+		super.add(node);
+		return node;
+	}
+
+	addClone(node) {
+		const clone = node.clone();
+		clone.id.set(this.nextId());
+		return this.insert(clone, this.indexOf(node) + 1);
+	}
+
+}

package/core/model/event/ChangeEvent.js

@@ -0,0 +1,24 @@
+export default class ChangeEvent {
+
+	/**
+	 * @type string|undefined
+	 */
+	key;
+
+	/**
+	 * @type any
+	 */
+	old;
+
+	/**
+	 * @type any
+	 */
+	value;
+
+	constructor(value, old = undefined, key = undefined) {
+		this.key = key;
+		this.old = old;
+		this.value = value;
+	}
+
+}

package/core/model/event/EventManager.js

@@ -0,0 +1,44 @@
+const DEBUG_EVENT_MANAGER = false;
+
+export default class EventManager {
+	handlers;
+
+	constructor() {
+		this.handlers = [];
+	}
+
+	addEventListener(eventName, eventHandler) {
+		if (!this.handlers[eventName]) {
+			this.handlers[eventName] = [];
+		}
+		const index = this.handlers[eventName].indexOf(eventHandler);
+		if (index >= 0) {
+			if (DEBUG_EVENT_MANAGER) console.log('Event listener already registered.');
+			return;
+		}
+		return this.handlers[eventName].push(eventHandler);
+	}
+
+	removeEventListener(eventName, eventHandler) {
+		if (!this.handlers[eventName]) {
+			this.handlers[eventName] = [];
+		}
+		const index = this.handlers[eventName].indexOf(eventHandler);
+		if (index >= 0) {
+			this.handlers[eventName].splice(index, 1);
+		} else {
+			if (DEBUG_EVENT_MANAGER) console.log('Event listener cannot be removed - not found.');
+		}
+	}
+
+	triggerEvent(eventName, param) {
+		if (!this.handlers[eventName]) {
+			return;
+		}
+		const handlers = this.handlers[eventName];
+		handlers.forEach((item) => {
+			item(param);
+		});
+	}
+
+}

package/core/model/event/NodeWithEvents.js

@@ -0,0 +1,32 @@
+import EventManager from "./EventManager";
+
+export default class NodeWithEvents {
+
+	/**
+	 * @type EventManager
+	 */
+	eventManager;
+
+	addEventListener(eventName, eventHandler, runImmediately = false) {
+		if (!this.eventManager) {
+			this.eventManager = new EventManager();
+		}
+		this.eventManager.addEventListener(eventName, eventHandler);
+		if (runImmediately) {
+			eventHandler();
+		}
+	}
+
+	removeEventListener(eventName, eventHandler) {
+		if (this.eventManager) {
+			this.eventManager.removeEventListener(eventName, eventHandler);
+		}
+	}
+
+	triggerEvent(eventName, param) {
+		if (this.eventManager) {
+			this.eventManager.triggerEvent(eventName, param);
+		}
+	}
+
+}

package/core/model/template/TemplateNode.js

@@ -0,0 +1,45 @@
+import IdentifiedModelNode from "../collection/table/IdentifiedModelNode";
+import IntValue from "../value/IntValue";
+
+export default class TemplateNode extends IdentifiedModelNode {
+
+	/**
+	 * @type IntValue
+	 */
+	originalId;
+
+	constructor(id = 0) {
+		super(id);
+
+		this.originalId = this.addProperty('originalId', new IntValue());
+	}
+
+	isCloned() {
+		return this.originalId.isSet();
+	}
+
+	getOriginalId() {
+		if (this.originalId.isSet()) return this.originalId.get();
+		return this.id.get();
+	}
+
+	isOriginalId(id) {
+		return this.getOriginalId() === id;
+	}
+
+	isFromSameOrigin(tn) {
+		if (typeof tn.getOriginalId !== 'function') return false;
+		return this.isOriginalId(tn.getOriginalId());
+	}
+
+	/**
+	 * @return TemplateNode
+	 */
+	clone() {
+		throw new Error('Clone function not defined!');
+		//const ch = new CharacterModel();
+		//ch.restoreState(this.getState());
+		//ch.originalId.set(this.id.get());
+		//return ch;
+	}
+}

package/core/model/value/BoolValue.js

@@ -0,0 +1,17 @@
+import DirtyValue from "./DirtyValue";
+
+export default class BoolValue extends DirtyValue {
+
+	set(value) {
+		if (typeof value === 'string') {
+			super.set(value !== 'false' && value !== '');
+		} else {
+			super.set(value !== undefined && value !== null && value !== false && value !== 0);
+		}
+	}
+
+	invert() {
+		this.set(!this.get());
+	}
+
+}

package/core/model/value/CapacityValue.js

@@ -0,0 +1,49 @@
+import FloatValue from "./FloatValue";
+
+export default class CapacityValue extends FloatValue {
+
+	/**
+	 *
+	 * @type FloatValue
+	 */
+	min;
+
+	/**
+	 *
+	 * @type FloatValue
+	 */
+	max;
+
+	/**
+	 *
+	 * @type FloatValue
+	 */
+	progress;
+
+	constructor(min = 0, max = 1, value = 0.5) {
+		super(value);
+
+		this.min = new FloatValue(min);
+		this.max = new FloatValue(max);
+
+		this.progress = new FloatValue(value, false);
+
+		this.addEventListener('change', () => this.update())
+		this.min.addEventListener('change', () => this.propUpdated())
+		this.max.addEventListener('change', () => this.propUpdated())
+
+		this.update();
+	}
+
+	update() {
+		if (this.min.get() > this.max.get()) return this.min.set(this.max.get());
+		if (this.get() < this.min.get()) return this.set(this.min.get());
+		if (this.get() > this.max.get()) return this.set(this.max.get());
+		this.progress.set((this.get() - this.min.get()) / this.max.get());
+	}
+
+	propUpdated() {
+		this.update();
+		this.triggerEvent('change');
+	}
+}

package/core/model/value/DirtyValue.js

@@ -0,0 +1,66 @@
+import ModelBase from "../ModelBase";
+
+export default class DirtyValue extends ModelBase {
+	/** @type object|string|null */
+	value = null;
+
+	constructor(value = null, persistent = true) {
+		super(persistent);
+		this.set(value);
+	}
+
+	set(value) {
+		if (this.value !== value) {
+			const old = this.value;
+			this.value = value;
+			this.makeDirty();
+			this.triggerOnChangeEvent(old);
+		}
+	}
+
+	get() {
+		return this.value;
+	}
+
+	toString() {
+		return this.isSet() ? this.get() : '';
+	}
+
+	isEmpty() {
+		return this.value === null || this.value === undefined;
+	}
+
+	isSet() {
+		return !this.isEmpty();
+	}
+
+	getStateInternal() {
+		return this.get();
+	}
+
+	equalsTo(value) {
+		if (this.value === value) {
+			return true;
+		}
+		if (typeof value === 'object' && value !== null && value !== undefined && value.value !== undefined) {
+			return value.value === this.value;
+		}
+	}
+
+	restoreStateInternal(state) {
+		this.set(state);
+	}
+
+	addOnChangeListener(eventHandler, runImmediately = false) {
+		this.addEventListener('change', eventHandler, runImmediately);
+	}
+
+	removeOnChangeListener(eventHandler) {
+		this.removeEventListener('change', eventHandler);
+	}
+
+	triggerOnChangeEvent(oldValue) {
+		this.triggerEvent('change', {oldValue: oldValue, newValue: this.value});
+	}
+
+}

package/core/model/value/FloatValue.js

@@ -0,0 +1,8 @@
+import IntValue from "./IntValue";
+
+export default class FloatValue extends IntValue {
+
+	round() {
+		return Math.round(this.get());
+	}
+}