shop-components 0.0.25 → 0.1.0

package/dist/device-viewer/amr.d.ts

@@ -0,0 +1,75 @@
+import { Object3D, TextureLoader } from 'three';
+import { Logo, Scene3D, Skin, Slot } from './scene';
+import { ObjectSize } from './utils';
+import { SizeBox } from './dimension/size-box';
+import { AMRAssembly } from './assembly';
+import EventEmitter from 'eventemitter3';
+export declare const textureLoader: TextureLoader;
+export interface AmrProps {
+    url?: string;
+    showSizeBox: boolean;
+}
+export declare class Amr extends Object3D {
+    private _props;
+    private _emitter;
+    addEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    private _container;
+    private _app;
+    sizeBox: SizeBox;
+    _goodsSize: ObjectSize;
+    _slots: Slot[];
+    _logos: Logo[];
+    _skins: Skin[];
+    _levels: Map<number, AMRAssembly>;
+    private _lift;
+    private _fork;
+    private _jack;
+    private _bodyOpacity;
+    private _breathLights;
+    private _outline;
+    private _shelf;
+    private _shelves;
+    private _url;
+    private _shapeKeys;
+    private _materialsCache;
+    opacityCache: undefined | number;
+    get shapeKeys(): Map<string, number>;
+    get size(): {
+        width: number;
+        length: number;
+        height: number;
+    };
+    get slots(): Slot[];
+    get logos(): Logo[];
+    get skins(): Skin[];
+    get bodyOpacity(): number;
+    get fork(): Object3D<import("three").Object3DEventMap> | undefined;
+    get jack(): Object3D<import("three").Object3DEventMap> | undefined;
+    get lift(): Object3D<import("three").Object3DEventMap> | undefined;
+    set bodyOpacity(o: number);
+    constructor(_props: AmrProps);
+    init(app: Scene3D): void;
+    load(url: string): Promise<void>;
+    changeSkin(skin: Skin, value: string): void;
+    changeLogo(logo: Logo, url: string): void;
+    setShapeKey(key: string, value: number): void;
+    private _generateAmr;
+    setHeight(height: number): void;
+    setWeight(width: number): void;
+    setLength(length: number): void;
+    setForkHeight(height: number): void;
+    setJackHeight(height: number): void;
+    setLevel(level: number): void;
+    setGoodsSize(size: {
+        length: number;
+        width: number;
+        height: number;
+    }): void;
+    generateShelfLevel(levelMax?: number): void;
+    generateOuterLine(): void;
+    generateController(m: Object3D, amr: Object3D): void;
+    generateDimension(m: Object3D, amr: Object3D): void;
+    generateSlot(m: Object3D): Slot | undefined;
+    clean(): void;
+    destroy(): void;
+}

package/dist/device-viewer/assembly.d.ts

@@ -0,0 +1,11 @@
+import { Object3D } from 'three';
+import { ObjectSize } from './utils';
+export declare class AMRAssembly extends Object3D {
+    private _url?;
+    protected _size: ObjectSize;
+    constructor(_url?: string | undefined);
+    loaded(g: any): void;
+    get size(): ObjectSize;
+    private _load;
+    destroy(): void;
+}

package/dist/device-viewer/dimension/index.d.ts

@@ -0,0 +1,31 @@
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { Vector3 } from 'three';
+import EventEmitter from 'eventemitter3';
+export interface DimensionProps {
+    start: Vector3;
+    end: Vector3;
+    startOrigin?: Vector3;
+    axios: 'x' | 'y' | 'z';
+    divider: number;
+}
+export declare class Dimension extends CSS3DObject {
+    props: DimensionProps;
+    private _scale;
+    private _emitter;
+    addEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    removeEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    private endNode;
+    private _textNode;
+    private _mouseStart;
+    private _targetSize;
+    private _caches;
+    private _sizeFlag;
+    private _direction;
+    private _lines;
+    constructor(props: DimensionProps);
+    private _getIndexByAxios;
+    private _pointerdown;
+    private _pointermove;
+    private _pointercancel;
+    dispose(): void;
+}

package/dist/device-viewer/dimension/line3.d.ts

@@ -0,0 +1,21 @@
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+import { Vector3 } from 'three';
+export declare class Line3 extends CSS3DObject {
+    private _startWith?;
+    private _text;
+    constructor(start: Vector3, end: Vector3, _startWith?: string | undefined);
+    getV(v: number): number;
+    getSV(v: number): number;
+    dispose(): void;
+    hide(): void;
+    show(): void;
+    update(start: Vector3, end: Vector3): void;
+    updateSize(pos: Vector3): void;
+}
+export declare class Text3 extends CSS3DObject {
+    constructor(text: string, color?: string);
+    hide(): void;
+    show(): void;
+    update(text: string): void;
+    updateSize(pos: Vector3): void;
+}

package/dist/device-viewer/dimension/size-box.d.ts

@@ -0,0 +1,39 @@
+import { Box3, Object3D } from 'three';
+import { Tween } from '@tweenjs/tween.js';
+import { Scene3D } from '../scene';
+export declare class SizeBox extends Object3D {
+    private _box3;
+    private _line1;
+    private _line2;
+    private _line3;
+    private _outline;
+    private _object;
+    _fitAnimation: Tween<any> | undefined;
+    private _radius;
+    private _app;
+    private _hasWidthConfig;
+    private _hasLengthConfig;
+    private _hasHeightConfig;
+    follow: string;
+    followOrigin: number;
+    followScale: number;
+    originOffset: number;
+    translateCache: number;
+    constructor();
+    get hasSizeConfig(): {
+        length: boolean;
+        width: boolean;
+        height: boolean;
+    };
+    get size(): Box3;
+    get radius(): number;
+    init(app: Scene3D): void;
+    reset(): void;
+    private _changeSize;
+    private _change;
+    generate(object?: Object3D, offset?: number): void;
+    show(): void;
+    hide(): void;
+    dispose(): void;
+    update(originOffset?: number): void;
+}

package/dist/device-viewer/group-roller.d.ts

@@ -0,0 +1,20 @@
+import { AMRAssembly } from './assembly';
+import { Object3D } from 'three';
+import EventEmitter from 'eventemitter3';
+export declare class GroupRoller extends AMRAssembly {
+    private _container;
+    private _emitter;
+    addEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    private _widthGap;
+    private _lengthGap;
+    private _row;
+    constructor();
+    loaded(glb: Object3D): void;
+    setShapeKey(key: string, value: number): void;
+    setGoodsSize(size: {
+        length: number;
+        width: number;
+        height: number;
+    }): void;
+    destroy(): void;
+}

package/dist/device-viewer/index.d.ts

@@ -18,18 +18,30 @@ export declare class DeviceViewer extends LitElement {
     theme: undefined | string;
     onChange: undefined | Function;
     usePathTracing: boolean;
+    shelfLevel: number;
+    shapeKeys: Map<any, any>;
     progressBar: HTMLDivElement | undefined;
     lineCircles: HTMLDivElement[] | undefined;
     lineWrapper: HTMLDivElement | undefined;
+    sizeLength: HTMLDivElement | undefined;
+    sizeWidth: HTMLDivElement | undefined;
+    sizeHeight: HTMLDivElement | undefined;
     fit: () => void;
     generateBVH: () => void;
     download: () => string;
     clearAMR: () => void;
     exportAMR: () => Promise<void>;
     addAMR: () => void;
+    generateEdges: () => void;
+    setShapeKey: (key: string, val: any) => void;
     cancel: () => void;
+    changeShelfLevel: (e: any) => void;
+    changeAmrHeight: (e: any) => void;
+    changeAmrLevel: (e: any) => void;
+    changeGoodsSize: (e: any) => void;
     dragstart: (e: DragEvent) => void;
     dragend: (e: DragEvent) => void;
+    getShapeKeyValue: (key: string) => any;
     protected render(): unknown;
     static styles: import("lit").CSSResult;
 }

package/dist/device-viewer/mechanism/mechanism.d.ts

@@ -0,0 +1,29 @@
+import { Object3D } from 'three';
+import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
+export interface UserData {
+    [key: string]: any;
+}
+export interface MechanismProps {
+    name: '';
+    userData?: UserData;
+    target: string;
+    default: number;
+    min: number;
+    max: number;
+}
+export declare class Mechanism extends CSS2DObject {
+    props: MechanismProps;
+    amr: Object3D;
+    private _direction;
+    private _controllingRotate;
+    private _controlling;
+    private _startAt;
+    private _looper;
+    private _initial;
+    private _canRotate;
+    private _timer;
+    mechanism: Object3D | undefined;
+    constructor(props: MechanismProps, amr: Object3D);
+    private _update;
+    dispose(): void;
+}

package/dist/device-viewer/outerline.d.ts

@@ -0,0 +1,16 @@
+import { Object3D, Vector3 } from 'three';
+import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
+export declare class Outerline extends Object3D {
+    radius: number;
+    private _text;
+    private _line;
+    private _box;
+    constructor(radius: number, height: number);
+    update(radius: number): void;
+    change(pos: Vector3): void;
+}
+export declare class RadiusText extends CSS2DObject {
+    private _wrapper;
+    constructor(radius: string);
+    update(radius: string): void;
+}

package/dist/device-viewer/roller.d.ts

@@ -0,0 +1,31 @@
+import { Object3D, Vector3 } from 'three';
+import { AMRAssembly } from './assembly';
+import EventEmitter from 'eventemitter3';
+export interface RollerProps {
+    goodsSize: Vector3;
+}
+export declare class Roller extends AMRAssembly {
+    private _props;
+    private _goodsWidthGap;
+    private _goodsLengthGap;
+    private _emitter;
+    addEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    private _shaft;
+    private _shaftInstances;
+    private _length;
+    private _container;
+    private _goodsContainer;
+    private _goodsSize;
+    private _goods;
+    constructor(_props: RollerProps);
+    get length(): number;
+    loaded(glb: Object3D): void;
+    setGoodsSize({ length, width, height }: {
+        length: number;
+        width: number;
+        height: number;
+    }): void;
+    setShapeKey(key: string, value: number): void;
+    private _generateShaft;
+    destroy(): void;
+}

package/dist/device-viewer/row.d.ts

@@ -0,0 +1,18 @@
+import { Object3D } from 'three';
+import { AMRAssembly } from './assembly';
+import EventEmitter from 'eventemitter3';
+import { ObjectSize } from './utils';
+export declare class Row extends Object3D {
+    private _items;
+    private _group;
+    private _gap;
+    protected _size: ObjectSize;
+    private _emitter;
+    addEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
+    get size(): ObjectSize;
+    get items(): AMRAssembly[];
+    constructor(gap?: number);
+    addItem(item: AMRAssembly): void;
+    updateLayout(): void;
+    destroy(): void;
+}

package/dist/device-viewer/scene.d.ts

@@ -1,15 +1,18 @@
 import { Mesh, MeshStandardMaterial, Object3D, PerspectiveCamera, Scene, Vector2, WebGLRenderer } from 'three';
-import { FullScreenQuad } from 'three/examples/jsm/postprocessing/Pass';
 import { OutlinePass } from 'three/examples/jsm/postprocessing/OutlinePass';
 import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass';
 import { OrbitControls } from 'three/examples/jsm/controls/OrbitControls';
-import { InstancedFlow } from 'three/examples/jsm/modifiers/CurveModifier';
+import { WebGLPathTracer } from 'three-gpu-pathtracer';
 import { EffectComposer } from 'three/examples/jsm/postprocessing/EffectComposer';
+import { Font } from 'three/examples/jsm/loaders/FontLoader';
 import EventEmitter from 'eventemitter3';
 import Stats from 'stats-fps.js';
 import { Pane } from 'tweakpane';
+import { Sound } from './sound';
 import { Slot, SLOT_EVENTS } from './slot';
 import { DeviceLines, Line } from './lines';
+import { Amr } from './amr';
+export declare const font: Font;
 export { Slot, DeviceLines, Line, SLOT_EVENTS };
 export interface Logo {
     name: string;
@@ -28,17 +31,19 @@ export interface SceneProps {
     useSound: boolean;
 }
 export declare class Scene3D {
-    private props;
+    props: SceneProps;
     stats: Stats;
     scene: Scene;
     renderer: WebGLRenderer;
-    ptRenderer: any;
-    fsQuad: FullScreenQuad;
+    private css2dRenderer;
+    private css3dRenderer;
+    pathTracer: WebGLPathTracer;
     mousePos: Vector2;
     mouseCoord: Vector2;
     offset: Vector2;
     size: Vector2;
     private _prevSelectedObj;
+    amr: Amr;
     _composer: EffectComposer;
     _outlinePass: OutlinePass;
     _outlinePassError: OutlinePass;
@@ -51,41 +56,23 @@ export declare class Scene3D {
     private _raycaster;
     private _selected;
     private _pointerDownTimeout;
-    flow: InstancedFlow | undefined;
     pane: Pane | undefined;
-    face: Mesh | undefined;
-    sceneInfo: {
-        materials: never[];
-        textures: never[];
-    };
-    private css2dRenderer;
-    _slots: Slot[];
-    _logos: Logo[];
-    _skins: Skin[];
+    lines: DeviceLines;
     private _dragging;
     readonly maxSample = 1024;
     sampleCount: number;
     private _usePathTracing;
     private _fpsCache;
     private _fpsCacheMax;
-    private _bodyOpacity;
-    lines: DeviceLines;
     private _emitter;
-    private _sound;
-    private _materialsCache;
-    private opacityCache;
+    sound: Sound;
+    private _ground;
     get usePathTracing(): boolean;
     set usePathTracing(use: boolean);
-    get slots(): Slot[];
-    get logos(): Logo[];
-    get skins(): Skin[];
     get fpsAverage(): number;
-    set bodyOpacity(o: number);
-    get bodyOpacity(): number;
     constructor(props: SceneProps);
     addEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
     removeEventListener: <T extends string | symbol>(event: T, fn: (...args: any[]) => void, context?: any) => EventEmitter<string | symbol, any>;
-    changeSkin(skin: Skin, value: string): void;
     showState(): void;
     hideState(): void;
     private _loadEnv;
@@ -95,7 +82,6 @@ export declare class Scene3D {
     private _pointerdown;
     private _detectTrackpad;
     private _initEvents;
-    changeLogo(logo: Logo, url: string): void;
     generateBVH(): Promise<void>;
     download(): string;
     clearAMR(): void;
@@ -103,7 +89,7 @@ export declare class Scene3D {
         [key: string]: any;
     }>;
     addAMR(url: string): Promise<void>;
-    generateSlot(m: Object3D): Slot | undefined;
+    generateEdges(): void;
     fit: () => void;
     select(obj: string | Object3D | Object3D[]): void;
     appendTo(parent: HTMLElement): void;

package/dist/device-viewer/slot.d.ts

@@ -1,9 +1,13 @@
-import { Object3D } from 'three';
+import { Mesh, Object3D } from 'three';
 import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
 import EventEmitter from 'eventemitter3';
 import { Scene3D } from './scene';
 export interface SlotProps {
     name: string;
+    follows: Map<string, {
+        scale: number;
+        origin: number;
+    }>;
     slot: Object3D;
 }
 export interface DeviceInfo {
@@ -23,6 +27,7 @@ export declare const SLOT_EVENTS: {
 };
 export declare class Slot extends CSS2DObject {
     private props;
+    private target;
     private _emitter;
     private _slotContainer;
     private _slotUI;
@@ -35,9 +40,12 @@ export declare class Slot extends CSS2DObject {
     private _loading;
     private _selected;
     private _deviceSelected;
+    private _timer;
     get hasDevice(): boolean;
     deviceInfo: DeviceInfo | undefined;
-    constructor(props: SlotProps);
+    constructor(props: SlotProps, target: Mesh | undefined);
+    shapeKeyChanged(key: string, value: number): void;
+    private _tick;
     loadGlb(sglb: string): Promise<Object3D<import("three").Object3DEventMap> | undefined>;
     installBracket(url: string): Promise<void>;
     install(info: DeviceInfo): Promise<void>;

package/dist/device-viewer/text2.d.ts

@@ -0,0 +1,4 @@
+import { CSS2DObject } from 'three/examples/jsm/renderers/CSS2DRenderer';
+export declare class Text2 extends CSS2DObject {
+    constructor(text: string);
+}

package/dist/device-viewer/text3.d.ts

@@ -0,0 +1,4 @@
+import { CSS3DObject } from 'three/examples/jsm/renderers/CSS3DRenderer';
+export declare class Text3 extends CSS3DObject {
+    constructor(text: string);
+}

package/dist/device-viewer/utils/index.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from 'three';
+import { Box3, Mesh, Object3D, Vector3 } from 'three';
 export declare const clearThreeObjectMesh: (object: Object3D) => void;
 export declare const uuid: () => string;
 export declare function getElementLeftPosition(element: any): {
@@ -9,3 +9,28 @@ export declare function getRelativePosition(child: Element, target: Element): {
     y: number;
     x: number;
 };
+export declare function getVector3FromArray(arr: number[]): Vector3;
+export declare function getLocationPosition(obj: Object3D, wp: Vector3): Vector3;
+export declare function getScaledSettings(): {
+    tiles: number;
+    renderScale: number;
+};
+export declare function generateMorphTargetWithTarget(target: Mesh): Vector3;
+export declare function generateMorphTarget(originPoint: Vector3, morphPositions: any[], influences: number[]): Vector3;
+export declare function calculateTotalDimensionsUsingVertices(object: Object3D): {
+    box: Box3;
+    maxRadius: number;
+    height: number;
+    hasLength: boolean;
+    hasWidth: boolean;
+    hasHeight: boolean;
+};
+export declare function calculateInscribedCircleRadius(length: number, width: number): number;
+export declare function calculateCircleRadiusByBox3(box: Box3): number;
+export declare function debounce(fn: any, delay: number, scope?: any): () => void;
+export declare class ObjectSize {
+    length: number;
+    width: number;
+    height: number;
+    constructor(length: number, width: number, height: number);
+}