skandha-facets 0.10.1 → 0.12.0

package/facets/Addition.d.ts

@@ -0,0 +1,30 @@
+import { DefineCbs } from 'aspiration';
+export type GenericObjectT = any;
+export declare class Addition<T = any> {
+    static className: () => string;
+    item?: T;
+    parentId?: string;
+    setParentId(parentId?: string): void;
+    setItem(item?: T): void;
+    add(args: {
+        values?: GenericObjectT;
+    }): any;
+    confirm(): Promise<void>;
+    cancel(): void;
+    _reset(): void;
+}
+type Cbs<T> = {
+    add: {
+        stageAdd(): void;
+        createItem(): T;
+        highlightNewItem(): void;
+    };
+    cancel: {
+        unstageAdd(parentId: string | undefined): void;
+    };
+    confirm: {
+        confirmAdd(): void;
+    };
+};
+export type AdditionCbs<T = any> = DefineCbs<Addition<T>, Cbs<T>>;
+export {};

package/{Addition.js → facets/Addition.js}

@@ -4,9 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { getCallbacks, host } from 'aspiration';
+import { getCallbacks, withCbs } from 'aspiration';
 import { data, operation } from 'skandha';
-export class Addition {
+class Addition {
     constructor() {
         Object.defineProperty(this, "item", {
             enumerable: true,
@@ -21,27 +21,39 @@ export class Addition {
             value: void 0
         });
     }
-    add(values) {
+    setParentId(parentId) {
+        this.parentId = parentId;
+    }
+    setItem(item) {
+        this.item = item;
+    }
+    add(args) {
+        var _a;
         const cbs = getCallbacks(this);
-        cbs.storeLocation && cbs.storeLocation();
-        return Promise.resolve(cbs.createItem()).then((item) => {
-            this.item = item;
-            cbs.highlightNewItem && cbs.highlightNewItem();
-        });
+        cbs.stageAdd && cbs.stageAdd();
+        const newItem = (_a = args.values) !== null && _a !== void 0 ? _a : cbs.createItem();
+        this.setItem(newItem);
+        cbs.highlightNewItem && cbs.highlightNewItem();
+        return newItem;
     }
     confirm() {
         const cbs = getCallbacks(this);
-        return Promise.resolve(cbs.confirm()).then(() => {
+        const result = cbs.confirmAdd ? cbs.confirmAdd() : undefined;
+        return Promise.resolve(result).then(() => {
             this._reset();
         });
     }
     cancel() {
         const cbs = getCallbacks(this);
-        cbs.restoreLocation && cbs.restoreLocation();
+        if (this.item) {
+            const parentId = this.parentId;
+            this._reset();
+            cbs.unstageAdd && cbs.unstageAdd(parentId);
+        }
     }
     _reset() {
-        this.item = undefined;
-        this.parentId = undefined;
+        this.setItem(undefined);
+        this.setParentId(undefined);
     }
 }
 Object.defineProperty(Addition, "className", {
@@ -56,15 +68,25 @@ __decorate([
 __decorate([
     data
 ], Addition.prototype, "parentId", void 0);
+__decorate([
+    operation({ log: false })
+], Addition.prototype, "setParentId", null);
+__decorate([
+    operation({ log: false })
+], Addition.prototype, "setItem", null);
 __decorate([
     operation,
-    host(['values'])
+    withCbs()
 ], Addition.prototype, "add", null);
 __decorate([
     operation,
-    host
+    withCbs()
 ], Addition.prototype, "confirm", null);
 __decorate([
     operation,
-    host
+    withCbs()
 ], Addition.prototype, "cancel", null);
+__decorate([
+    operation({ log: false })
+], Addition.prototype, "_reset", null);
+export { Addition };

package/facets/Deletion.d.ts

@@ -0,0 +1,16 @@
+import { DefineCbs } from 'aspiration';
+export declare class Deletion {
+    static className: () => string;
+    disabled?: boolean;
+    delete(args: {
+        itemIds: string[];
+        moveToTrash?: boolean;
+    }): Promise<any>;
+}
+type Cbs = {
+    delete: {
+        deleteItems(): any;
+    };
+};
+export type DeletionCbs = DefineCbs<Deletion, Cbs>;
+export {};

package/{Deletion.js → facets/Deletion.js}

@@ -4,10 +4,18 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { getCallbacks, host } from 'aspiration';
-import { operation } from 'skandha';
-export class Deletion {
-    delete(itemIds) {
+import { getCallbacks, withCbs } from 'aspiration';
+import { data, operation } from 'skandha';
+class Deletion {
+    constructor() {
+        Object.defineProperty(this, "disabled", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: undefined
+        });
+    }
+    delete(args) {
         const cbs = getCallbacks(this);
         return Promise.resolve(cbs.deleteItems());
     }
@@ -18,7 +26,11 @@ Object.defineProperty(Deletion, "className", {
     writable: true,
     value: () => 'Deletion'
 });
+__decorate([
+    data
+], Deletion.prototype, "disabled", void 0);
 __decorate([
     operation,
-    host(['itemIds'])
+    withCbs()
 ], Deletion.prototype, "delete", null);
+export { Deletion };

package/facets/Display.d.ts

@@ -0,0 +1,7 @@
+export declare class Display<T = any> {
+    static className: () => string;
+    items: T[];
+    get itemById(): {
+        [id: string]: T;
+    };
+}

package/facets/Display.js

@@ -0,0 +1,36 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { stub } from 'aspiration';
+import { data, output } from 'skandha';
+import { listToItemById } from '../internal/utils';
+class Display {
+    constructor() {
+        Object.defineProperty(this, "items", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: stub
+        });
+    }
+    get itemById() {
+        var _a;
+        return listToItemById((_a = this.items) !== null && _a !== void 0 ? _a : []);
+    }
+}
+Object.defineProperty(Display, "className", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: () => 'Display'
+});
+__decorate([
+    data
+], Display.prototype, "items", void 0);
+__decorate([
+    output
+], Display.prototype, "itemById", null);
+export { Display };

package/facets/DragAndDrop.d.ts

@@ -0,0 +1,15 @@
+import { DefineCbs } from 'aspiration';
+import { HoverPositionT } from './Hovering';
+export declare class DragAndDrop {
+    static className: () => string;
+    drop(args: {
+        hoverPosition: HoverPositionT;
+    }): Promise<void>;
+}
+type Cbs = {
+    drop: {
+        drop(): void;
+    };
+};
+export type DragAndDropCbs = DefineCbs<DragAndDrop, Cbs>;
+export {};

package/facets/DragAndDrop.js

@@ -0,0 +1,31 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { getCallbacks, withCbs } from 'aspiration';
+import { operation } from 'skandha';
+import { selectionIsInsertedOnDragAndDrop } from '../policies/selectionIsInsertedOnDragAndDrop';
+const dropDefaultCbs = (dragAndDrop) => ({
+    drop: function () {
+        selectionIsInsertedOnDragAndDrop(dragAndDrop, this.args.hoverPosition);
+    },
+});
+class DragAndDrop {
+    drop(args) {
+        const cbs = getCallbacks(this);
+        return Promise.resolve(cbs.drop());
+    }
+}
+Object.defineProperty(DragAndDrop, "className", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: () => 'DragAndDrop'
+});
+__decorate([
+    operation,
+    withCbs(dropDefaultCbs)
+], DragAndDrop.prototype, "drop", null);
+export { DragAndDrop };

package/facets/DragAndDropUIConnector.d.ts

@@ -0,0 +1,31 @@
+import { DragAndDrop } from './DragAndDrop';
+import { Hovering } from './Hovering';
+export interface DragAndDropUIConnectorT {
+    handle(itemId: string): DragAndDropUIPropsT;
+}
+export type PropsT = {
+    dragAndDrop: DragAndDrop;
+    hovering: Hovering;
+};
+export declare class DragAndDropUIConnector implements DragAndDropUIConnectorT {
+    props: PropsT;
+    constructor(props: PropsT);
+    handle(itemId: string): DragAndDropUIPropsT;
+}
+export declare function getDragState(hoverPosition: any, itemId: string): "before" | "after" | "none";
+export type DragAndDropUIPropsT = {
+    draggable?: boolean;
+    dragState?: string;
+    onDragStart?: (event: any) => void;
+    onDragOver?: (event: any) => void;
+    onDragEnd?: (event: any) => void;
+    onDrop?: (event: any) => void;
+};
+export declare function dragAndDropUIHandlers<T extends DragAndDropUIPropsT>(props: T): {
+    draggable: boolean | undefined;
+    onDragStart: ((event: any) => void) | undefined;
+    onDragOver: ((event: any) => void) | undefined;
+    onDrop: ((event: any) => void) | undefined;
+    onDragEnd: ((event: any) => void) | undefined;
+};
+export declare function createDragAndDropUIConnector(dragAndDrop: DragAndDrop, hovering: Hovering): DragAndDropUIConnector;

package/facets/DragAndDropUIConnector.js

@@ -0,0 +1,61 @@
+import { isBefore } from '../internal/utils';
+export class DragAndDropUIConnector {
+    constructor(props) {
+        Object.defineProperty(this, "props", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.props = props;
+    }
+    handle(itemId) {
+        return {
+            draggable: true,
+            onDragStart: () => { },
+            onDragOver: (e) => {
+                e.preventDefault();
+                this.props.hovering.setHoverPosition({
+                    targetItemId: itemId,
+                    isBefore: isBefore(e),
+                });
+            },
+            onDragEnd: () => {
+                this.props.hovering.setHoverPosition(undefined);
+            },
+            onDrop: () => {
+                const hoverPosition = this.props.hovering.hoverPosition;
+                if (hoverPosition) {
+                    this.props.dragAndDrop
+                        .drop({ hoverPosition: hoverPosition })
+                        .then(() => {
+                        this.props.hovering.setHoverPosition(undefined);
+                    });
+                }
+            },
+            dragState: getDragState(this.props.hovering.hoverPosition, itemId),
+        };
+    }
+}
+export function getDragState(hoverPosition, itemId) {
+    return (hoverPosition === null || hoverPosition === void 0 ? void 0 : hoverPosition.targetItemId) === itemId
+        ? (hoverPosition === null || hoverPosition === void 0 ? void 0 : hoverPosition.isBefore)
+            ? 'before'
+            : 'after'
+        : 'none';
+}
+export function dragAndDropUIHandlers(props) {
+    return {
+        draggable: props.draggable,
+        onDragStart: props.onDragStart,
+        onDragOver: props.onDragOver,
+        onDrop: props.onDrop,
+        onDragEnd: props.onDragEnd,
+    };
+}
+export function createDragAndDropUIConnector(dragAndDrop, hovering) {
+    return new DragAndDropUIConnector({
+        dragAndDrop,
+        hovering,
+    });
+}

package/facets/Edit.d.ts

@@ -0,0 +1,23 @@
+import { DefineCbs } from 'aspiration';
+export declare class Edit {
+    static className: () => string;
+    isEditing: boolean;
+    reset(): void;
+    save(args: {
+        values: any;
+    }): Promise<any>;
+    cancel(): void;
+    enable(): void;
+}
+export type Cbs = {
+    save: {
+        saveItem(): any;
+    };
+    cancel: {
+        onCancel(): void;
+    };
+    enable: {
+        onEnable(): void;
+    };
+};
+export type EditCbs = DefineCbs<Edit, Cbs>;

package/{Editing.js → facets/Edit.js}

@@ -4,9 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { getCallbacks, host } from 'aspiration';
+import { getCallbacks, withCbs } from 'aspiration';
 import { data, operation } from 'skandha';
-export class Editing {
+class Edit {
     constructor() {
         Object.defineProperty(this, "isEditing", {
             enumerable: true,
@@ -15,38 +15,53 @@ export class Editing {
             value: false
         });
     }
-    save(values) {
+    reset() {
+        this.isEditing = false;
+    }
+    save(args) {
         const cbs = getCallbacks(this);
-        return Promise.resolve(cbs.saveItem()).then(() => {
-            this.isEditing = false;
-            cbs.refreshView && cbs.refreshView();
+        return Promise.resolve(cbs.saveItem()).then((savedObj) => {
+            this.reset();
+            return savedObj;
         });
     }
     cancel() {
-        this.isEditing = false;
+        const cbs = getCallbacks(this);
+        if (this.isEditing) {
+            this.reset();
+            cbs.onCancel && cbs.onCancel();
+        }
     }
     enable() {
-        this.isEditing = true;
+        const cbs = getCallbacks(this);
+        if (!this.isEditing) {
+            this.isEditing = true;
+            cbs.onEnable && cbs.onEnable();
+        }
     }
 }
-Object.defineProperty(Editing, "className", {
+Object.defineProperty(Edit, "className", {
     enumerable: true,
     configurable: true,
     writable: true,
-    value: () => 'Editing'
+    value: () => 'Edit'
 });
 __decorate([
     data
-], Editing.prototype, "isEditing", void 0);
+], Edit.prototype, "isEditing", void 0);
+__decorate([
+    operation
+], Edit.prototype, "reset", null);
 __decorate([
     operation,
-    host(['values'])
-], Editing.prototype, "save", null);
+    withCbs()
+], Edit.prototype, "save", null);
 __decorate([
     operation,
-    host
-], Editing.prototype, "cancel", null);
+    withCbs()
+], Edit.prototype, "cancel", null);
 __decorate([
     operation,
-    host
-], Editing.prototype, "enable", null);
+    withCbs()
+], Edit.prototype, "enable", null);
+export { Edit };

package/{handlers → facets}/EditWithKeys.d.ts

@@ -1,4 +1,4 @@
-export declare type PropsT = {
+export type PropsT = {
     container: any;
 };
 export declare class EditWithKeys {

package/{handlers → facets}/EditWithKeys.js

@@ -1,5 +1,5 @@
-import { Editing } from "../Editing";
-import { getf } from "skandha";
+import { getf } from 'skandha';
+import { Edit } from './Edit';
 export class EditWithKeys {
     constructor(props) {
         Object.defineProperty(this, "props", {
@@ -17,12 +17,12 @@ export class EditWithKeys {
                 if (key === keyEdit) {
                     e.preventDefault();
                     e.stopPropagation();
-                    const editing = getf(Editing, ctr);
-                    if (editing.isEditing) {
-                        editing.cancel();
+                    const edit = getf(Edit, ctr);
+                    if (edit.isEditing) {
+                        edit.cancel();
                     }
                     else {
-                        editing.enable();
+                        edit.enable();
                     }
                 }
             },

package/facets/Filtering.d.ts

@@ -0,0 +1,21 @@
+import { DefineCbs } from 'aspiration';
+export type FilterT<T> = (x: T[]) => T[];
+export declare class Filtering<T = any> {
+    static className: () => string;
+    isEnabled: boolean;
+    filter: FilterT<T>;
+    inputItems: Array<T>;
+    get filteredItems(): T[];
+    apply(args: {
+        filter: FilterT<T>;
+    }): void;
+    setEnabled(args: {
+        flag: boolean;
+    }): void;
+}
+type Cbs<T> = {
+    apply: {};
+    setEnabled: {};
+};
+export type FilteringCbs<T = any> = DefineCbs<Filtering<T>, Cbs<T>>;
+export {};

package/{Filtering.js → facets/Filtering.js}

@@ -4,9 +4,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { host, stub } from 'aspiration';
+import { stub, withCbs } from 'aspiration';
 import { data, operation } from 'skandha';
-export class Filtering {
+class Filtering {
     constructor() {
         Object.defineProperty(this, "isEnabled", {
             enumerable: true,
@@ -30,12 +30,12 @@ export class Filtering {
     get filteredItems() {
         return this.isEnabled ? this.filter(this.inputItems) : this.inputItems;
     }
-    apply(filter) {
-        this.filter = filter;
-        this.setEnabled(true);
+    apply(args) {
+        this.filter = args.filter;
+        this.setEnabled({ flag: true });
     }
-    setEnabled(flag) {
-        this.isEnabled = flag;
+    setEnabled(args) {
+        this.isEnabled = args.flag;
     }
 }
 Object.defineProperty(Filtering, "className", {
@@ -58,9 +58,10 @@ __decorate([
 ], Filtering.prototype, "filteredItems", null);
 __decorate([
     operation,
-    host(['filter'])
+    withCbs()
 ], Filtering.prototype, "apply", null);
 __decorate([
     operation,
-    host(['flag'])
+    withCbs()
 ], Filtering.prototype, "setEnabled", null);
+export { Filtering };

package/facets/Highlight.d.ts

@@ -0,0 +1,17 @@
+import { DefineCbs } from 'aspiration';
+export declare class Highlight<T = any> {
+    static className: () => string;
+    highlightableIds: Array<string>;
+    id: string | undefined;
+    item?: T;
+    highlightItem(args: {
+        id: string | undefined;
+    }): void;
+}
+type Cbs<T> = {
+    highlightItem: {
+        scrollItemIntoView(): void;
+    };
+};
+export type HighlightCbs<T = any> = DefineCbs<Highlight<T>, Cbs<T>>;
+export {};

package/{Highlight.js → facets/Highlight.js}

@@ -4,11 +4,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { getCallbacks, host } from 'aspiration';
-import { data, operation, output } from 'skandha';
+import { getCallbacks, stub, withCbs } from 'aspiration';
+import { data, input, operation, output } from 'skandha';
 const highlightItemDefaultCbs = (highlight) => ({});
-export class Highlight {
+class Highlight {
     constructor() {
+        Object.defineProperty(this, "highlightableIds", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: stub
+        });
         Object.defineProperty(this, "id", {
             enumerable: true,
             configurable: true,
@@ -22,9 +28,9 @@ export class Highlight {
             value: void 0
         });
     }
-    highlightItem(id) {
+    highlightItem(args) {
         const cbs = getCallbacks(this);
-        this.id = id;
+        this.id = args.id;
         cbs.scrollItemIntoView && cbs.scrollItemIntoView();
     }
 }
@@ -34,6 +40,9 @@ Object.defineProperty(Highlight, "className", {
     writable: true,
     value: () => 'Highlight'
 });
+__decorate([
+    input
+], Highlight.prototype, "highlightableIds", void 0);
 __decorate([
     data
 ], Highlight.prototype, "id", void 0);
@@ -42,5 +51,6 @@ __decorate([
 ], Highlight.prototype, "item", void 0);
 __decorate([
     operation,
-    host(['id'], highlightItemDefaultCbs)
+    withCbs(highlightItemDefaultCbs)
 ], Highlight.prototype, "highlightItem", null);
+export { Highlight };

package/facets/HighlightUIConnector.d.ts

@@ -0,0 +1,30 @@
+import { Highlight } from './Highlight';
+export interface HighlightUIConnectorT {
+    handle(itemId: string): HighlightUIPropsT;
+}
+export type PropsT = {
+    highlight: Highlight;
+};
+export declare class HighlightUIConnector implements HighlightUIConnectorT {
+    props: PropsT;
+    _handleMouseDown: any;
+    constructor(props: PropsT);
+    _highlight(e: any, itemId: string): void;
+    _createMouseDownHandler(): (e: any, itemId: string) => void;
+    handle(itemId: any): HighlightUIPropsT;
+}
+export type HighlightUIPropsT = {
+    isHighlighted: boolean;
+    onMouseDown?: any;
+};
+export declare function highlightUIHandlers<T extends HighlightUIPropsT>(props: T): {
+    onMouseDown: any;
+};
+export declare function createHighlightUIConnector(highlight: Highlight): HighlightUIConnector;
+export declare const createHighlightKeyHandlers: (highlight: Highlight, options?: {
+    keyDown?: string;
+    keyUp?: string;
+    getHighlightableIds?: () => string[];
+}) => {
+    [x: string]: () => void;
+};