ng2-dragula
Version:
Simple drag and drop with dragula
112 lines • 14.7 kB
JavaScript
import { Subject, Subscription } from 'rxjs';
import { filter } from 'rxjs/operators';
import { EventTypes } from './EventTypes';
import { DrakeFactory } from './DrakeFactory';
export const MockDrakeFactory = new DrakeFactory((containers, options) => {
return new MockDrake(containers, options);
});
/** You can use MockDrake to simulate Drake events.
*
* The three methods that actually do anything are `on(event, listener)`,
* `destroy()`, and a new method, `emit()`. Use `emit()` to manually emit Drake
* events, and if you injected MockDrake properly with MockDrakeFactory or
* mocked the DragulaService.find() method, then you can make ng2-dragula think
* drags and drops are happening.
*
* Caveats:
*
* 1. YOU MUST MAKE THE DOM CHANGES YOURSELF.
* 2. REPEAT: YOU MUST MAKE THE DOM CHANGES YOURSELF.
* That means `source.removeChild(el)`, and `target.insertBefore(el)`.
* 3. None of the other methods do anything.
* That's ok, because ng2-dragula doesn't use them.
*/
export class MockDrake {
/**
* @param containers A list of container elements.
* @param options These will NOT be used. At all.
* @param models Nonstandard, but useful for testing using `new MockDrake()` directly.
* Note, default value is undefined, like a real Drake. Don't change that.
*/
constructor(containers = [], options = {}, models) {
this.containers = containers;
this.options = options;
this.models = models;
// Basic but fully functional event emitter shim
this.emitter$ = new Subject();
this.subs = new Subscription();
/* Doesn't represent anything meaningful. */
this.dragging = false;
}
on(event, callback) {
this.subs.add(this.emitter$
.pipe(filter(({ eventType }) => eventType === event))
.subscribe(({ eventType, args }) => {
if (eventType === EventTypes.Drag) {
const argument = Array.from(args);
const el = argument[0];
const source = argument[1];
//@ts-ignore
callback(el, source);
return;
}
if (eventType === EventTypes.Drop) {
const argument = Array.from(args);
const el = argument[0];
const target = argument[1];
const source = argument[2];
const sibling = argument[3];
//@ts-ignore
callback(el, target, source, sibling);
return;
}
if (eventType === EventTypes.Remove) {
const argument = Array.from(args);
const el = argument[0];
const container = argument[1];
const source = argument[2];
//@ts-ignore
callback(el, container, source);
return;
}
callback(args);
}));
}
/* Does nothing useful. */
start(item) {
this.dragging = true;
}
/* Does nothing useful. */
end() {
this.dragging = false;
}
cancel(revert) {
this.dragging = false;
}
/* Does nothing useful. */
canMove(item) {
return this.options.accepts ? this.options.accepts(item) : false;
}
/* Does nothing useful. */
remove() {
this.dragging = false;
}
destroy() {
this.subs.unsubscribe();
}
/**
* This is the most useful method. You can use it to manually fire events that would normally
* be fired by a real drake.
*
* You're likely most interested in firing `drag`, `remove` and `drop`, the three events
* DragulaService uses to implement [dragulaModel].
*
* See https://github.com/bevacqua/dragula#drakeon-events for what you should emit (and in what order).
*
* (Note also, firing dropModel and removeModel won't work. You would have to mock DragulaService for that.)
*/
emit(eventType, ...args) {
this.emitter$.next({ eventType, args });
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MockDrake.js","sourceRoot":"","sources":["../../../libs/ng2-dragula/src/MockDrake.ts"],"names":[],"mappings":"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","sourcesContent":["import { Subject, Subscription } from 'rxjs';\nimport { DrakeWithModels } from './DrakeWithModels';\nimport { filter } from 'rxjs/operators';\nimport { EventTypes } from './EventTypes';\nimport { DragulaOptions } from './DragulaOptions';\nimport { DrakeFactory } from './DrakeFactory';\nimport { Drake } from 'dragula';\n\nexport const MockDrakeFactory = new DrakeFactory((containers, options) => {\n  return new MockDrake(containers, options);\n});\n\n/** You can use MockDrake to simulate Drake events.\n *\n * The three methods that actually do anything are `on(event, listener)`,\n * `destroy()`, and a new method, `emit()`. Use `emit()` to manually emit Drake\n * events, and if you injected MockDrake properly with MockDrakeFactory or\n * mocked the DragulaService.find() method, then you can make ng2-dragula think\n * drags and drops are happening.\n *\n * Caveats:\n *\n * 1. YOU MUST MAKE THE DOM CHANGES YOURSELF.\n * 2. REPEAT: YOU MUST MAKE THE DOM CHANGES YOURSELF.\n *    That means `source.removeChild(el)`, and `target.insertBefore(el)`.\n * 3. None of the other methods do anything.\n *    That's ok, because ng2-dragula doesn't use them.\n */\nexport class MockDrake implements DrakeWithModels {\n  // Basic but fully functional event emitter shim\n  private emitter$ = new Subject<{ eventType: EventTypes, args: any[] }>();\n  private subs = new Subscription();\n\n  /**\n   * @param containers A list of container elements.\n   * @param options These will NOT be used. At all.\n   * @param models Nonstandard, but useful for testing using `new MockDrake()` directly.\n   *               Note, default value is undefined, like a real Drake. Don't change that.\n   */\n  constructor(\n    public containers: Element[] = [],\n    public options: DragulaOptions = {},\n    public models?: any[][]\n  ) {}\n  on(event: 'drag', listener: (el: Element, source: Element) => void): Drake;\n  on(event: 'dragend', listener: (el: Element) => void): Drake;\n  on(event: 'drop', listener: (el: Element, target: Element, source: Element, sibling: Element) => void): Drake;\n  on(event: 'cancel' | 'remove' | 'shadow' | 'over' | 'out', listener: (el: Element, container: Element, source: Element) => void): Drake;\n  on(event: 'cloned', listener: (clone: Element, original: Element, type: 'copy' | 'mirror') => void): Drake;\n  on(event: 'dropModel', listener: ([el, target, source, sibling, item, sourceModel, targetModel, sourceIndex, targetIndex,]: [Element, Element, Element, Element, any, any[], any[], number, number]) => void): Drake;\n  on(event: 'removeModel', listener: ([el, container, source, item, sourceModel, sourceIndex]: [Element, Element, Element, any, any[], number]) => void): Drake;\n  \n  on(event: string, callback: (...args: any)=> any): any {\n    this.subs.add(this.emitter$\n      .pipe(\n        filter(({ eventType }) => eventType === event)\n      )\n      .subscribe(({eventType, args} ) => {\n        if (eventType === EventTypes.Drag) {\n          const argument = Array.from(args);\n          const el = argument[0];\n          const source = argument[1];\n          //@ts-ignore\n          callback(el, source);\n          return;\n        }\n\n        if (eventType === EventTypes.Drop) {\n          const argument = Array.from(args);\n          const el = argument[0];\n          const target = argument[1];\n          const source = argument[2];\n          const sibling = argument[3];\n          //@ts-ignore\n          callback(el, target, source, sibling);\n          return;\n        }\n\n        if (eventType === EventTypes.Remove) {\n          const argument = Array.from(args);\n          const el = argument[0];\n          const container = argument[1];\n          const source = argument[2];\n          //@ts-ignore\n          callback(el, container, source);\n          return;\n        }\n        callback(args);\n      }));\n  }\n\n  /* Doesn't represent anything meaningful. */\n  dragging = false;\n\n  /* Does nothing useful. */\n  start(item: Element): any {\n    this.dragging = true;\n  }\n  /* Does nothing useful. */\n  end(): any {\n    this.dragging = false;\n  }\n  /* Does nothing useful. */\n  cancel(revert: boolean): any;\n  cancel(): any;\n  cancel(revert?: any) {\n    this.dragging = false;\n  }\n\n  /* Does nothing useful. */\n  canMove(item: Element) {\n    return this.options.accepts ? this.options.accepts(item) : false;\n  }\n\n  /* Does nothing useful. */\n  remove(): any {\n    this.dragging = false;\n  }\n\n  destroy(): any {\n    this.subs.unsubscribe();\n  }\n\n  /**\n   * This is the most useful method. You can use it to manually fire events that would normally\n   * be fired by a real drake.\n   *\n   * You're likely most interested in firing `drag`, `remove` and `drop`, the three events\n   * DragulaService uses to implement [dragulaModel].\n   *\n   * See https://github.com/bevacqua/dragula#drakeon-events for what you should emit (and in what order).\n   *\n   * (Note also, firing dropModel and removeModel won't work. You would have to mock DragulaService for that.)\n   */\n  emit(eventType: EventTypes, ...args: any[]) {\n    this.emitter$.next({ eventType, args });\n  }\n\n}\n"]}