@operato/scene-storage 10.0.0-beta.33 → 10.0.0-beta.34

package/dist/rack-grid-cell.d.ts

@@ -0,0 +1,341 @@
+import { Component, Properties, RealObject } from '@hatiolab/things-scene';
+import type { State } from '@hatiolab/things-scene';
+/** RackGridCell 컴포넌트 state */
+export interface RackGridCellState extends State {
+    section?: string;
+    unit?: string;
+    shelfLocations?: string;
+    binLocations?: string;
+    isEmpty?: boolean;
+    border?: any;
+    merged?: boolean;
+    rowspan?: number;
+    colspan?: number;
+}
+declare const RackGridCell_base: (new (...args: any[]) => {
+    contains(x: number, y: number): boolean;
+    get path(): {
+        x: any;
+        y: any;
+    }[];
+    set path(path: {
+        x: any;
+        y: any;
+    }[]): any;
+    get anchors(): {
+        name: string;
+        position: {
+            x: any;
+            y: any;
+        };
+    }[];
+    get bounds(): any;
+    set bounds(bounds: any): any;
+    render(ctx: CanvasRenderingContext2D): void;
+    _app: any;
+    _model: any;
+    _state: any;
+    _delta: any;
+    _animation: any;
+    _animate: any;
+    _parent: any;
+    _disposed: any;
+    _textHidden: any;
+    _text_substitutor: any;
+    _value_substitutor: any;
+    _mappings: any;
+    _realObject: import("@hatiolab/things-scene").IRealObject | undefined;
+    _cachedState: any;
+    updatedAt: any;
+    fontSize: any;
+    __cache__: any;
+    created(): void;
+    added(parent: any): void;
+    removed(parent: any): void;
+    ready(): Promise<void>;
+    touch(): void;
+    clearCache(...attrs: any[]): void;
+    removeSelf(completely: any): void;
+    resetAnimation(): void;
+    dispose(): void;
+    get nature(): import("@hatiolab/things-scene").ComponentNature;
+    get disposed(): boolean;
+    isLayer(): boolean;
+    isGroup(): boolean;
+    isContainer(): this is import("@hatiolab/things-scene").Container;
+    isLine(): boolean;
+    isRoot(): boolean;
+    isRootModel(): boolean;
+    is3dish(): boolean;
+    get is3dMode(): boolean;
+    isIn3DSpace(): boolean;
+    isTemplate(): boolean;
+    isHTMLElement(): boolean;
+    isConnectable(): boolean;
+    isIdentifiable(): boolean;
+    isPositionable(): boolean;
+    replaceRefids(replaceMap: any): void;
+    get(property: any): any;
+    set(props: any, propval?: any): any;
+    getState(property: any): any;
+    setState(props: Partial<import("@hatiolab/things-scene").State> | string, propval?: any): any;
+    get model(): any;
+    get state(): import("@hatiolab/things-scene").State;
+    get hierarchy(): any;
+    get volatile(): never[];
+    _applyProps(target: any, props: any, options: any): any;
+    move(offset: {
+        x: number;
+        y: number;
+    }, ...args: boolean[]): void;
+    symmetryX(x?: number): void;
+    symmetryY(y: number): void;
+    adjustResize(bounds: import("@hatiolab/things-scene").BOUNDS, origin_bounds: import("@hatiolab/things-scene").BOUNDS, diagonal: boolean): {
+        left: any;
+        top: any;
+        width: any;
+        height: any;
+    };
+    adjustRotation(rotation: number, step: boolean): number;
+    outline(progress: number): any;
+    get center(): import("@hatiolab/things-scene").POINT;
+    set center(p: import("@hatiolab/things-scene").POINT): any;
+    get location(): import("@hatiolab/things-scene").POINT;
+    set location(l: import("@hatiolab/things-scene").POINT): any;
+    get rotate(): import("@hatiolab/things-scene").POINT;
+    set rotate(r: import("@hatiolab/things-scene").POINT): any;
+    get dimension(): import("@hatiolab/things-scene").DIMENSION;
+    set dimension(d: import("@hatiolab/things-scene").DIMENSION): any;
+    get drawPath(): import("@hatiolab/things-scene").POINT[];
+    get rotatePoint(): import("@hatiolab/things-scene").POINT;
+    get mutable(): boolean;
+    get resizable(): boolean;
+    get rotatable(): boolean;
+    buildRealObject(): import("@hatiolab/things-scene").IRealObject | undefined;
+    get realObject(): import("@hatiolab/things-scene").IRealObject | undefined;
+    draw(context?: import("@hatiolab/things-scene").SceneRenderContext): void;
+    prerender(context: import("@hatiolab/things-scene").SceneRenderContext): void;
+    postrender(context: import("@hatiolab/things-scene").SceneRenderContext): void;
+    prepare(resolve: (component: Component) => void, reject: (reason: any) => void): void;
+    prepareIf(condition: boolean): void;
+    drawText(context: import("@hatiolab/things-scene").SceneRenderContext): void;
+    drawStroke(context: import("@hatiolab/things-scene").SceneRenderContext, override?: Record<string, unknown>): void;
+    drawFill(context: import("@hatiolab/things-scene").SceneRenderContext, override?: Record<string, unknown>): void;
+    get strokeStyle(): any;
+    set strokeStyle(v: any): any;
+    get fillStyle(): any;
+    set fillStyle(v: any): any;
+    get fontColor(): string;
+    set fontColor(v: string): any;
+    get rotation(): number;
+    set rotation(v: number): any;
+    get decorators(): string[];
+    get decotag(): string;
+    get hidden(): boolean;
+    set hidden(v: boolean): any;
+    get tag(): string;
+    set tag(v: string): any;
+    get appendum(): any;
+    set appendum(v: any): any;
+    defaultTextSubstitutor(): string;
+    textLines(context?: import("@hatiolab/things-scene").SceneRenderContext): any[][];
+    get font(): string;
+    get lineHeight(): number;
+    get textSubstitutor(): () => string;
+    get text(): string;
+    set text(v: string): any;
+    get textBounds(): import("@hatiolab/things-scene").BOUNDS;
+    get textRotation(): number;
+    get textHidden(): boolean;
+    set textHidden(v: boolean): any;
+    get hasTextProperty(): boolean;
+    animate(opts: import("@hatiolab/things-scene").AnimationConfig): any;
+    effect(context: import("@hatiolab/things-scene").SceneRenderContext, model: any): void;
+    serialize(...others: any[]): string;
+    trim(): void;
+    closeScene(data: any): void;
+    delta(attr?: string | object, value?: any): any;
+    invalidate(): void;
+    get value(): any;
+    set value(v: any): any;
+    get data(): any;
+    set data(v: any): any;
+    set tap(v: any): any;
+    get mappings(): any[];
+    get retention(): number;
+    get animation(): import("@hatiolab/things-scene").AnimationController | undefined;
+    get started(): boolean;
+    set started(v: boolean): any;
+    get controls(): import("@hatiolab/things-scene").Control[] | undefined;
+    findFirst(finder: string | ((c: Component) => boolean), ...others: any[]): Component | undefined;
+    findAll(s: string | ((c: Component) => boolean), ...others: any[]): any[] | undefined;
+    capture(x: number, y: number, except?: (c: Component) => boolean): any;
+    findAnchor(name: string): any;
+    isDescendible(container: Component | any): boolean;
+    getContext(component?: unknown): any;
+    get root(): Component;
+    get rootModel(): Component;
+    get parent(): Component;
+    set parent(v: Component): any;
+    get scalable(): boolean;
+    get stuck(): boolean;
+    get capturable(): boolean;
+    get position(): string;
+    get origin(): string;
+    get offset(): import("@hatiolab/things-scene").POINT;
+    get app(): import("@hatiolab/things-scene").ApplicationContext;
+    drawEffect(context: import("@hatiolab/things-scene").SceneRenderContext): void;
+    prepareFill(resolve: Function, reject: Function): void;
+    prepareFillIf(condition: boolean): void;
+    onchangeFill(after: Record<string, any>, before: Record<string, any>): void;
+    drawImage(context: import("@hatiolab/things-scene").SceneRenderContext, image: HTMLImageElement, left: number, top: number, width: number, height: number): void;
+    mutateBounds(logic: ((bounds: import("@hatiolab/things-scene").BOUNDS) => import("@hatiolab/things-scene").BOUNDS | void) | null, context?: any): void;
+    mutatePath(beforeLogic: ((path: import("@hatiolab/things-scene").POINT[]) => import("@hatiolab/things-scene").POINT[] | void) | null, afterLogic: ((path: import("@hatiolab/things-scene").POINT[]) => import("@hatiolab/things-scene").POINT[] | void) | null, context?: any): void;
+    access(accessor: string): any;
+    substitute(template: string, data: any): string | undefined;
+    onchangeMappings(after: Record<string, any>, before: Record<string, any>): void;
+    onchangeData(after: Record<string, any>, before: Record<string, any>): void;
+    buildMappings(): void;
+    executeMappings(force?: boolean): void;
+    disposeMappings(): void;
+    ondropfile(transfered: FileList, files: string[]): void;
+    transcoordS2P(x: number, y: number, rp?: import("@hatiolab/things-scene").POINT): import("@hatiolab/things-scene").POINT;
+    transcoordP2S(x: number, y: number, rp?: import("@hatiolab/things-scene").POINT): import("@hatiolab/things-scene").POINT;
+    transcoordS2T(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    transcoordT2P(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    transcoordT2S(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    transcoordS2TR(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    transcoordS2O(x: number, y: number, target: Component): import("@hatiolab/things-scene").POINT;
+    transcoordC2S(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    transcoordS2C(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    toParent(x: number, y: number, rp?: import("@hatiolab/things-scene").POINT): import("@hatiolab/things-scene").POINT;
+    fromParent(x: number, y: number, rp?: import("@hatiolab/things-scene").POINT): import("@hatiolab/things-scene").POINT;
+    toScene(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    fromScene(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    toLocal(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    toGlobal(x: number, y: number, top?: Component): import("@hatiolab/things-scene").POINT;
+    toOther(x: number, y: number, target: Component): import("@hatiolab/things-scene").POINT;
+    on<K extends keyof import("@hatiolab/things-scene").ComponentEventMap>(name: K, callback: (...args: import("@hatiolab/things-scene").ComponentEventMap[K]) => void, context?: any): any;
+    on(name: string | object, callback: Function, context?: any): any;
+    off<K extends keyof import("@hatiolab/things-scene").ComponentEventMap>(name: K, callback?: ((...args: import("@hatiolab/things-scene").ComponentEventMap[K]) => void) | undefined, context?: any): any;
+    off(name?: string | object, callback?: Function, context?: any): any;
+    once<K extends keyof import("@hatiolab/things-scene").ComponentEventMap>(name: K, callback: (...args: import("@hatiolab/things-scene").ComponentEventMap[K]) => void, context?: any): any;
+    once(name: string | object, callback: Function, context?: any): any;
+    trigger<K extends keyof import("@hatiolab/things-scene").ComponentEventMap>(name: K, ...args: import("@hatiolab/things-scene").ComponentEventMap[K]): any;
+    trigger(name: string, ...args: any[]): any;
+    delegate_on(delegator: any): any;
+    delegate_off(delegator: any): any;
+    onchange(after: Record<string, any>, before: Record<string, any>): void;
+    calculateBounds?(): void;
+    oncreate_element?(element: HTMLElement): void;
+    removeComponent(component: Component, ghost?: boolean): void;
+    addComponent(component: Component, ghost?: boolean): void;
+    insertComponentAt(component: Component, index: number, ghost?: boolean): void;
+    getOverlay(component: Component): HTMLElement | undefined;
+    findById(id: string): Component | undefined;
+    findByRefid(ref: string | number): Component | undefined;
+    findAllById(id: string): Component[];
+    resize(): void;
+    fit(type?: string): void;
+    get components(): Component[] | undefined;
+    get layout(): any;
+    get auxOverlay(): HTMLElement | undefined;
+    get isReady(): boolean;
+    get unitScale(): number;
+    get selected(): Component[];
+    set selected(_v: Component[]): any;
+    get focused(): Component | null;
+    set focused(_v: Component | null): any;
+    get hasSameParentForAllSelected(): boolean;
+    set hasSameParentForAllSelected(_v: boolean): any;
+    get fitMode(): string | undefined;
+    set fitMode(_v: string | undefined): any;
+    get element(): HTMLElement | null;
+    set element(_v: HTMLElement | null): any;
+}) & typeof Component;
+/**
+ * 1. 스타일을 상속 받아야 함. (cascade-style)
+ * 2. 스타일을 동적처리할 수 있음. (로직처리)
+ * 3. 데이타를 받을 수 있음.
+ */
+export declare class RackGridCell extends RackGridCell_base {
+    get state(): RackGridCellState;
+    _focused: boolean;
+    get hasTextProperty(): boolean;
+    get nature(): {
+        mutable: boolean;
+        resizable: boolean;
+        rotatable: boolean;
+        properties: ({
+            type: string;
+            label: string;
+            name: string;
+            placeholder?: undefined;
+            property?: undefined;
+        } | {
+            type: string;
+            label: string;
+            name: string;
+            placeholder: string;
+            property?: undefined;
+        } | {
+            type: string;
+            label: string;
+            name: string;
+            property: {
+                event: {
+                    'increase-location-pattern': (event: CustomEvent) => void;
+                };
+                merge?: undefined;
+                split?: undefined;
+            };
+            placeholder?: undefined;
+        } | {
+            type: string;
+            label: string;
+            name: string;
+            property: {
+                merge: boolean;
+                split: boolean;
+                event?: undefined;
+            };
+            placeholder?: undefined;
+        })[];
+    };
+    buildRealObject(): RealObject | undefined;
+    set merged(merged: any);
+    get merged(): any;
+    set rowspan(rowspan: any);
+    get rowspan(): any;
+    set colspan(colspan: any);
+    get colspan(): any;
+    get border(): any;
+    get isEmpty(): any;
+    _drawBorder(context: CanvasRenderingContext2D, x: number, y: number, to_x: number, to_y: number, style: any): void;
+    render(context: CanvasRenderingContext2D): void;
+    _draw_rack_cell(context: CanvasRenderingContext2D): void;
+    get decotag(): string;
+    get index(): {
+        row: number;
+        column: number;
+    };
+    get rowIndex(): number;
+    get columnIndex(): number;
+    get leftCell(): any;
+    get rightCell(): any;
+    get aboveCell(): any;
+    get belowCell(): any;
+    get rowCells(): any;
+    get columnCells(): any;
+    get aboveRowCells(): any;
+    get lastUnit(): number;
+    get firstUnit(): number;
+    get notEmptyRowCells(): any;
+    get emptyRowCells(): any;
+    get isAisle(): boolean;
+    onchange(after: Properties, before: Properties): void;
+    onmouseenter(): void;
+    onmouseleave(): void;
+    contains(x: number, y: number): boolean;
+}
+export {};

package/dist/rack-grid-cell.js

@@ -0,0 +1,321 @@
+import { __decorate } from "tslib";
+/*
+ * Copyright © HatioLab Inc. All rights reserved.
+ */
+import { Component, RectPath, sceneComponent } from '@hatiolab/things-scene';
+import { Rack } from './rack-column.js';
+const EMPTY_BORDER = {};
+function isBottomMost(idx, rows, columns) {
+    return idx >= (rows - 1) * columns;
+}
+function isRightMost(idx, rows, columns) {
+    return (idx + 1) % columns == 0;
+}
+function hasAnyProperty(o, ...properties) {
+    for (let p in properties) {
+        if (o.hasOwnProperty(properties[p])) {
+            return true;
+        }
+    }
+}
+const EMPTY_CELL_STROKE_STYLE = '#ccc';
+const EMPTY_CELL_LINE_WIDTH = 1;
+const EMPTY_CELL_FILL_STYLE = '#efefef';
+/**
+ * 1. 스타일을 상속 받아야 함. (cascade-style)
+ * 2. 스타일을 동적처리할 수 있음. (로직처리)
+ * 3. 데이타를 받을 수 있음.
+ */
+let RackGridCell = class RackGridCell extends RectPath(Component) {
+    get state() {
+        return super.state;
+    }
+    _focused = false;
+    get hasTextProperty() {
+        return false;
+    }
+    get nature() {
+        return {
+            mutable: false,
+            resizable: true,
+            rotatable: true,
+            properties: [
+                {
+                    type: 'string',
+                    label: 'section',
+                    name: 'section'
+                },
+                {
+                    type: 'string',
+                    label: 'unit',
+                    name: 'unit'
+                },
+                {
+                    type: 'string',
+                    label: 'shelf-locations',
+                    name: 'shelfLocations',
+                    placeholder: '1,2,3,... / ,,,04'
+                },
+                {
+                    type: 'textarea',
+                    label: 'bin-locations',
+                    name: 'binLocations',
+                    placeholder: '1,2,3,...'
+                },
+                {
+                    type: 'checkbox',
+                    label: 'is-empty',
+                    name: 'isEmpty'
+                },
+                {
+                    type: 'location-increase-pattern',
+                    label: '',
+                    name: '',
+                    property: {
+                        event: {
+                            'increase-location-pattern': (event) => {
+                                const { increasingDirection, skipNumbering, startSection, startUnit } = event.detail;
+                                const rackTable = this.parent;
+                                rackTable.increaseLocation(increasingDirection, skipNumbering, startSection, startUnit);
+                            }
+                        }
+                    }
+                },
+                {
+                    type: 'editor-table',
+                    label: '',
+                    name: '',
+                    property: {
+                        merge: false,
+                        split: false
+                    }
+                }
+            ]
+        };
+    }
+    buildRealObject() {
+        // isEmpty cell 은 3D 에 mesh 를 만들지 않는다. v9 에서는 RackGrid3D.createRacks 가
+        // cell._realObject 를 사전 설정하면 3D pipeline 이 자동 buildRealObject 호출을 skip
+        // 하던 것을, v10 의 ThreeCapability 도입 이후로는 *항상* 자동 호출됨. RackGrid3D
+        // createRacks 의 isEmpty 체크와 이 자동 경로 사이의 불일치로 isEmpty=true cell 도
+        // 3D 에 그려지던 regression — 여기 isEmpty 체크 추가로 두 경로 정합.
+        if (this.getState('isEmpty'))
+            return undefined;
+        return new Rack(this);
+    }
+    set merged(merged) {
+        this.set('merged', !!merged);
+        if (merged)
+            this.set('text', '');
+    }
+    get merged() {
+        return this.getState('merged');
+    }
+    set rowspan(rowspan) {
+        this.set('rowspan', rowspan);
+    }
+    get rowspan() {
+        return this.getState('rowspan');
+    }
+    set colspan(colspan) {
+        this.set('colspan', colspan);
+    }
+    get colspan() {
+        return this.getState('colspan');
+    }
+    get border() {
+        return this.state.border || EMPTY_BORDER;
+    }
+    get isEmpty() {
+        return this.getState('isEmpty');
+    }
+    _drawBorder(context, x, y, to_x, to_y, style) {
+        if (style && style.strokeStyle && style.lineWidth && style.lineDash) {
+            context.beginPath();
+            context.moveTo(x, y);
+            context.lineTo(to_x, to_y);
+            Component.drawStroke(context, style);
+        }
+    }
+    render(context) {
+        const { left, top, width, height } = this.bounds;
+        const { isEmpty } = this.state;
+        const border = this.border;
+        if (!isEmpty) {
+            this._draw_rack_cell(context);
+        }
+        // Cell 채우기.
+        context.beginPath();
+        context.lineWidth = 0;
+        context.rect(left, top, width, height);
+        // Border 그리기
+        const parent = this.parent;
+        const idx = parent.components.indexOf(this);
+        const columns = parent.columns || 1;
+        const rows = parent.rows || 1;
+        this._drawBorder(context, left, top, left + width, top, border.top);
+        this._drawBorder(context, left, top + height, left, top, border.left);
+        if (isRightMost(idx, rows, columns))
+            this._drawBorder(context, left + width, top, left + width, top + height, border.right);
+        if (isBottomMost(idx, rows, columns))
+            this._drawBorder(context, left + width, top + height, left, top + height, border.bottom);
+    }
+    _draw_rack_cell(context) {
+        const { left, top, width, height } = this.bounds;
+        context.save();
+        context.fillStyle = EMPTY_CELL_FILL_STYLE;
+        context.fillRect(left, top, width, height);
+        context.beginPath();
+        context.lineWidth = EMPTY_CELL_LINE_WIDTH;
+        context.strokeStyle = EMPTY_CELL_STROKE_STYLE;
+        context.moveTo(left, top);
+        context.lineTo(left + width, top + height);
+        context.moveTo(left + width, top);
+        context.lineTo(left, top + height);
+        context.stroke();
+        context.closePath();
+        context.restore();
+    }
+    get decotag() {
+        const rackTable = this.parent;
+        let { locPattern, zone = '' } = rackTable.model;
+        locPattern = locPattern.substring(0, locPattern.indexOf('{u}') + 3);
+        let locationString = '';
+        if (this.getState('section') && this.getState('unit'))
+            locationString = locPattern
+                .replace('{z}', zone)
+                .replace('{s}', this.getState('section'))
+                .replace('{u}', this.getState('unit'));
+        return locationString || '';
+    }
+    get index() {
+        const rackTable = this.parent;
+        const index = rackTable.components.indexOf(this);
+        const rowIndex = Math.floor(index / rackTable.columns);
+        const columnIndex = index % rackTable.columns;
+        return {
+            row: rowIndex,
+            column: columnIndex
+        };
+    }
+    get rowIndex() {
+        return this.index.row;
+    }
+    get columnIndex() {
+        return this.index.column;
+    }
+    get leftCell() {
+        const rackTable = this.parent;
+        const rowIndex = this.rowIndex;
+        const columnIndex = this.columnIndex;
+        if (columnIndex === 0)
+            return null;
+        const leftCell = rackTable.components[rowIndex * rackTable.columns + columnIndex - 1];
+        return leftCell;
+    }
+    get rightCell() {
+        const rackTable = this.parent;
+        const rowIndex = this.rowIndex;
+        const columnIndex = this.columnIndex;
+        if (columnIndex === rackTable.columns)
+            return null;
+        const rightCell = rackTable.components[rowIndex * rackTable.columns + columnIndex + 1];
+        return rightCell;
+    }
+    get aboveCell() {
+        const rackTable = this.parent;
+        const rowIndex = this.rowIndex;
+        const columnIndex = this.columnIndex;
+        if (rowIndex === 0)
+            return null;
+        const aboveCell = rackTable.components[(rowIndex - 1) * rackTable.columns + columnIndex];
+        return aboveCell;
+    }
+    get belowCell() {
+        const rackTable = this.parent;
+        const rowIndex = this.rowIndex;
+        const columnIndex = this.columnIndex;
+        if (rowIndex === rackTable.rows)
+            return null;
+        const belowCell = rackTable.components[(rowIndex + 1) * rackTable.columns + columnIndex];
+        return belowCell;
+    }
+    get rowCells() {
+        const rackTable = this.parent;
+        return rackTable.getCellsByRow(this.rowIndex);
+    }
+    get columnCells() {
+        const rackTable = this.parent;
+        return rackTable.getCellsByColumn(this.columnIndex);
+    }
+    get aboveRowCells() {
+        let aboveCell = this.aboveCell;
+        while (1) {
+            const aboveRowCells = aboveCell.notEmptyRowCells;
+            if (aboveRowCells.length > 0)
+                return aboveRowCells;
+            aboveCell = aboveCell.aboveCell;
+        }
+    }
+    get lastUnit() {
+        const rowCells = this.aboveRowCells;
+        for (let i = rowCells.length - 1; i > 0; i--) {
+            const cell = rowCells[i];
+            const unit = cell.getState('unit');
+            if (unit)
+                return Number(unit);
+        }
+        return 0;
+    }
+    get firstUnit() {
+        const rowCells = this.aboveRowCells;
+        for (let i = 0; i < rowCells.length; i++) {
+            const cell = rowCells[i];
+            const unit = cell.getState('unit');
+            if (unit)
+                return Number(unit);
+        }
+        return 0;
+    }
+    get notEmptyRowCells() {
+        return this.rowCells.filter((c) => {
+            return !c.getState('isEmpty');
+        });
+    }
+    get emptyRowCells() {
+        return this.rowCells.filter((c) => {
+            return c.getState('isEmpty');
+        });
+    }
+    get isAisle() {
+        return this.notEmptyRowCells.length === 0;
+    }
+    onchange(after, before) {
+        if (hasAnyProperty(after, 'isEmpty')) {
+            // FIXME
+            delete this.model.unit;
+            delete this.model.section;
+        }
+    }
+    onmouseenter() {
+        this.trigger('deco');
+    }
+    onmouseleave() {
+        this.trigger('decoreset');
+    }
+    contains(x, y) {
+        const contains = super.contains(x, y);
+        if (!contains) {
+            this._focused = false;
+            this.invalidate();
+        }
+        return contains;
+    }
+};
+RackGridCell = __decorate([
+    sceneComponent('rack-grid-cell')
+], RackGridCell);
+export { RackGridCell };
+;
+['border'].forEach(getter => Component.memoize(RackGridCell.prototype, getter, false));
+//# sourceMappingURL=rack-grid-cell.js.map