skandha-facets 0.10.1 → 0.11.0

package/facets/Addition.d.ts

@@ -0,0 +1,28 @@
+import { DefineCbs } from 'aspiration';
+export type GenericObjectT = any;
+export declare class Addition<T = any> {
+    static className: () => string;
+    item?: T;
+    parentId?: string;
+    add(args: {
+        values?: GenericObjectT;
+    }): Promise<any>;
+    confirm(): Promise<void>;
+    cancel(): void;
+    _reset(): void;
+}
+type Cbs<T> = {
+    add: {
+        stageAdd(): void;
+        createItem(): T;
+        highlightNewItem(): void;
+    };
+    cancel: {
+        unstageAdd(): 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 { data, operation } from 'skandha';
-export class Addition {
+import { getCallbacks, withCbs } from 'aspiration';
+import { data, decorateCb, operation } from 'skandha';
+class Addition {
     constructor() {
         Object.defineProperty(this, "item", {
             enumerable: true,
@@ -21,23 +21,30 @@ export class Addition {
             value: void 0
         });
     }
-    add(values) {
+    add(args) {
+        var _a;
         const cbs = getCallbacks(this);
-        cbs.storeLocation && cbs.storeLocation();
-        return Promise.resolve(cbs.createItem()).then((item) => {
+        cbs.stageAdd && cbs.stageAdd();
+        const newItem = (_a = args.values) !== null && _a !== void 0 ? _a : cbs.createItem();
+        return Promise.resolve(newItem).then(decorateCb((item) => {
             this.item = item;
             cbs.highlightNewItem && cbs.highlightNewItem();
-        });
+            return item;
+        }));
     }
     confirm() {
         const cbs = getCallbacks(this);
-        return Promise.resolve(cbs.confirm()).then(() => {
+        const result = cbs.confirmAdd ? cbs.confirmAdd() : undefined;
+        return Promise.resolve(result).then(decorateCb(() => {
             this._reset();
-        });
+        }));
     }
     cancel() {
         const cbs = getCallbacks(this);
-        cbs.restoreLocation && cbs.restoreLocation();
+        if (this.item) {
+            this._reset();
+            cbs.unstageAdd && cbs.unstageAdd();
+        }
     }
     _reset() {
         this.item = undefined;
@@ -58,13 +65,17 @@ __decorate([
 ], Addition.prototype, "parentId", void 0);
 __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 { DropPositionT } from './Insertion';
+export declare class DragAndDrop {
+    static className: () => string;
+    drop(args: {
+        dropPosition: DropPositionT;
+    }): 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.dropPosition);
+    },
+});
+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,34 @@
+import { DragAndDrop } from './DragAndDrop';
+import { DropPositionT } from './Insertion';
+export interface DragAndDropUIConnectorT {
+    hoverPosition?: DropPositionT;
+    setHoverPosition(x?: DropPositionT): void;
+    handle(itemId: string): DragAndDropUIPropsT;
+}
+export type PropsT = {
+    dragAndDrop: DragAndDrop;
+};
+export declare class DragAndDropUIConnector implements DragAndDropUIConnectorT {
+    props: PropsT;
+    hoverPosition?: DropPositionT;
+    constructor(props: PropsT);
+    setHoverPosition(x?: DropPositionT): void;
+    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): DragAndDropUIConnector;

package/{DragAndDrop.js → facets/DragAndDropUIConnector.js}

@@ -4,27 +4,23 @@ 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 } from 'skandha';
-import { isBefore } from './internal/utils';
-import { selectionIsInsertedOnDragAndDrop } from './policies/selectionIsInsertedOnDragAndDrop';
-const dropDefaultCbs = (dragAndDrop) => ({
-    drop: function () {
-        selectionIsInsertedOnDragAndDrop(dragAndDrop, this.dropPosition);
-    },
-});
-export class DragAndDrop {
-    constructor() {
+import { data, decorateCb, operation } from 'skandha';
+import { isBefore } from '../internal/utils';
+export class DragAndDropUIConnector {
+    constructor(props) {
+        Object.defineProperty(this, "props", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "hoverPosition", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-    }
-    drop(dropPosition) {
-        const cbs = getCallbacks(this);
-        return Promise.resolve(cbs.drop());
+        this.props = props;
     }
     setHoverPosition(x) {
         this.hoverPosition = x;
@@ -45,38 +41,31 @@ export class DragAndDrop {
             },
             onDrop: () => {
                 if (this.hoverPosition) {
-                    this.drop(this.hoverPosition).then(() => {
+                    this.props.dragAndDrop
+                        .drop({ dropPosition: this.hoverPosition })
+                        .then(decorateCb(() => {
                         this.setHoverPosition(undefined);
-                    });
+                    }));
                 }
             },
+            dragState: getDragState(this.hoverPosition, itemId),
         };
     }
 }
-Object.defineProperty(DragAndDrop, "className", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: () => 'DragAndDrop'
-});
 __decorate([
     data
-], DragAndDrop.prototype, "hoverPosition", void 0);
-__decorate([
-    operation,
-    host(['dropPosition'], dropDefaultCbs)
-], DragAndDrop.prototype, "drop", null);
+], DragAndDropUIConnector.prototype, "hoverPosition", void 0);
 __decorate([
     operation({ log: false })
-], DragAndDrop.prototype, "setHoverPosition", null);
-export function dragState(hoverPosition, itemId) {
+], DragAndDropUIConnector.prototype, "setHoverPosition", null);
+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 dragHandlers(props) {
+export function dragAndDropUIHandlers(props) {
     return {
         draggable: props.draggable,
         onDragStart: props.onDragStart,
@@ -85,3 +74,6 @@ export function dragHandlers(props) {
         onDragEnd: props.onDragEnd,
     };
 }
+export function createDragAndDropUIConnector(dragAndDrop) {
+    return new DragAndDropUIConnector({ dragAndDrop });
+}

package/facets/Edit.d.ts

@@ -0,0 +1,22 @@
+import { DefineCbs } from 'aspiration';
+export declare class Edit {
+    static className: () => string;
+    isEditing: boolean;
+    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 { data, operation } from 'skandha';
-export class Editing {
+import { getCallbacks, withCbs } from 'aspiration';
+import { data, decorateCb, operation } from 'skandha';
+class Edit {
     constructor() {
         Object.defineProperty(this, "isEditing", {
             enumerable: true,
@@ -15,38 +15,47 @@ export class Editing {
             value: false
         });
     }
-    save(values) {
+    save(args) {
         const cbs = getCallbacks(this);
-        return Promise.resolve(cbs.saveItem()).then(() => {
+        return Promise.resolve(cbs.saveItem()).then(decorateCb((localItem) => {
             this.isEditing = false;
-            cbs.refreshView && cbs.refreshView();
-        });
+            return localItem;
+        }));
     }
     cancel() {
-        this.isEditing = false;
+        const cbs = getCallbacks(this);
+        if (this.isEditing) {
+            this.isEditing = false;
+            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,
-    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 };