mvc-tsx
Version:
MVC based on React
889 lines (829 loc) • 30.1 kB
JavaScript
(function webpackUniversalModuleDefinition(root, factory) {
if(typeof exports === 'object' && typeof module === 'object')
module.exports = factory(require("EventEmitterModule"), require("React"), require("ReactDOM"));
else if(typeof define === 'function' && define.amd)
define(["EventEmitterModule", "React", "ReactDOM"], factory);
else {
var a = typeof exports === 'object' ? factory(require("EventEmitterModule"), require("React"), require("ReactDOM")) : factory(root["EventEmitterModule"], root["React"], root["ReactDOM"]);
for(var i in a) (typeof exports === 'object' ? exports : root)[i] = a[i];
}
})(window, function(__WEBPACK_EXTERNAL_MODULE_events__, __WEBPACK_EXTERNAL_MODULE_react__, __WEBPACK_EXTERNAL_MODULE_react_dom__) {
return /******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId]) {
/******/ return installedModules[moduleId].exports;
/******/ }
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ i: moduleId,
/******/ l: false,
/******/ exports: {}
/******/ };
/******/
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ // Flag the module as loaded
/******/ module.l = true;
/******/
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/
/******/
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/
/******/ // define getter function for harmony exports
/******/ __webpack_require__.d = function(exports, name, getter) {
/******/ if(!__webpack_require__.o(exports, name)) {
/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter });
/******/ }
/******/ };
/******/
/******/ // define __esModule on exports
/******/ __webpack_require__.r = function(exports) {
/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
/******/ }
/******/ Object.defineProperty(exports, '__esModule', { value: true });
/******/ };
/******/
/******/ // create a fake namespace object
/******/ // mode & 1: value is a module id, require it
/******/ // mode & 2: merge all properties of value into the ns
/******/ // mode & 4: return value when already ns object
/******/ // mode & 8|1: behave like require
/******/ __webpack_require__.t = function(value, mode) {
/******/ if(mode & 1) value = __webpack_require__(value);
/******/ if(mode & 8) return value;
/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
/******/ var ns = Object.create(null);
/******/ __webpack_require__.r(ns);
/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value });
/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
/******/ return ns;
/******/ };
/******/
/******/ // getDefaultExport function for compatibility with non-harmony modules
/******/ __webpack_require__.n = function(module) {
/******/ var getter = module && module.__esModule ?
/******/ function getDefault() { return module['default']; } :
/******/ function getModuleExports() { return module; };
/******/ __webpack_require__.d(getter, 'a', getter);
/******/ return getter;
/******/ };
/******/
/******/ // Object.prototype.hasOwnProperty.call
/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
/******/
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/
/******/
/******/ // Load entry module and return exports
/******/ return __webpack_require__(__webpack_require__.s = "./lib/index.ts");
/******/ })
/************************************************************************/
/******/ ({
/***/ "./lib/Controller.ts":
/***/ (function(module, exports, __webpack_require__) {
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Controller = void 0;
const Meta_1 = __webpack_require__("./lib/Meta.ts");
class Controller {
constructor(model) {
this.modelListeners = [];
this.dynamicListeners = [];
this.model = model;
this.initModelEvents();
}
initModelEvents() {
const listeners = Meta_1.getListeners(this);
const modelListeners = listeners.filter(listener => Meta_1.isModelListener(listener));
for (const listener of modelListeners) {
const eventType = listener.eventType;
const handler = (...args) => {
listener.handler(...args);
};
this.modelListeners.push({
eventType,
handler
});
this.model.on(eventType, handler);
}
}
/**
* Attach handler to View DOM events like are click, or model events.
* @param eventType any DOM Event type
* @param selector "model" or simple class selector like are: ".my-class".
* Selectors like are ".a .b .c" does not supported.
*/
on(eventType, selector, handler) {
const handlerArgs = Meta_1.findHandlerArguments(this, handler.name);
handler = handler.bind(this);
this.dynamicListeners.push({
eventType,
selector,
handler,
handlerArgs
});
}
/**
* Destroy controller and clear memory.
* Detach all listeners.
*/
destroy() {
this.onDestroy();
for (const modelListener of this.modelListeners) {
this.model.removeListener(modelListener.eventType, modelListener.handler);
}
delete this.model;
}
/**
* Detach listeners and fix any memory leaks.
* Should be any functions with clearing memory leaks.
* This method will be called from before .destroy()
*/
onDestroy() {
// redefine me
}
}
exports.Controller = Controller;
/***/ }),
/***/ "./lib/DOMListener.ts":
/***/ (function(module, exports, __webpack_require__) {
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DOMListener = void 0;
const ReactDOM = __importStar(__webpack_require__("react-dom"));
const isValidTarget_1 = __webpack_require__("./lib/utils/isValidTarget.ts");
const getPropertyFromEvent_1 = __webpack_require__("./lib/utils/getPropertyFromEvent.ts");
const getNearestModelByEvent_1 = __webpack_require__("./lib/utils/getNearestModelByEvent.ts");
class DOMListener {
constructor(params) {
this.realEventType = fixFocusAndBlur(params.eventType);
this.selector = params.selector;
this.handlerArgs = params.handlerArgs;
this.handler = params.handler;
this.view = params.view;
}
listen() {
this.domHandler = (event) => {
this.onDOMEvent(event);
};
window.addEventListener(this.realEventType, this.domHandler);
}
destroy() {
window.removeEventListener(this.realEventType, this.domHandler);
delete this.view;
delete this.handler;
delete this.domHandler;
delete this.handlerArgs;
}
onDOMEvent(event) {
const componentEl = ReactDOM.findDOMNode(this.view);
if (this.isValidEvent(event, componentEl)) {
const currentTarget = this.getCurrentTarget(event, componentEl);
const args = this.getHandlerArgs(event, currentTarget);
this.handler(...args);
}
}
isValidEvent(event, componentEl) {
const thisIsValidTarget = isValidTarget_1.isValidTarget({
componentEl,
selector: this.selector,
target: event.target,
});
return thisIsValidTarget;
}
getHandlerArgs(event, currentTarget) {
const args = this.handlerArgs.map((eventPropertyPath) => this.getHandlerArgument(event, currentTarget, eventPropertyPath));
return args;
}
getHandlerArgument(event, currentTarget, eventPropertyPath) {
if (typeof eventPropertyPath === "function") {
const ModelConstructor = eventPropertyPath;
const model = this.getHandlerArgumentByModel(event, ModelConstructor);
return model;
}
else {
const argValue = getPropertyFromEvent_1.getPropertyFromEvent(event, currentTarget, eventPropertyPath);
return argValue;
}
}
getHandlerArgumentByModel(event, ModelConstructor) {
const model = getNearestModelByEvent_1.getNearestModelByEvent(event, ModelConstructor);
if (!model) {
throw new Error("cannot find model: " + ModelConstructor.name);
}
return model;
}
getCurrentTarget(event, componentEl) {
if (typeof this.selector === "function") {
const currentTarget = componentEl;
return currentTarget;
}
let elem = event.target;
const currentTargetClassName = this.selector.slice(1);
while (elem) {
const isCurrentTarget = (elem.classList &&
elem.classList.contains(currentTargetClassName));
if (isCurrentTarget) {
return elem;
}
elem = elem.parentNode;
}
}
}
exports.DOMListener = DOMListener;
// blur and focus do not bubbling
function fixFocusAndBlur(eventType) {
if (eventType === "blur") {
return "focusout";
}
if (eventType === "focus") {
return "focusin";
}
return eventType;
}
/***/ }),
/***/ "./lib/Meta.ts":
/***/ (function(module, exports, __webpack_require__) {
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.forView = exports.isDomListener = exports.isModelListener = exports.findHandlerArguments = exports.getListeners = exports.event = exports.on = void 0;
const Model_1 = __webpack_require__("./lib/Model.ts");
const mvcEvents_1 = __webpack_require__("./lib/mvcEvents.ts");
const DOMListener_1 = __webpack_require__("./lib/DOMListener.ts");
/**
* Attach handler to View DOM events like are click, or model events.
* ```js
* class MyController extends Controller<MyModel> {
*
* // listen dom event
* *@on("click", MyView.ui.button)
* onClickButton() {
* // some action
* }
*
* }
* ```
* @param eventTypeOrModel any DOM Event type or Model constructor
* @param selectorOrViewOrModelEventType selector like are: ".my-class" or model eventType
* Selectors like are ".a .b .c" does not supported.
*/
function on(eventTypeOrModel, selectorOrViewOrModelEventType) {
let eventType;
let selector;
const isInvalidCall = (typeof eventTypeOrModel === "function" &&
typeof selectorOrViewOrModelEventType === "function");
if (isInvalidCall) {
throw new Error("invalid call, first argument and second cannot be a function at the same time");
}
if (typeof eventTypeOrModel === "string") {
eventType = eventTypeOrModel;
selector = selectorOrViewOrModelEventType;
if (typeof selector === "string") {
const selectorIsJustClassName = /^\.[\w-]+$/.test(selector);
const selectorIsWindow = selector === "window";
const isValidSelector = (selectorIsJustClassName ||
selectorIsWindow);
if (!isValidSelector) {
throw new Error(`invalid selector "${selector}", selector should be just className like are ".some-class" or "window"`);
}
}
}
else {
eventType = selectorOrViewOrModelEventType;
selector = eventTypeOrModel;
}
return (target, methodName, descriptor) => {
if (!target._listenersMeta) {
target._listenersMeta = [];
}
const meta = {
eventType,
selector,
methodName
};
target._listenersMeta.push(meta);
};
}
exports.on = on;
/**
* Get some value from event object or get nearest model from components
* ```ts
* class MyController extends Controller<MyModel> {
*
* *@on("change", MyView.ui.input)
* onChangeInput(
* // get changed input value:
* // event.target.value
* *@event("target", "value") inputValue: string
* ) {
* // some action
* }
*
* *@on("change", MyView.ui.input)
* onChangeInput(
* // get full event object:
* *@event() e: Event
* ) {
* // some action
* }
*
* *@on("click", MyView.ui.childView)
* onClickChild(
* // get model from nearest view by event target
* *@event(ChildModel) child: ChildModel
* ) {
* // some action
* }
*
* }
* ```
* @param firstKey keyof dom event object
* @param secondKey keyof Event[firstKey], next step in property path.
* @param otherPropertyPath other keys
*/
function event(firstKey, secondKey, ...otherPropertyPath) {
return (target, methodName, argumentIndex) => {
if (!target._handlersArguments) {
target._handlersArguments = [];
}
const handlerArgs = {
methodName,
argumentIndex,
eventPropertyPath: []
};
if (!firstKey) {
handlerArgs.eventPropertyPath = [];
}
else if (typeof firstKey === "string") {
const propertyPath = [
firstKey
];
if (secondKey) {
propertyPath.push(secondKey);
}
if (otherPropertyPath.length) {
propertyPath.push(...otherPropertyPath);
}
handlerArgs.eventPropertyPath = propertyPath;
}
else {
const ModelConstructor = firstKey;
handlerArgs.eventPropertyPath = ModelConstructor;
}
target._handlersArguments.push(handlerArgs);
};
}
exports.event = event;
function getListeners(controller) {
const proto = controller.constructor.prototype;
const listenersMeta = (proto._listenersMeta || []);
const listeners = [];
listenersMeta.push(...controller.dynamicListeners);
for (const listenerMeta of listenersMeta) {
let handler;
let handlerArgs = [];
if (listenerMeta.methodName) {
handler = controller[listenerMeta.methodName].bind(controller);
handlerArgs = findHandlerArguments(controller, listenerMeta.methodName);
}
else {
handler = listenerMeta.handler;
handlerArgs = listenerMeta.handlerArgs;
}
const listener = {
eventType: listenerMeta.eventType,
selector: listenerMeta.selector,
handlerArgs,
handler
};
listeners.push(listener);
}
return listeners;
}
exports.getListeners = getListeners;
function findHandlerArguments(controller, methodName) {
const proto = controller.constructor.prototype;
const handlersArguments = proto._handlersArguments || [];
const handlerArgs = handlersArguments
.filter(someArgs => someArgs.methodName === methodName)
.sort((a, b) => a.argumentIndex - b.argumentIndex)
.map(someArgs => someArgs.eventPropertyPath);
return handlerArgs;
}
exports.findHandlerArguments = findHandlerArguments;
function isModelListener(listener) {
return (typeof listener.selector === "function" &&
listener.selector.prototype instanceof Model_1.Model);
}
exports.isModelListener = isModelListener;
function isDomListener(listener) {
return !isModelListener(listener);
}
exports.isDomListener = isDomListener;
/**
* For every instance of ViewConstructor will created instance of CreateController
* ```ts
* // bind by classes
* *@forView(MyView)
* class MyController extends Controller<MyModel> {}
*
* // or create controller instance manually
* *@forView(MyView, (model: MyModel) =>
* new MyController(model, ...someOptions)
* )
* class MyController extends Controller<MyModel> {}
*
* ````
* @param ViewConstructor for every this View
* @param CreateController create this Controller
*/
function forView(ViewConstructor, CreateController) {
return (ControllerClass) => {
mvcEvents_1.mvcEvents.on("initView", (domEvent) => {
if (!(domEvent.view instanceof ViewConstructor)) {
return;
}
createControllersForView(domEvent.view, domEvent.model);
});
function createControllersForView(view, model) {
const originalEmit = model.emit;
model.emit = (eventType) => {
throw new Error(`${ControllerClass.name}: it is forbidden to emit any model event inside the controller constructor. Triggered "${eventType}"`);
};
const controller = CreateController ?
CreateController(model) :
new ControllerClass(model);
const listenersMeta = getListeners(controller);
const domListenersMeta = listenersMeta.filter(isDomListener);
const domListeners = [];
for (const meta of domListenersMeta) {
const domListener = new DOMListener_1.DOMListener({
eventType: meta.eventType,
selector: meta.selector,
handlerArgs: meta.handlerArgs,
handler: meta.handler,
view
});
domListener.listen();
domListeners.push(domListener);
}
mvcEvents_1.mvcEvents.once("destroyView", (domEvent) => {
if (domEvent.view !== view) {
return;
}
for (const domListener of domListeners) {
domListener.destroy();
}
controller.destroy();
domListeners.splice(0);
});
model.emit = originalEmit;
}
};
}
exports.forView = forView;
/***/ }),
/***/ "./lib/Model.ts":
/***/ (function(module, exports, __webpack_require__) {
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Model = void 0;
const events_1 = __webpack_require__("events");
/**
* Base Model layer
* @extends EventEmitter
*/
class Model extends events_1.EventEmitter {
/**
* Apply changes to model and emit changes to listeners.
* @param props changes to apply on model
* @param options any options, who will transferred to all listeners
* @fires change
*/
set(props, options = {}) {
const changes = {};
let hasChanges = false;
for (const key in props) {
const newValue = props[key];
const oldValue = this[key];
if (newValue !== oldValue) {
hasChanges = true;
this[key] = newValue;
changes[key] = newValue;
}
}
if (hasChanges) {
/**
* change event
*
* @event change
* @type {Partial<this>} changes
*/
this.emit("change", changes, options);
}
}
on(event, handler) {
return super.on(event, handler);
}
}
exports.Model = Model;
/***/ }),
/***/ "./lib/View.ts":
/***/ (function(module, exports, __webpack_require__) {
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.View = void 0;
const React = __importStar(__webpack_require__("react"));
const ReactDOM = __importStar(__webpack_require__("react-dom"));
const mvcEvents_1 = __webpack_require__("./lib/mvcEvents.ts");
/**
* Base View layer
* @extends React.Component
*/
class View extends React.Component {
constructor(props) {
super(props);
this.onChangeModel = this.onChangeModel.bind(this);
this.model = props.model;
this.state = this.getStateByModel(this.model);
this.listenModelChanges();
mvcEvents_1.mvcEvents.emit("initView", {
view: this,
model: this.model
});
}
render() {
return this.template(this.model);
}
componentWillReceiveProps(newProps) {
this.stopListenModel();
this.model = newProps.model;
this.listenModelChanges();
const newState = this.getStateByModel(this.model);
this.setState(newState);
}
componentDidMount() {
const rootEl = ReactDOM.findDOMNode(this);
rootEl._view = this;
}
componentWillUnmount() {
// clear memory leaks
this.onDestroy();
mvcEvents_1.mvcEvents.emit("destroyView", {
view: this,
model: this.model
});
const rootEl = ReactDOM.findDOMNode(this);
delete rootEl._view;
this.stopListenModel();
}
/**
* Detach listeners and fix any memory leaks.
* Should be any functions with clearing memory leaks.
*/
onDestroy() {
// redefine me
}
stopListenModel() {
this.model.off("change", this.onChangeModel);
}
listenModelChanges() {
this.model.on("change", this.onChangeModel);
}
onChangeModel(changes) {
this.setState({
...changes
});
}
getStateByModel(model) {
const newState = {
...this.model
};
const emitterProps = ["_events", "_eventsCount", "_maxListeners"];
for (const emitterProp of emitterProps) {
delete newState[emitterProp];
}
return newState;
}
}
exports.View = View;
/***/ }),
/***/ "./lib/index.ts":
/***/ (function(module, exports, __webpack_require__) {
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.forView = exports.event = exports.on = exports.Controller = exports.View = exports.Model = exports.EventEmitter = exports.ReactDOM = exports.React = void 0;
const React = __importStar(__webpack_require__("react"));
exports.React = React;
const ReactDOM = __importStar(__webpack_require__("react-dom"));
exports.ReactDOM = ReactDOM;
const events_1 = __webpack_require__("events");
Object.defineProperty(exports, "EventEmitter", { enumerable: true, get: function () { return events_1.EventEmitter; } });
const Meta_1 = __webpack_require__("./lib/Meta.ts");
Object.defineProperty(exports, "on", { enumerable: true, get: function () { return Meta_1.on; } });
Object.defineProperty(exports, "event", { enumerable: true, get: function () { return Meta_1.event; } });
Object.defineProperty(exports, "forView", { enumerable: true, get: function () { return Meta_1.forView; } });
const Model_1 = __webpack_require__("./lib/Model.ts");
Object.defineProperty(exports, "Model", { enumerable: true, get: function () { return Model_1.Model; } });
const View_1 = __webpack_require__("./lib/View.ts");
Object.defineProperty(exports, "View", { enumerable: true, get: function () { return View_1.View; } });
const Controller_1 = __webpack_require__("./lib/Controller.ts");
Object.defineProperty(exports, "Controller", { enumerable: true, get: function () { return Controller_1.Controller; } });
if (typeof window !== "undefined") {
const windowObj = window;
windowObj.MVC = {
React,
ReactDOM,
EventEmitter: events_1.EventEmitter,
Model: Model_1.Model,
View: View_1.View,
Controller: Controller_1.Controller,
on: Meta_1.on,
event: Meta_1.event,
forView: Meta_1.forView
};
if (!windowObj.React) {
windowObj.React = React;
}
if (!windowObj.ReactDOM) {
windowObj.ReactDOM = ReactDOM;
}
if (!windowObj.EventEmitter) {
windowObj.EventEmitter = events_1.EventEmitter;
}
}
/***/ }),
/***/ "./lib/mvcEvents.ts":
/***/ (function(module, exports, __webpack_require__) {
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.mvcEvents = void 0;
const events_1 = __webpack_require__("events");
exports.mvcEvents = new events_1.EventEmitter();
/***/ }),
/***/ "./lib/utils/getNearestModelByEvent.ts":
/***/ (function(module, exports, __webpack_require__) {
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.getNearestModelByEvent = void 0;
function getNearestModelByEvent(event, ModelConstructor) {
let parent = event.target;
while (parent) {
const view = parent._view;
if (view) {
const model = view.model;
if (model instanceof ModelConstructor) {
return model;
}
}
parent = parent.parentElement;
}
return null;
}
exports.getNearestModelByEvent = getNearestModelByEvent;
/***/ }),
/***/ "./lib/utils/getPropertyFromEvent.ts":
/***/ (function(module, exports, __webpack_require__) {
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.getPropertyFromEvent = void 0;
function getPropertyFromEvent(event, currentTarget, propertyPath) {
let eventPropertyValue = event;
for (const key of propertyPath) {
let nextValue = eventPropertyValue[key];
if (key === "currentTarget") {
nextValue = currentTarget;
}
else if (typeof nextValue === "function") {
nextValue = nextValue.bind(eventPropertyValue);
}
eventPropertyValue = nextValue;
}
return eventPropertyValue;
}
exports.getPropertyFromEvent = getPropertyFromEvent;
/***/ }),
/***/ "./lib/utils/isValidTarget.ts":
/***/ (function(module, exports, __webpack_require__) {
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.isValidTarget = void 0;
function isValidTarget(params) {
if (params.selector === "window") {
return true;
}
let parent = params.target;
let insideComponent = false;
let insideSelector = false;
let elemMatchesSelector;
if (typeof params.selector === "string") {
const selectorClassName = params.selector.replace(".", "");
elemMatchesSelector = (elem) => elem.classList.contains(selectorClassName);
}
else {
const ChildView = params.selector;
elemMatchesSelector = (elem) => elem._view instanceof ChildView;
}
while (parent) {
if (elemMatchesSelector(parent)) {
insideSelector = true;
}
if (parent === params.componentEl) {
insideComponent = true;
break;
}
parent = parent.parentElement;
}
return (insideComponent &&
insideSelector);
}
exports.isValidTarget = isValidTarget;
/***/ }),
/***/ "events":
/***/ (function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_events__;
/***/ }),
/***/ "react":
/***/ (function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_react__;
/***/ }),
/***/ "react-dom":
/***/ (function(module, exports) {
module.exports = __WEBPACK_EXTERNAL_MODULE_react_dom__;
/***/ })
/******/ });
});
//# sourceMappingURL=only-mvc.full.js.map