beardos-toolbox 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,105 @@
+import * as s3 from './s3';
+export * from './s3';
+import JSONL from './jsonl';
+export * from './misc-js-funcs';
+import tileMap from './tile-map';
+export * from './tile-map';
+export { s3, JSONL, tileMap };
+declare const _default: {
+    s3: typeof s3;
+    JSONL: {
+        stringify: (data: any[]) => string;
+        parse: (data: string) => any[];
+    };
+    tileMap: {
+        TileFlags: {
+            readonly NONE: 0;
+            readonly BLOCKED: 1;
+            readonly OCCUPIED: 2;
+            readonly VISIBLE: 4;
+            readonly EXPLORED: 8;
+            readonly WATER: 16;
+            readonly HAZARD: 32;
+        };
+        createTileMap: <T>(width: number, height: number) => import("./tile-map").TileMap<T>;
+        getTileIndex: (map: import("./tile-map").TileMap<unknown>, x: number, y: number) => number;
+        getTileInfo: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number) => import("./tile-map").TileInfo<T> | null;
+        indexToCoords: (map: import("./tile-map").TileMap<unknown>, index: number) => {
+            x: number;
+            y: number;
+        };
+        setFlag: (map: import("./tile-map").TileMap<unknown>, x: number, y: number, flag: number) => void;
+        clearFlag: (map: import("./tile-map").TileMap<unknown>, x: number, y: number, flag: number) => void;
+        toggleFlag: (map: import("./tile-map").TileMap<unknown>, x: number, y: number, flag: number) => void;
+        hasFlag: (map: import("./tile-map").TileMap<unknown>, x: number, y: number, flag: number) => boolean;
+        addEntity: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number, entity: T) => boolean;
+        removeEntity: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number, predicate: (e: T) => boolean) => boolean;
+        moveEntity: <T>(map: import("./tile-map").TileMap<T>, fromX: number, fromY: number, toX: number, toY: number, predicate: (e: T) => boolean) => boolean;
+        getEntitiesAt: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number) => T[];
+        clearEntitiesAt: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number) => void;
+        getAdjacentIndices: (map: import("./tile-map").TileMap<unknown>, x: number, y: number, includeDiagonals?: boolean) => number[];
+        getAdjacentTiles: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number, includeDiagonals?: boolean) => import("./tile-map").TileInfo<T>[];
+        getIndicesInRange: (map: import("./tile-map").TileMap<unknown>, x: number, y: number, range: number, shape?: import("./tile-map").RangeShape, includeOrigin?: boolean) => number[];
+        getTilesInRange: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number, range: number, shape?: import("./tile-map").RangeShape, includeOrigin?: boolean) => import("./tile-map").TileInfo<T>[];
+        getEntitiesInRange: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number, range: number, shape?: import("./tile-map").RangeShape, includeOrigin?: boolean) => T[];
+        validateTile: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number, validator?: import("./tile-map").TileValidator<T>) => boolean;
+        validateRange: <T>(map: import("./tile-map").TileMap<T>, x: number, y: number, range: number, validator: import("./tile-map").TileValidator<T>, shape?: import("./tile-map").RangeShape, includeOrigin?: boolean) => boolean;
+        createSpatialConfig: (tileWidth: number, tileHeight: number, originX?: number, originY?: number) => import("./tile-map").SpatialConfig;
+        worldToTile: (spatial: import("./tile-map").SpatialConfig, wx: number, wy: number) => {
+            x: number;
+            y: number;
+        };
+        tileToWorld: (spatial: import("./tile-map").SpatialConfig, tx: number, ty: number) => {
+            x: number;
+            y: number;
+        };
+        tileCenterWorld: (spatial: import("./tile-map").SpatialConfig, tx: number, ty: number) => {
+            x: number;
+            y: number;
+        };
+        screenToWorld: (cameraX: number, cameraY: number, sx: number, sy: number) => {
+            x: number;
+            y: number;
+        };
+        worldToScreen: (cameraX: number, cameraY: number, wx: number, wy: number) => {
+            x: number;
+            y: number;
+        };
+        screenToTile: (spatial: import("./tile-map").SpatialConfig, cameraX: number, cameraY: number, sx: number, sy: number) => {
+            x: number;
+            y: number;
+        };
+        tileToScreen: (spatial: import("./tile-map").SpatialConfig, cameraX: number, cameraY: number, tx: number, ty: number) => {
+            x: number;
+            y: number;
+        };
+        worldToTileExact: (spatial: import("./tile-map").SpatialConfig, wx: number, wy: number) => import("./tile-map").TilePosition;
+        getTileAtWorld: <T>(map: import("./tile-map").TileMap<T>, spatial: import("./tile-map").SpatialConfig, wx: number, wy: number) => import("./tile-map").TileInfo<T> | null;
+        getTileAtScreen: <T>(map: import("./tile-map").TileMap<T>, spatial: import("./tile-map").SpatialConfig, cameraX: number, cameraY: number, sx: number, sy: number) => import("./tile-map").TileInfo<T> | null;
+    };
+    utils: {
+        sleep: (ms: number) => Promise<unknown>;
+        chunkArray: (source: Array<any>, chunkSize?: number) => any;
+        settledSeparator: (result: Array<PromiseSettledResult<any>>) => {
+            settled: PromiseFulfilledResult<any>[];
+            rejected: PromiseRejectedResult[];
+            total: number;
+        };
+        timeFormat: (ms: number) => string;
+        timeSinceString: (ms: number) => string;
+        generateRandomString: (length?: number) => string;
+        default: {
+            sleep: (ms: number) => Promise<unknown>;
+            chunkArray: (source: Array<any>, chunkSize?: number) => any;
+            settledSeparator: (result: Array<PromiseSettledResult<any>>) => {
+                settled: PromiseFulfilledResult<any>[];
+                rejected: PromiseRejectedResult[];
+                total: number;
+            };
+            timeFormat: (ms: number) => string;
+            timeSinceString: (ms: number) => string;
+            generateRandomString: (length?: number) => string;
+        };
+    };
+};
+export default _default;

package/dist/index.mjs

@@ -0,0 +1,490 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// s3.ts
+var s3_exports = {};
+__export(s3_exports, {
+  deleteObject: () => deleteObject,
+  getClient: () => getClient,
+  getObject: () => getObject,
+  listObjects: () => listObjects,
+  putObject: () => putObject
+});
+import { S3Client, PutObjectCommand, GetObjectCommand, ListObjectsV2Command, DeleteObjectCommand } from "@aws-sdk/client-s3";
+var client;
+var getClient = ({ region, accessKeyId, secretAccessKey }) => {
+  if (!client) {
+    client = new S3Client({ region, credentials: { accessKeyId, secretAccessKey } });
+  }
+  return client;
+};
+var putObject = async (config, data, key, contentType) => {
+  try {
+    const cl = getClient(config);
+    const params = {
+      Bucket: config.bucket,
+      Key: key,
+      Body: typeof data === "string" ? Buffer.from(data, "utf-8") : data
+    };
+    if (contentType) {
+      params.ContentType = contentType;
+    }
+    return await cl.send(new PutObjectCommand(params));
+  } catch (e) {
+    console.error("Could not upload json file", { error: e });
+    throw e;
+  }
+};
+var getObject = async (config, key) => {
+  const params = {
+    Bucket: config.bucket,
+    Key: key
+  };
+  try {
+    const cl = getClient(config);
+    return await cl.send(new GetObjectCommand(params));
+  } catch (e) {
+    console.error("Could not get object from s3", { error: e, params });
+    throw e;
+  }
+};
+var listObjects = async (config, prefix, Marker) => {
+  const params = {
+    Bucket: config.bucket,
+    Prefix: prefix
+  };
+  if (Marker) {
+    params.StartAfter = Marker;
+  }
+  try {
+    const cl = getClient(config);
+    const response = await cl.send(new ListObjectsV2Command(params));
+    return { Objects: response.Contents ?? [], Marker: response.NextContinuationToken };
+  } catch (e) {
+    console.error("Could not upload json file", { error: e });
+    throw e;
+  }
+};
+var deleteObject = async (config, Key) => {
+  const params = {
+    Bucket: config.bucket,
+    Key
+  };
+  try {
+    const cl = getClient(config);
+    return await cl.send(new DeleteObjectCommand(params));
+  } catch (e) {
+    console.error("Could not delete object from s3", { error: e, params });
+    throw e;
+  }
+};
+
+// jsonl.ts
+import { EOL } from "os";
+var jsonl_default = {
+  stringify: (data) => {
+    return data.map((d) => JSON.stringify(d)).join(EOL);
+  },
+  parse: (data) => {
+    return data.split(EOL).map((d, i) => {
+      try {
+        return JSON.parse(d);
+      } catch (e) {
+        console.error("Could not parse JSONL on line: " + i, { error: e.message, line: i });
+      }
+    });
+  }
+};
+
+// misc-js-funcs.ts
+var misc_js_funcs_exports = {};
+__export(misc_js_funcs_exports, {
+  chunkArray: () => chunkArray,
+  default: () => misc_js_funcs_default,
+  generateRandomString: () => generateRandomString,
+  settledSeparator: () => settledSeparator,
+  sleep: () => sleep,
+  timeFormat: () => timeFormat,
+  timeSinceString: () => timeSinceString
+});
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var chunkArray = (source, chunkSize = 10) => {
+  const chunks = source.reduce((resultArray, item, index) => {
+    const chunkIndex = Math.floor(index / chunkSize);
+    if (!resultArray[chunkIndex]) {
+      resultArray[chunkIndex] = [];
+    }
+    resultArray[chunkIndex].push(item);
+    return resultArray;
+  }, []);
+  return chunks;
+};
+var settledSeparator = (result) => {
+  const settled = result.filter((r) => r.status === "fulfilled");
+  const rejected = result.filter((r) => r.status === "rejected");
+  return { settled, rejected, total: result.length };
+};
+var timeFormat = (ms) => {
+  if (ms < 1e3) return `${ms} ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(2)} secs`;
+  if (ms < 36e5) return `${(ms / 6e4).toFixed(2)} mins`;
+  return `${(ms / 36e5).toFixed(2)} hrs`;
+};
+var timeSinceString = (ms) => {
+  return timeFormat(Date.now() - ms);
+};
+var generateRandomString = (length = 8) => {
+  return Math.random().toString(36).substring(2, 2 + length);
+};
+var misc_js_funcs_default = {
+  sleep,
+  chunkArray,
+  settledSeparator,
+  timeFormat,
+  timeSinceString,
+  generateRandomString
+};
+
+// tile-map.ts
+var TileFlags = {
+  NONE: 0,
+  BLOCKED: 1,
+  OCCUPIED: 2,
+  VISIBLE: 4,
+  EXPLORED: 8,
+  WATER: 16,
+  HAZARD: 32
+};
+var _idx = (width, x, y) => y * width + x;
+var _inBounds = (width, height, x, y) => x >= 0 && x < width && y >= 0 && y < height;
+var _CARDINAL = new Int8Array([-1, 0, 1, 0, 0, -1, 0, 1]);
+var _ALL_ADJ = new Int8Array([-1, 0, 1, 0, 0, -1, 0, 1, -1, -1, -1, 1, 1, -1, 1, 1]);
+var createTileMap = (width, height) => ({
+  width,
+  height,
+  size: width * height,
+  flags: new Uint8Array(width * height),
+  entities: /* @__PURE__ */ new Map()
+});
+var getTileIndex = (map, x, y) => _inBounds(map.width, map.height, x, y) ? _idx(map.width, x, y) : -1;
+var getTileInfo = (map, x, y) => {
+  if (!_inBounds(map.width, map.height, x, y)) return null;
+  const index = _idx(map.width, x, y);
+  return {
+    index,
+    x,
+    y,
+    flags: map.flags[index],
+    entities: map.entities.get(index) ?? []
+  };
+};
+var indexToCoords = (map, index) => ({
+  x: index % map.width,
+  y: index / map.width | 0
+});
+var setFlag = (map, x, y, flag) => {
+  if (_inBounds(map.width, map.height, x, y)) map.flags[_idx(map.width, x, y)] |= flag;
+};
+var clearFlag = (map, x, y, flag) => {
+  if (_inBounds(map.width, map.height, x, y)) map.flags[_idx(map.width, x, y)] &= ~flag;
+};
+var toggleFlag = (map, x, y, flag) => {
+  if (_inBounds(map.width, map.height, x, y)) map.flags[_idx(map.width, x, y)] ^= flag;
+};
+var hasFlag = (map, x, y, flag) => {
+  if (!_inBounds(map.width, map.height, x, y)) return false;
+  return (map.flags[_idx(map.width, x, y)] & flag) !== 0;
+};
+var addEntity = (map, x, y, entity) => {
+  if (!_inBounds(map.width, map.height, x, y)) return false;
+  const index = _idx(map.width, x, y);
+  const bucket = map.entities.get(index);
+  if (bucket) bucket.push(entity);
+  else map.entities.set(index, [entity]);
+  return true;
+};
+var removeEntity = (map, x, y, predicate) => {
+  if (!_inBounds(map.width, map.height, x, y)) return false;
+  const index = _idx(map.width, x, y);
+  const bucket = map.entities.get(index);
+  if (!bucket) return false;
+  for (let i = 0; i < bucket.length; i++) {
+    if (predicate(bucket[i])) {
+      bucket.splice(i, 1);
+      if (bucket.length === 0) map.entities.delete(index);
+      return true;
+    }
+  }
+  return false;
+};
+var moveEntity = (map, fromX, fromY, toX, toY, predicate) => {
+  const { width, height } = map;
+  if (!_inBounds(width, height, fromX, fromY) || !_inBounds(width, height, toX, toY)) return false;
+  const srcIndex = _idx(width, fromX, fromY);
+  const src = map.entities.get(srcIndex);
+  if (!src) return false;
+  for (let i = 0; i < src.length; i++) {
+    if (predicate(src[i])) {
+      const entity = src[i];
+      src.splice(i, 1);
+      if (src.length === 0) map.entities.delete(srcIndex);
+      const dstIndex = _idx(width, toX, toY);
+      const dst = map.entities.get(dstIndex);
+      if (dst) dst.push(entity);
+      else map.entities.set(dstIndex, [entity]);
+      return true;
+    }
+  }
+  return false;
+};
+var getEntitiesAt = (map, x, y) => {
+  if (!_inBounds(map.width, map.height, x, y)) return [];
+  return map.entities.get(_idx(map.width, x, y)) ?? [];
+};
+var clearEntitiesAt = (map, x, y) => {
+  if (_inBounds(map.width, map.height, x, y)) map.entities.delete(_idx(map.width, x, y));
+};
+var getAdjacentIndices = (map, x, y, includeDiagonals = false) => {
+  const { width, height } = map;
+  const offsets = includeDiagonals ? _ALL_ADJ : _CARDINAL;
+  const result = [];
+  for (let i = 0; i < offsets.length; i += 2) {
+    const nx = x + offsets[i];
+    const ny = y + offsets[i + 1];
+    if (nx >= 0 && nx < width && ny >= 0 && ny < height) result.push(_idx(width, nx, ny));
+  }
+  return result;
+};
+var getAdjacentTiles = (map, x, y, includeDiagonals = false) => {
+  const { width, height } = map;
+  const offsets = includeDiagonals ? _ALL_ADJ : _CARDINAL;
+  const result = [];
+  for (let i = 0; i < offsets.length; i += 2) {
+    const nx = x + offsets[i];
+    const ny = y + offsets[i + 1];
+    if (nx >= 0 && nx < width && ny >= 0 && ny < height) {
+      const index = _idx(width, nx, ny);
+      result.push({ index, x: nx, y: ny, flags: map.flags[index], entities: map.entities.get(index) ?? [] });
+    }
+  }
+  return result;
+};
+var getIndicesInRange = (map, x, y, range, shape = "square", includeOrigin = false) => {
+  const { width, height } = map;
+  const r2 = range * range;
+  const result = [];
+  for (let dy = -range; dy <= range; dy++) {
+    const ny = y + dy;
+    if (ny < 0 || ny >= height) continue;
+    for (let dx = -range; dx <= range; dx++) {
+      if (!includeOrigin && dx === 0 && dy === 0) continue;
+      if (shape === "circle" && dx * dx + dy * dy > r2) continue;
+      const nx = x + dx;
+      if (nx >= 0 && nx < width) result.push(_idx(width, nx, ny));
+    }
+  }
+  return result;
+};
+var getTilesInRange = (map, x, y, range, shape = "square", includeOrigin = false) => {
+  const { width, height } = map;
+  const r2 = range * range;
+  const result = [];
+  for (let dy = -range; dy <= range; dy++) {
+    const ny = y + dy;
+    if (ny < 0 || ny >= height) continue;
+    for (let dx = -range; dx <= range; dx++) {
+      if (!includeOrigin && dx === 0 && dy === 0) continue;
+      if (shape === "circle" && dx * dx + dy * dy > r2) continue;
+      const nx = x + dx;
+      if (nx >= 0 && nx < width) {
+        const index = _idx(width, nx, ny);
+        result.push({ index, x: nx, y: ny, flags: map.flags[index], entities: map.entities.get(index) ?? [] });
+      }
+    }
+  }
+  return result;
+};
+var getEntitiesInRange = (map, x, y, range, shape = "square", includeOrigin = false) => {
+  const { width, height } = map;
+  const r2 = range * range;
+  const result = [];
+  for (let dy = -range; dy <= range; dy++) {
+    const ny = y + dy;
+    if (ny < 0 || ny >= height) continue;
+    for (let dx = -range; dx <= range; dx++) {
+      if (!includeOrigin && dx === 0 && dy === 0) continue;
+      if (shape === "circle" && dx * dx + dy * dy > r2) continue;
+      const nx = x + dx;
+      if (nx < 0 || nx >= width) continue;
+      const bucket = map.entities.get(_idx(width, nx, ny));
+      if (bucket) for (let i = 0; i < bucket.length; i++) result.push(bucket[i]);
+    }
+  }
+  return result;
+};
+var validateTile = (map, x, y, validator) => {
+  if (!_inBounds(map.width, map.height, x, y)) return false;
+  if (!validator) return true;
+  const index = _idx(map.width, x, y);
+  return validator({ index, x, y, flags: map.flags[index], entities: map.entities.get(index) ?? [] });
+};
+var validateRange = (map, x, y, range, validator, shape = "square", includeOrigin = false) => {
+  const { width, height } = map;
+  const r2 = range * range;
+  for (let dy = -range; dy <= range; dy++) {
+    const ny = y + dy;
+    if (ny < 0 || ny >= height) continue;
+    for (let dx = -range; dx <= range; dx++) {
+      if (!includeOrigin && dx === 0 && dy === 0) continue;
+      if (shape === "circle" && dx * dx + dy * dy > r2) continue;
+      const nx = x + dx;
+      if (nx < 0 || nx >= width) continue;
+      const index = _idx(width, nx, ny);
+      if (!validator({ index, x: nx, y: ny, flags: map.flags[index], entities: map.entities.get(index) ?? [] })) return false;
+    }
+  }
+  return true;
+};
+var createSpatialConfig = (tileWidth, tileHeight, originX = 0, originY = 0) => ({ tileWidth, tileHeight, originX, originY });
+var worldToTile = (spatial, wx, wy) => ({
+  x: (wx - spatial.originX) / spatial.tileWidth | 0,
+  y: (wy - spatial.originY) / spatial.tileHeight | 0
+});
+var tileToWorld = (spatial, tx, ty) => ({
+  x: tx * spatial.tileWidth + spatial.originX,
+  y: ty * spatial.tileHeight + spatial.originY
+});
+var tileCenterWorld = (spatial, tx, ty) => ({
+  x: tx * spatial.tileWidth + spatial.originX + (spatial.tileWidth >> 1),
+  y: ty * spatial.tileHeight + spatial.originY + (spatial.tileHeight >> 1)
+});
+var screenToWorld = (cameraX, cameraY, sx, sy) => ({
+  x: sx + cameraX,
+  y: sy + cameraY
+});
+var worldToScreen = (cameraX, cameraY, wx, wy) => ({
+  x: wx - cameraX,
+  y: wy - cameraY
+});
+var screenToTile = (spatial, cameraX, cameraY, sx, sy) => ({
+  x: (sx + cameraX - spatial.originX) / spatial.tileWidth | 0,
+  y: (sy + cameraY - spatial.originY) / spatial.tileHeight | 0
+});
+var tileToScreen = (spatial, cameraX, cameraY, tx, ty) => ({
+  x: tx * spatial.tileWidth + spatial.originX - cameraX,
+  y: ty * spatial.tileHeight + spatial.originY - cameraY
+});
+var worldToTileExact = (spatial, wx, wy) => {
+  const fx = (wx - spatial.originX) / spatial.tileWidth;
+  const fy = (wy - spatial.originY) / spatial.tileHeight;
+  const tileX = fx | 0;
+  const tileY = fy | 0;
+  return { tileX, tileY, fracX: fx - tileX, fracY: fy - tileY };
+};
+var getTileAtWorld = (map, spatial, wx, wy) => {
+  const tx = (wx - spatial.originX) / spatial.tileWidth | 0;
+  const ty = (wy - spatial.originY) / spatial.tileHeight | 0;
+  return getTileInfo(map, tx, ty);
+};
+var getTileAtScreen = (map, spatial, cameraX, cameraY, sx, sy) => {
+  const tx = (sx + cameraX - spatial.originX) / spatial.tileWidth | 0;
+  const ty = (sy + cameraY - spatial.originY) / spatial.tileHeight | 0;
+  return getTileInfo(map, tx, ty);
+};
+var tile_map_default = {
+  TileFlags,
+  createTileMap,
+  getTileIndex,
+  getTileInfo,
+  indexToCoords,
+  setFlag,
+  clearFlag,
+  toggleFlag,
+  hasFlag,
+  addEntity,
+  removeEntity,
+  moveEntity,
+  getEntitiesAt,
+  clearEntitiesAt,
+  getAdjacentIndices,
+  getAdjacentTiles,
+  getIndicesInRange,
+  getTilesInRange,
+  getEntitiesInRange,
+  validateTile,
+  validateRange,
+  createSpatialConfig,
+  worldToTile,
+  tileToWorld,
+  tileCenterWorld,
+  screenToWorld,
+  worldToScreen,
+  screenToTile,
+  tileToScreen,
+  worldToTileExact,
+  getTileAtWorld,
+  getTileAtScreen
+};
+
+// index.ts
+var index_default = {
+  s3: s3_exports,
+  JSONL: jsonl_default,
+  tileMap: tile_map_default,
+  utils: {
+    ...misc_js_funcs_exports
+  }
+};
+export {
+  jsonl_default as JSONL,
+  TileFlags,
+  addEntity,
+  chunkArray,
+  clearEntitiesAt,
+  clearFlag,
+  createSpatialConfig,
+  createTileMap,
+  index_default as default,
+  deleteObject,
+  generateRandomString,
+  getAdjacentIndices,
+  getAdjacentTiles,
+  getClient,
+  getEntitiesAt,
+  getEntitiesInRange,
+  getIndicesInRange,
+  getObject,
+  getTileAtScreen,
+  getTileAtWorld,
+  getTileIndex,
+  getTileInfo,
+  getTilesInRange,
+  hasFlag,
+  indexToCoords,
+  listObjects,
+  moveEntity,
+  putObject,
+  removeEntity,
+  s3_exports as s3,
+  screenToTile,
+  screenToWorld,
+  setFlag,
+  settledSeparator,
+  sleep,
+  tileCenterWorld,
+  tile_map_default as tileMap,
+  tileToScreen,
+  tileToWorld,
+  timeFormat,
+  timeSinceString,
+  toggleFlag,
+  validateRange,
+  validateTile,
+  worldToScreen,
+  worldToTile,
+  worldToTileExact
+};
+//# sourceMappingURL=index.mjs.map