gaesup-world 0.2.25 → 0.2.26

package/dist/gaesup/tools/keyBoardToolTip/constant.js

@@ -0,0 +1,122 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+export var KeyboardF = {
+    ESC: { name: "ESC", gridRow: "1/2", gridColumn: "1/2" },
+    F1: { name: "F1", gridRow: "1/2", gridColumn: "3/4" },
+    F2: { name: "F2", gridRow: "1/2", gridColumn: "4/5" },
+    F3: { name: "F3", gridRow: "1/2", gridColumn: "5/6" },
+    F4: { name: "F4", gridRow: "1/2", gridColumn: "6/7" },
+    F5: { name: "F5", gridRow: "1/2", gridColumn: "8/9" },
+    F6: { name: "F6", gridRow: "1/2", gridColumn: "9/10" },
+    F7: { name: "F7", gridRow: "1/2", gridColumn: "10/11" },
+    F8: { name: "F8", gridRow: "1/2", gridColumn: "11/12" },
+    F9: { name: "F9", gridRow: "1/2", gridColumn: "13/14" },
+    F10: { name: "F10", gridRow: "1/2", gridColumn: "14/15" },
+    F11: { name: "F11", gridRow: "1/2", gridColumn: "15/16" },
+    F12: { name: "F12", gridRow: "1/2", gridColumn: "16/17" },
+};
+export var KeyboardOne = {
+    Backquote: { name: "`", gridRow: "2/3", gridColumn: "1/3" },
+    Digit1: { name: "1", gridRow: "2/3", gridColumn: "3/4" },
+    Digit2: { name: "2", gridRow: "2/3", gridColumn: "4/5" },
+    Digit3: { name: "3", gridRow: "2/3", gridColumn: "5/6" },
+    Digit4: { name: "4", gridRow: "2/3", gridColumn: "6/7" },
+    Digit5: { name: "5", gridRow: "2/3", gridColumn: "7/8" },
+    Digit6: { name: "6", gridRow: "2/3", gridColumn: "8/9" },
+    Digit7: { name: "7", gridRow: "2/3", gridColumn: "9/10" },
+    Digit8: { name: "8", gridRow: "2/3", gridColumn: "10/11" },
+    Digit9: { name: "9", gridRow: "2/3", gridColumn: "11/12" },
+    Digit0: { name: "0", gridRow: "2/3", gridColumn: "12/13" },
+    Minus: { name: "-", gridRow: "2/3", gridColumn: "13/14" },
+    Equal: { name: "=", gridRow: "2/3", gridColumn: "14/15" },
+    Backspace: { name: "Backspace", gridRow: "2/3", gridColumn: "15/17" },
+};
+export var KeyboardTwo = {
+    Tab: { name: "Tab", gridRow: "3/4", gridColumn: "1/3" },
+    KeyQ: { name: "Q", gridRow: "3/4", gridColumn: "3/4" },
+    KeyW: { name: "W", gridRow: "3/4", gridColumn: "4/5" },
+    KeyE: { name: "E", gridRow: "3/4", gridColumn: "5/6" },
+    KeyR: { name: "R", gridRow: "3/4", gridColumn: "6/7" },
+    KeyT: { name: "T", gridRow: "3/4", gridColumn: "7/8" },
+    KeyY: { name: "Y", gridRow: "3/4", gridColumn: "8/9" },
+    KeyU: { name: "U", gridRow: "3/4", gridColumn: "9/10" },
+    KeyI: { name: "I", gridRow: "3/4", gridColumn: "10/11" },
+    KeyO: { name: "O", gridRow: "3/4", gridColumn: "11/12" },
+    KeyP: { name: "P", gridRow: "3/4", gridColumn: "12/13" },
+    BracketLeft: { name: "[", gridRow: "3/4", gridColumn: "13/14" },
+    BracketRight: { name: "]", gridRow: "3/4", gridColumn: "14/15" },
+    Backslash: { name: "\\", gridRow: "3/4", gridColumn: "15/17" },
+};
+export var KeyboardThree = {
+    CapsLock: { name: "CapsLock", gridRow: "4/5", gridColumn: "1/3" },
+    KeyA: { name: "A", gridRow: "4/5", gridColumn: "3/4" },
+    KeyS: { name: "S", gridRow: "4/5", gridColumn: "4/5" },
+    KeyD: { name: "D", gridRow: "4/5", gridColumn: "5/6" },
+    KeyF: { name: "F", gridRow: "4/5", gridColumn: "6/7" },
+    KeyG: { name: "G", gridRow: "4/5", gridColumn: "7/8" },
+    KeyH: { name: "H", gridRow: "4/5", gridColumn: "8/9" },
+    KeyJ: { name: "J", gridRow: "4/5", gridColumn: "9/10" },
+    KeyK: { name: "K", gridRow: "4/5", gridColumn: "10/11" },
+    KeyL: { name: "L", gridRow: "4/5", gridColumn: "11/12" },
+    Semicolon: { name: ";", gridRow: "4/5", gridColumn: "12/13" },
+    Quote: { name: "'", gridRow: "4/5", gridColumn: "13/14" },
+    Enter: { name: "Enter", gridRow: "4/5", gridColumn: "14/17" },
+};
+export var KeyboardFour = {
+    ShiftLeft: {
+        name: "Shift",
+        gridRow: "5/6",
+        gridColumn: "1/4",
+        code: "Shift",
+    },
+    KeyZ: { name: "Z", gridRow: "5/6", gridColumn: "4/5" },
+    KeyX: { name: "X", gridRow: "5/6", gridColumn: "5/6" },
+    KeyC: { name: "C", gridRow: "5/6", gridColumn: "6/7" },
+    KeyV: { name: "V", gridRow: "5/6", gridColumn: "7/8" },
+    KeyB: { name: "B", gridRow: "5/6", gridColumn: "8/9" },
+    KeyN: { name: "N", gridRow: "5/6", gridColumn: "9/10" },
+    KeyM: { name: "M", gridRow: "5/6", gridColumn: "10/11" },
+    Comma: { name: ",", gridRow: "5/6", gridColumn: "11/12" },
+    Period: { name: ".", gridRow: "5/6", gridColumn: "12/13" },
+    Slash: { name: "/", gridRow: "5/6", gridColumn: "13/14" },
+    ShiftRight: {
+        name: "Shift",
+        gridRow: "5/6",
+        gridColumn: "14/17",
+        code: "Shift",
+    },
+};
+export var KeyboardFive = {
+    ControlLeft: {
+        name: "Control",
+        gridRow: "6/7",
+        gridColumn: "1/3",
+        code: "Control",
+    },
+    Option: { name: "Option", gridRow: "6/7", gridColumn: "3/5" },
+    AltLeft: { name: "Alt", gridRow: "6/7", gridColumn: "5/7", code: "Alt" },
+    Space: { name: "Space", gridRow: "6/7", gridColumn: "7/13" },
+    AltRight: { name: "Alt", gridRow: "6/7", gridColumn: "13/15", code: "Alt" },
+    ControlRight: {
+        name: "Control",
+        gridRow: "6/7",
+        gridColumn: "15/17",
+        code: "Control",
+    },
+};
+export var KeyboardArrow = {
+    ArrowUp: { name: "Up", gridRow: "5/6", gridColumn: "19/20" },
+    ArrowLeft: { name: "Left", gridRow: "6/7", gridColumn: "18/19" },
+    ArrowDown: { name: "Down", gridRow: "6/7", gridColumn: "19/20" },
+    ArrowRight: { name: "Right", gridRow: "6/7", gridColumn: "20/21" },
+};
+export var KeyBoardAll = __assign(__assign(__assign(__assign(__assign(__assign(__assign({}, KeyboardF), KeyboardOne), KeyboardTwo), KeyboardThree), KeyboardFour), KeyboardFive), KeyboardArrow);

package/dist/gaesup/tools/keyBoardToolTip/default.d.ts

@@ -0,0 +1,10 @@
+export declare const KeyboardMapDefault: {
+    name: string;
+    keys: string[];
+}[];
+export declare const keyboardToolTipDefault: {
+    keyBoardMap: {
+        name: string;
+        keys: string[];
+    }[];
+};

package/dist/gaesup/tools/keyBoardToolTip/default.js

@@ -0,0 +1,12 @@
+export var KeyboardMapDefault = [
+    { name: "forward", keys: ["ArrowUp", "KeyW"] },
+    { name: "backward", keys: ["ArrowDown", "KeyS"] },
+    { name: "leftward", keys: ["ArrowLeft", "KeyA"] },
+    { name: "rightward", keys: ["ArrowRight", "KeyD"] },
+    { name: "jump", keys: ["Space"] },
+    { name: "run", keys: ["Shift"] },
+    { name: "greet", keys: ["KeyZ"] },
+];
+export var keyboardToolTipDefault = {
+    keyBoardMap: KeyboardMapDefault,
+};

package/dist/gaesup/tools/keyBoardToolTip/index.d.ts

@@ -0,0 +1,3 @@
+import "./style.css";
+import { keyBoardToolTipType } from "./type";
+export declare function KeyBoardToolTip(props: keyBoardToolTipType): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/tools/keyBoardToolTip/index.js

@@ -0,0 +1,70 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useContext } from "react";
+import { GaesupWorldContext } from "../../world/context";
+import { KeyBoardAll } from "./constant";
+import "./style.css";
+export function KeyBoardToolTip(props) {
+    var worldContext = useContext(GaesupWorldContext);
+    var keyBoardMap = props.keyBoardMap, keyBoardToolTipInnerStyle = props.keyBoardToolTipInnerStyle, selectedKeyCapStyle = props.selectedKeyCapStyle, notSelectedkeyCapStyle = props.notSelectedkeyCapStyle, keyCapStyle = props.keyCapStyle, label = props.label;
+    var mode = worldContext.mode, control = worldContext.control;
+    var keyArray = Object.entries(KeyBoardAll).reduce(function (keyArray, cur) {
+        var key = cur[0], value = cur[1];
+        var gridRow = value.gridRow, gridColumn = value.gridColumn, name = value.name;
+        var labeledName = (label === null || label === void 0 ? void 0 : label[name]) || name;
+        var keyBoardItem = {
+            code: value.code || key,
+            gridRow: gridRow,
+            gridColumn: gridColumn,
+            name: labeledName,
+        };
+        keyArray.push(keyBoardItem);
+        return keyArray;
+    }, []);
+    var codeToActionObj = keyBoardMap.reduce(function (maps, keyboardMapItem) {
+        keyboardMapItem.keys.forEach(function (key) {
+            maps[key] = keyboardMapItem.name;
+        });
+        return maps;
+    }, {});
+    return (_jsx(_Fragment, { children: mode.controller === "keyboard" && (_jsx("div", { className: "keyBoardToolInner", style: keyBoardToolTipInnerStyle, children: keyArray.map(function (item, key) {
+                var background = "rgba(0, 0, 0, 0.1)";
+                var boxShadow = "0 0 5px rgba(0, 0, 0, 0.2)";
+                var isSelect = "none";
+                if (codeToActionObj[item.code]) {
+                    if (control[codeToActionObj[item.code]]) {
+                        isSelect = "select";
+                        background = "linear-gradient( 68.4deg,  rgba(99,251,215,1) -0.4%, rgba(5,222,250,1) 100.2% )";
+                        boxShadow = "0 0 10px rgba(99,251,215,1)";
+                    }
+                    else {
+                        isSelect = "notSelect";
+                        background = "rgba(0, 0, 0, 0.6)";
+                        boxShadow = "0 0 10px rgba(0, 0, 0, 0.6)";
+                    }
+                }
+                var color = "white";
+                if (codeToActionObj[item.code] &&
+                    control[codeToActionObj[item.code]]) {
+                    color = "black";
+                }
+                var keyStyle = keyCapStyle;
+                if (isSelect === "select") {
+                    keyStyle = __assign({}, selectedKeyCapStyle);
+                }
+                else if (isSelect === "notSelect") {
+                    keyStyle = __assign({}, notSelectedkeyCapStyle);
+                }
+                return (_jsx("div", { className: "keyCap", style: __assign({ background: background, boxShadow: boxShadow, color: color, gridRow: item.gridRow, gridColumn: item.gridColumn }, keyStyle), children: item.name }, key));
+            }) })) }));
+}

package/dist/gaesup/tools/keyBoardToolTip/type.d.ts

@@ -0,0 +1,37 @@
+import { CSSProperties } from "react";
+export type keyboardMapType = {
+    name: string;
+    keys: string[];
+    label?: string;
+    match?: string;
+}[];
+export type keyMapItemType = {
+    name: string;
+    gridRow: string;
+    gridColumn: string;
+    code?: string;
+};
+export type keyArrayItemType = {
+    code: string;
+    gridRow: string;
+    gridColumn: string;
+    name: string;
+};
+export type keyboardMapItemType = {
+    name: string;
+    keys: string[];
+};
+export type keyBoardMapType = {
+    [name: string]: keyMapItemType;
+};
+export type keyBoardLabelType = {
+    [name: string]: string;
+};
+export type keyBoardToolTipType = {
+    keyBoardLabel?: keyBoardLabelType;
+    keyBoardMap?: keyboardMapItemType[];
+    label?: Record<string, string>;
+} & {
+    [key in "keyBoardToolTipInnerStyle" | "notSelectedkeyCapStyle" | "selectedKeyCapStyle" | "keyCapStyle"]?: CSSProperties;
+};
+export type keyBoardToolTipPartialType = Partial<keyBoardToolTipType>;

package/dist/gaesup/tools/keyBoardToolTip/type.js

@@ -0,0 +1 @@
+export {};

package/dist/gaesup/tools/miniMap/default.d.ts

@@ -0,0 +1,9 @@
+export declare const minimapDefault: {
+    scale: number;
+    minScale: number;
+    maxScale: number;
+    blockScale: boolean;
+};
+export declare const minimapInnerDefault: {
+    props: {};
+};

package/dist/gaesup/tools/miniMap/default.js

@@ -0,0 +1,9 @@
+export var minimapDefault = {
+    scale: 0.5,
+    minScale: 0.1,
+    maxScale: 2,
+    blockScale: false,
+};
+export var minimapInnerDefault = {
+    props: {},
+};

package/dist/gaesup/tools/miniMap/index.d.ts

@@ -0,0 +1,3 @@
+import "./style.css";
+import { minimapType } from "./type";
+export declare function MiniMap(props: minimapType): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/tools/miniMap/index.js

@@ -0,0 +1,72 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useContext, useState } from "react";
+import { GaesupWorldContext } from "../../world/context";
+import { minimapDefault } from "./default";
+import "./style.css";
+// X 축은 동(+) 서(-) 방향, 즉 경도를 나타낸다.
+// Z 축은 남(+) 북(-) 방향, 즉 위도를 나타낸다.
+export function MiniMap(props) {
+    var _a = useContext(GaesupWorldContext), minimap = _a.minimap, activeState = _a.activeState, mode = _a.mode;
+    var _b = useState(props.scale || minimapDefault.scale), scale = _b[0], setscale = _b[1];
+    var innerStyle = props.innerStyle, textStyle = props.textStyle, objectStyle = props.objectStyle, avatarStyle = props.avatarStyle, scaleStyle = props.scaleStyle, directionStyle = props.directionStyle, plusMinusStyle = props.plusMinusStyle;
+    var upscale = useCallback(function () {
+        var max = props.maxScale || minimapDefault.maxScale;
+        setscale(function (scale) { return Math.min(max, scale + 0.1); });
+    }, [setscale, scale]);
+    var downscale = useCallback(function () {
+        var min = props.minScale || minimapDefault.minScale;
+        setscale(function (scale) { return Math.max(min, scale - 0.1); });
+    }, [setscale, scale]);
+    return (_jsxs("div", { className: "minimap", onWheel: function (e) {
+            if (props.blockScale)
+                return;
+            if (e.deltaY <= 0)
+                upscale();
+            else
+                downscale();
+        }, children: [_jsx("div", { className: "minimapOuter", style: objectStyle }), _jsxs("div", { className: "minimapInner", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                        ? "translate(-50%, -50%) rotate(180deg) "
+                        : "translate(-50%, -50%) rotate(".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, innerStyle), children: [_jsx("div", { className: "east direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(-50%, -50%) rotate(180deg) "
+                                : "translate(-50%, -50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "E" }), _jsx("div", { className: "west direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(50%, -50%) rotate(180deg) "
+                                : "translate(50%, -50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "W" }), _jsx("div", { className: "south direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(-50%, 50%) rotate(180deg) "
+                                : "translate(-50%, 50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "S" }), _jsx("div", { className: "north direction", style: __assign({ transform: props.blockRotate || mode.control === "normal"
+                                ? "translate(-50%, -50%) rotate(180deg) "
+                                : "translate(-50%, -50%) rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }, directionStyle), children: "N" }), Object.values(minimap.props).map(function (_a, key) {
+                        var center = _a.center, size = _a.size, text = _a.text;
+                        var X = (center.x - activeState.position.x) * scale;
+                        var Z = (center.z - activeState.position.z) * scale;
+                        return (_jsxs("div", { children: [_jsx("div", { className: "minimapObject", style: __assign({ width: "".concat(size.x * scale, "rem"), height: "".concat(size.z * scale, "rem"), top: "50%", left: "50%", transform: "translate(-50.1%, -50.1%) translate(".concat(-X, "rem, ").concat(-Z, "rem)"), transformOrigin: "50% 50%", zIndex: 1 + key }, objectStyle) }, key), _jsx("div", { className: "textObject", style: {
+                                        width: "".concat(size.x * scale, "rem"),
+                                        height: "".concat(size.z * scale, "rem"),
+                                        top: "50.1%",
+                                        left: "50.1%",
+                                        transform: "translate(-50.1%, -50.1%) translate(".concat(-X, "rem, ").concat(-Z, "rem)"),
+                                        transformOrigin: "50.1% 50.1%",
+                                        zIndex: 1001 + key,
+                                    }, children: text && (_jsx("div", { className: "text", style: __assign(__assign({}, textStyle), { zIndex: 1001 + key, transform: props.blockRotate || mode.control === "normal"
+                                                ? " rotate(180deg) "
+                                                : " rotate(-".concat((activeState.euler.y * 180) / Math.PI + 180, "deg) ") }), children: text })) })] }, key));
+                    }), _jsx("div", { className: "avatar", style: avatarStyle })] }), !props.blockScaleControl && (_jsxs("div", { className: "scale", style: scaleStyle, children: [_jsx("div", { className: "plusMinus", style: plusMinusStyle, onClick: function () {
+                            if (props.blockScale)
+                                return;
+                            downscale();
+                        }, children: "+" }), "SCALE 1:", Math.round(100 / scale), _jsx("div", { className: "plusMinus", style: plusMinusStyle, onClick: function () {
+                            if (props.blockScale)
+                                return;
+                            upscale();
+                        }, children: "-" })] }))] }));
+}

package/dist/gaesup/tools/miniMap/type.d.ts

@@ -0,0 +1,25 @@
+import { CSSProperties, ReactElement } from "react";
+import * as THREE from "three";
+export type minimapPropsType = {
+    type: "normal" | "ground";
+    text?: string;
+    center: THREE.Vector3;
+    size: THREE.Vector3;
+    children?: ReactElement;
+    position?: THREE.Vector3;
+};
+export type minimapInnerType = {
+    props: {
+        [key: string]: minimapPropsType;
+    };
+};
+export type minimapType = {
+    [key in "minimapStyle" | "outerStyle" | "innerStyle" | "textStyle" | "objectStyle" | "avatarStyle" | "directionStyle" | "scaleStyle" | "plusMinusStyle"]?: CSSProperties;
+} & {
+    minScale?: number;
+    maxScale?: number;
+    blockScale?: boolean;
+    scale?: number;
+    blockRotate?: boolean;
+    blockScaleControl?: boolean;
+};

package/dist/gaesup/tools/miniMap/type.js

@@ -0,0 +1 @@
+export {};

package/dist/gaesup/tools/rideable/index.d.ts

@@ -0,0 +1,3 @@
+import { rideableType } from "../../world/context/type.js";
+import "./style.css";
+export declare function Rideable(props: rideableType): import("react/jsx-runtime").JSX.Element;

package/dist/gaesup/tools/rideable/index.js

@@ -0,0 +1,79 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useContext, useEffect } from "react";
+import { euler } from "@react-three/rapier";
+import { PassiveAirplane } from "../../component/passive/airplane/index.js";
+import { PassiveVehicle } from "../../component/passive/vehicle/index.js";
+import { useRideable } from "../../hooks/useRideable/index.js";
+import { V3 } from "../../utils/vector.js";
+import { GaesupWorldContext } from "../../world/context/index.js";
+import "./style.css";
+export function Rideable(props) {
+    var _this = this;
+    var _a = useContext(GaesupWorldContext), states = _a.states, rideable = _a.rideable;
+    var _b = useRideable(), initRideable = _b.initRideable, getRideable = _b.getRideable, ride = _b.ride, landing = _b.landing;
+    var current = getRideable(props.objectkey);
+    useEffect(function () {
+        initRideable(props);
+    }, []);
+    useEffect(function () {
+        if ((states === null || states === void 0 ? void 0 : states.isLanding) &&
+            rideable[props.objectkey] &&
+            !rideable[props.objectkey].visible) {
+            landing(props.objectkey);
+        }
+    }, [states === null || states === void 0 ? void 0 : states.isLanding]);
+    var onCollisionEnter = function (e) { return __awaiter(_this, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, ride(e, props)];
+                case 1:
+                    _a.sent();
+                    return [2 /*return*/];
+            }
+        });
+    }); };
+    return (_jsx(_Fragment, { children: current &&
+            rideable[props.objectkey] &&
+            rideable[props.objectkey].visible && (_jsxs("group", { userData: { intangible: true }, children: [props.objectType === "vehicle" && (_jsx(PassiveVehicle, { position: current.position || V3(0, 0, 0), euler: current.rotation || euler(), currentAnimation: "idle", offset: props.offset, urls: {
+                        vehicleUrl: props.url,
+                        wheelUrl: props.wheelUrl,
+                    }, onCollisionEnter: onCollisionEnter })), props.objectType === "airplane" && (_jsx(PassiveAirplane, { position: current.position || V3(0, 0, 0), euler: current.rotation || euler(), currentAnimation: "idle", offset: props.offset, urls: {
+                        airplaneUrl: props.url,
+                    }, onCollisionEnter: onCollisionEnter }))] })) }));
+}

package/dist/gaesup/tools/type.d.ts

@@ -0,0 +1,2 @@
+import { CSSProperties } from "react";
+export type VECssType = Record<keyof CSSProperties, string>;

package/dist/gaesup/tools/type.js

@@ -0,0 +1 @@
+export {};

package/dist/gaesup/tools/zoomButton/index.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="react" />
+import "@/tools/zoomButton/style.css";
+export type zoomButtonPropsType = {
+    children?: React.ReactNode;
+    position: THREE.Vector3;
+    target?: THREE.Vector3;
+    keepBlocking?: boolean;
+    zoomButtonStyle?: React.CSSProperties;
+};
+export declare function useZoom(): {
+    setZoom: (position: THREE.Vector3, isZoom: boolean) => Promise<void>;
+    openCamera: () => Promise<void>;
+    closeCamera: (position: THREE.Vector3) => Promise<void>;
+    isZoom: boolean;
+    setIsZoom: import("react").Dispatch<import("react").SetStateAction<boolean>>;
+    moveToCamera: () => Promise<void>;
+};
+export declare function ZoomButton(props: zoomButtonPropsType): import("react/jsx-runtime").JSX.Element;