king-crimson v1.0.1

king-crimson

A library that provides classes for managing sequential data.

Installation

npm install king-crimson

Usage

The following two management classes are provided.

• DateTimeDataManager: Manage data with datetime information.
• IntervalDataManager: Manages data with interval information.

DateTimeDataManager

import { DateTimeDataManager } from "king-crimson";
import { DateTime, Duration, Interval } from "luxon";
import queryString from "query-string";

// Event data to manage
interface MyEventData {
  timestamp: number;
  event: string;
}

// Create an async function to call API
const fetchData = async (since: number, until: number, signal: AbortSignal) => {
  const query = queryString.stringify({ since, until });
  const url = `https://example.com/api/data?${query}`;
  const res = await fetch(uri, { signal });
  const data = await res.json();
  return data;
};

// Create instance
const ddm = new DateTimeDataManager<MyEventData>({
  fetchFn(period: Interval) {
    const controller = new AbortController();
    const signal = controller.signal;
    const since = period.start.toMillis();
    const until = period.end.toMillis();
    return {
      promise: fetchData(since, until, signal),
      cancel() {
        controller.abort();
      }
    };
  },
  itemKey(item: MyEventData) {
    return item.timestamp;
  }
});

// Execute fetch
const datetime = DateTime.local();
ddm.fetch(datetime);

// Cancel fetch
ddm.cansel();

// Search data
const interval = datetime.before(Duration.fromObject({ hour: 1 }));
const data = ddm.searchBetween(interval);

Config

Options

IntervalDataManager

import { IntervalDataManager } from "king-crimson";
import { DateTime, Duration, Interval } from "luxon";
import queryString from "query-string";

// Event data to manage
interface MyEventData {
  timestamp: number;
  duration: number;
  event: string;
}

// Create an async function to call API
const fetchData = async (since: number, until: number, signal: AbortSignal) => {
  const query = queryString.stringify({ since, until });
  const url = `https://example.com/api/data?${query}`;
  const res = await fetch(uri, { signal });
  const data = await res.json();
  return data;
};

// Create instance
const idm = new IntervalDataManager<MyEventData>({
  fetchFn(period: Interval) {
    const controller = new AbortController();
    const signal = controller.signal;
    const since = period.start.toMillis();
    const until = period.end.toMillis();
    return {
      promise: fetchData(since, until, signal),
      cancel() {
        controller.abort();
      }
    };
  },
  itemKey(item: MyEventData) {
    return item.timestamp;
  },
  itemTimestamp(item: MyEventData) {
    return item.timestamp;
  },
  itemDuration(item: MyEventData) {
    return item.duration;
  }
});

// Execute fetch
const datetime = DateTime.local();
idm.fetch(datetime);

// Cancel fetch
idm.cansel();

// Search data
const interval = datetime.before(Duration.fromObject({ hour: 1 }));
let data = idm.searchBetween(interval);

// Search for data that includes a specified datetime
data = searchOn(datetime);

Config

Options

Event

Both classes emit the following events: