prefix
stringlengths 82
32.6k
| middle
stringlengths 5
470
| suffix
stringlengths 0
81.2k
| file_path
stringlengths 6
168
| repo_name
stringlengths 16
77
| context
listlengths 5
5
| lang
stringclasses 4
values | ground_truth
stringlengths 5
470
|
|---|---|---|---|---|---|---|---|
import { Timer } from "./performance";
import { CancelablePromise, IsTransferrable, Timing } from "./types";
import { withTimeout } from "./utils";
let id = 0;
interface Cancel {
type: "cancel";
id: number;
}
interface Response {
type: "response";
id: number;
error?: string;
response?: any;
timings: Timing;
}
interface Request {
type: "request";
id?: number;
name: string;
args: any[];
}
type Message = Cancel | Response | Request;
type MethodsReturning<T, R> = {
[K in keyof T]: T[K] extends (...args: any) => R ? T[K] : never;
};
/**
* Utility for sending messages to a remote instance of `<T>` running in a web worker
* from the main thread, or in the main thread running from a web worker.
*/
export default class Actor<T> {
callbacks: {
[id: number]: (
error: Error | undefined,
message: any,
timings: Timing,
) => void;
};
cancels: { [id: number]: () => void };
dest: Worker;
timeoutMs: number;
constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {
this.callbacks = {};
this.cancels = {};
this.dest = dest;
this.timeoutMs = timeoutMs;
this.dest.onmessage = async ({ data }) => {
const message: Message = data;
if (message.type === "cancel") {
const cancel = this.cancels[message.id];
delete this.cancels[message.id];
if (cancel) {
cancel();
}
} else if (message.type === "response") {
const callback = this.callbacks[message.id];
delete this.callbacks[message.id];
if (callback) {
callback(
message.error ? new Error(message.error) : undefined,
message.response,
message.timings,
);
}
} else if (message.type === "request") {
const timer = new | Timer("worker"); |
const handler: Function = (dispatcher as any)[message.name];
const request = handler.apply(handler, [...message.args, timer]);
const url = `${message.name}_${message.id}`;
if (message.id && request) {
this.cancels[message.id] = request.cancel;
try {
const response = await request.value;
const transferrables = (response as IsTransferrable)
?.transferrables;
this.postMessage(
{
id: message.id,
type: "response",
response,
timings: timer.finish(url),
},
transferrables,
);
} catch (e: any) {
this.postMessage({
id: message.id,
type: "response",
error: e?.toString() || "error",
timings: timer.finish(url),
});
}
delete this.cancels[message.id];
}
}
};
}
postMessage(message: Message, transferrables?: Transferable[]) {
this.dest.postMessage(message, transferrables || []);
}
/** Invokes a method by name with a set of arguments in the remote context. */
send<
R,
M extends MethodsReturning<T, CancelablePromise<R>>,
K extends keyof M & string,
P extends Parameters<M[K]>,
>(
name: K,
transferrables: Transferable[],
timer?: Timer,
...args: P
): CancelablePromise<R> {
const thisId = ++id;
const value: Promise<R> = new Promise((resolve, reject) => {
this.postMessage(
{ id: thisId, type: "request", name, args },
transferrables,
);
this.callbacks[thisId] = (error, result, timings) => {
timer?.addAll(timings);
if (error) reject(error);
else resolve(result);
};
});
return withTimeout(this.timeoutMs, {
value,
cancel: () => {
delete this.callbacks[thisId];
this.postMessage({ id: thisId, type: "cancel" });
},
});
}
}
| src/actor.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " managers: { [id: number]: LocalDemManager } = {};\n init = (message: InitMessage): CancelablePromise<void> => {\n this.managers[message.managerId] = new LocalDemManager(\n message.demUrlPattern,\n message.cacheSize,\n message.encoding,\n message.maxzoom,\n message.timeoutMs,\n );\n return { cancel() {}, value: Promise.resolve() };",
"score": 56.743955545487474
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " try {\n const data = await result.value;\n timing = timer.finish(request.url);\n if (canceled) return;\n response(undefined, data.arrayBuffer);\n } catch (error) {\n if (canceled) return;\n timing = timer.error(request.url);\n response(error as Error);\n }",
"score": 31.727711126405993
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " timing = timer.finish(request.url);\n if (canceled) return;\n const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();\n if (canceled) return;\n response(undefined, arrayBuffer, data.cacheControl, data.expires);\n } catch (error) {\n timing = timer.error(request.url);\n if (canceled) return;\n response(error as Error);\n }",
"score": 30.33079882457979
},
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " const result = cache.getCancelable(1, () => ({\n value: new Promise((_, rej) => {\n reject = rej;\n }),\n cancel: () => {\n throw new Error();\n },\n }));\n const error = new Error();\n reject(error);",
"score": 17.708680719986088
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " data?: any | undefined,\n cacheControl?: string | undefined,\n expires?: string | undefined,\n) => void;\ntype Protocol = (\n request: RequestParameters,\n response: ResponseCallback,\n) => Cancelable;\nconst used = new Set<string>();\n/**",
"score": 17.24785116031093
}
] | typescript | Timer("worker"); |
import AsyncCache from "./cache";
import decodeImage from "./decode-image";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
import { encodeIndividualOptions, withTimeout } from "./utils";
import {
CancelablePromise,
ContourTile,
DemTile,
Encoding,
FetchResponse,
IndividualContourTileOptions,
} from "./types";
import encodeVectorTile, { GeomType } from "./vtpbf";
import { Timer } from "./performance";
/**
* Holds cached tile state, and exposes `fetchContourTile` which fetches the necessary
* tiles and returns an encoded contour vector tiles.
*/
export interface DemManager {
loaded: Promise<any>;
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse>;
fetchAndParseTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile>;
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile>;
}
/**
* Caches, decodes, and processes raster tiles in the current thread.
*/
export class LocalDemManager implements DemManager {
tileCache: AsyncCache<string, FetchResponse>;
parsedCache: AsyncCache<string, DemTile>;
contourCache: AsyncCache<string, ContourTile>;
demUrlPattern: string;
encoding: Encoding;
maxzoom: number;
timeoutMs: number;
loaded = Promise.resolve();
decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =
decodeImage;
constructor(
demUrlPattern: string,
cacheSize: number,
encoding: Encoding,
maxzoom: number,
timeoutMs: number,
) {
this.tileCache = new AsyncCache(cacheSize);
this.parsedCache = new AsyncCache(cacheSize);
this.contourCache = new AsyncCache(cacheSize);
this.timeoutMs = timeoutMs;
this.demUrlPattern = demUrlPattern;
this.encoding = encoding;
this.maxzoom = maxzoom;
}
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> {
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.tileCache.getCancelable(url, () => {
let cancel = () => {};
const options: RequestInit = {};
try {
const controller = new AbortController();
options.signal = controller.signal;
cancel = () => controller.abort();
} catch (e) {
// ignore
}
timer?.fetchTile(url);
const mark = timer?.marker("fetch");
return withTimeout(this.timeoutMs, {
value: fetch(url, options).then(async (response) => {
mark?.();
if (!response.ok) {
throw new Error(`Bad response: ${response.status} for ${url}`);
}
return {
data: await response.blob(),
expires: response.headers.get("expires") || undefined,
cacheControl: response.headers.get("cache-control") || undefined,
};
}),
cancel,
});
});
}
fetchAndParseTile = (
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile> => {
const self = this;
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.parsedCache.getCancelable(url, () => {
const tile = self.fetchTile(z, x, y, timer);
let canceled = false;
let alsoCancel = () => {};
return {
value: tile.value.then(async (response) => {
if (canceled) throw new Error("canceled");
const result = self.decodeImage(response.data, self.encoding);
alsoCancel = result.cancel;
const mark = timer?.marker("decode");
const value = await result.value;
mark?.();
return value;
}),
cancel: () => {
canceled = true;
alsoCancel();
tile.cancel();
},
};
});
};
fetchDem(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<HeightTile> {
const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
const subZ = z - zoom;
const div = 1 << subZ;
const newX = Math.floor(x / div);
const newY = Math.floor(y / div);
const { value, cancel } = this.fetchAndParseTile(zoom, newX, newY, timer);
const subX = x % div;
const subY = y % div;
return {
value: value.then((tile) =>
HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
};
}
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> {
const {
levels,
multiplier = 1,
buffer = 1,
extent = 4096,
contourLayer = "contours",
elevationKey = "ele",
levelKey = "level",
subsampleBelow = 100,
} = options;
// no levels means less than min zoom with levels specified
if (!levels || levels.length === 0) {
return {
cancel() {},
value: Promise.resolve({ arrayBuffer: new ArrayBuffer(0) }),
};
}
const key = [z, x, y, encodeIndividualOptions(options)].join("/");
return this.contourCache.getCancelable(key, () => {
const max = 1 << z;
let canceled = false;
const neighborPromises: (CancelablePromise<HeightTile> | null)[] = [];
for (let iy = y - 1; iy <= y + 1; iy++) {
for (let ix = x - 1; ix <= x + 1; ix++) {
neighborPromises.push(
iy < 0 || iy >= max
? null
: this.fetchDem(z, (ix + max) % max, iy, options, timer),
);
}
}
const value = Promise.all(neighborPromises.map((n) => n?.value)).then(
async (neighbors) => {
let virtualTile = HeightTile.combineNeighbors(neighbors);
if (!virtualTile || canceled) {
return { arrayBuffer: new Uint8Array().buffer };
}
const mark = timer?.marker("isoline");
if (virtualTile.width >= subsampleBelow) {
virtualTile = virtualTile.materialize(2);
} else {
while (virtualTile.width < subsampleBelow) {
virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
}
}
virtualTile = virtualTile
.averagePixelCentersToGrid()
.scaleElevation(multiplier)
.materialize(1);
const isolines = generateIsolines(
levels[0],
virtualTile,
extent,
buffer,
);
mark?.();
| const result = encodeVectorTile({ |
extent,
layers: {
[contourLayer]: {
features: Object.entries(isolines).map(([eleString, geom]) => {
const ele = Number(eleString);
return {
type: GeomType.LINESTRING,
geometry: geom,
properties: {
[elevationKey]: ele,
[levelKey]: Math.max(
...levels.map((l, i) => (ele % l === 0 ? i : 0)),
),
},
};
}),
},
},
});
mark?.();
return { arrayBuffer: result.buffer };
},
);
return {
value,
cancel() {
canceled = true;
neighborPromises.forEach((n) => n && n.cancel());
},
};
});
}
}
| src/dem-manager.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/isolines.ts",
"retrieved_chunk": "export default function generateIsolines(\n interval: number,\n tile: HeightTile,\n extent: number = 4096,\n buffer: number = 1,\n): { [ele: number]: number[][] } {\n if (!interval) {\n return {};\n }\n const multiplier = extent / (tile.width - 1);",
"score": 17.15300353885347
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " count++;\n sum += v;\n }\n }\n }\n return count === 0 ? NaN : sum / count;\n });\n /** Returns a new tile with elevation values scaled by `multiplier`. */\n scaleElevation = (multiplier: number): HeightTile =>\n multiplier === 1",
"score": 12.923693352379738
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " levels: [1, 2],\n contourLayer: \"contour layer\",\n elevationKey: \"elevation key\",\n extent: 123,\n levelKey: \"level key\",\n multiplier: 123,\n overzoom: 3,\n };\n const origEncoded = encodeIndividualOptions(options);\n expect(encodeIndividualOptions(options)).toBe(origEncoded);",
"score": 11.544321604928673
},
{
"filename": "src/isolines.test.ts",
"retrieved_chunk": " return heightTile.get(nx, ny);\n },\n );\n const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);\n const rotatedResult: { [ele: number]: number[][] } = {};\n for (const ele in isolines) {\n rotatedResult[ele] = isolines[ele].map((eles) => {\n const rotatedLine: number[] = [...eles];\n for (let i = 0; i < rotatedLine.length; i += 2) {\n const [x, y] = rotate(",
"score": 11.395262060836805
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " */\n materialize = (buffer: number = 2): HeightTile => {\n const stride = this.width + 2 * buffer;\n const data = new Float32Array(stride * (this.height + 2 * buffer));\n let idx = 0;\n for (let y = -buffer; y < this.height + buffer; y++) {\n for (let x = -buffer; x < this.width + buffer; x++) {\n data[idx++] = this.get(x, y);\n }\n }",
"score": 11.083072027774822
}
] | typescript | const result = encodeVectorTile({ |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
| actor?: Actor<WorkerDispatch>; |
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " * Caches, decodes, and processes raster tiles in a shared web worker.\n */\nexport default class RemoteDemManager implements DemManager {\n managerId: number;\n actor: Actor<WorkerDispatch>;\n loaded: Promise<any>;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,",
"score": 46.00513678441319
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": "import { prepareContourTile, prepareDemTile } from \"./utils\";\nconst noManager = (managerId: number): CancelablePromise<any> => ({\n cancel() {},\n value: Promise.reject(new Error(`No manager registered for ${managerId}`)),\n});\n/**\n * Receives messages from an actor in the web worker.\n */\nexport default class WorkerDispatch {\n /** There is one worker shared between all managers in the main thread using the plugin, so need to store each of their configurations. */",
"score": 38.47729057119468
},
{
"filename": "src/actor.ts",
"retrieved_chunk": "}\ntype Message = Cancel | Response | Request;\ntype MethodsReturning<T, R> = {\n [K in keyof T]: T[K] extends (...args: any) => R ? T[K] : never;\n};\n/**\n * Utility for sending messages to a remote instance of `<T>` running in a web worker\n * from the main thread, or in the main thread running from a web worker.\n */\nexport default class Actor<T> {",
"score": 38.05773543288942
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " maxzoom: number,\n timeoutMs: number,\n actor?: Actor<WorkerDispatch>,\n ) {\n const managerId = (this.managerId = ++id);\n this.actor = actor || defaultActor();\n this.loaded = this.actor.send(\"init\", [], undefined, {\n cacheSize,\n demUrlPattern,\n encoding,",
"score": 34.015413125362045
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": "const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);\nconst workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);\nconst source = new DemSource({\n url: \"https://example/{z}/{x}/{y}.png\",\n cacheSize: 100,\n encoding: \"terrarium\",\n maxzoom: 11,\n worker: true,\n actor: mainActor,\n});",
"score": 32.31967181216025
}
] | typescript | actor?: Actor<WorkerDispatch>; |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
| timingCallbacks: Array<(timing: Timing) => void> = []; |
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": "}\n/**\n * Caches, decodes, and processes raster tiles in the current thread.\n */\nexport class LocalDemManager implements DemManager {\n tileCache: AsyncCache<string, FetchResponse>;\n parsedCache: AsyncCache<string, DemTile>;\n contourCache: AsyncCache<string, ContourTile>;\n demUrlPattern: string;\n encoding: Encoding;",
"score": 27.04897915718612
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " for (const list of input) {\n result.push(...list);\n }\n return result;\n}\n/** Utility for tracking how long tiles take to generate, and where the time is going. */\nexport class Timer {\n marks: { [key in TimingCategory]?: number[][] } = {};\n urls: string[] = [];\n fetched: string[] = [];",
"score": 22.708984239260108
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " * Caches, decodes, and processes raster tiles in a shared web worker.\n */\nexport default class RemoteDemManager implements DemManager {\n managerId: number;\n actor: Actor<WorkerDispatch>;\n loaded: Promise<any>;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,",
"score": 20.185767723178415
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(tile.width).toBe(4);\n expect(tile.height).toBe(4);\n const tile2 = await source.getDemTile(1, 2, 3);\n expect(tile2.data).toEqual(expectedElevations);\n const timings: Timing[] = [];\n source.onTiming((timing) => timings.push(timing));\n const fetched = await new Promise((resolve, reject) => {\n source.sharedDemProtocol(\n {\n url: source.sharedDemProtocolUrl",
"score": 18.626070663848047
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " id: number;\n error?: string;\n response?: any;\n timings: Timing;\n}\ninterface Request {\n type: \"request\";\n id?: number;\n name: string;\n args: any[];",
"score": 17.051659054718975
}
] | typescript | timingCallbacks: Array<(timing: Timing) => void> = []; |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
| manager: DemManager; |
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": "}\n/**\n * Caches, decodes, and processes raster tiles in the current thread.\n */\nexport class LocalDemManager implements DemManager {\n tileCache: AsyncCache<string, FetchResponse>;\n parsedCache: AsyncCache<string, DemTile>;\n contourCache: AsyncCache<string, ContourTile>;\n demUrlPattern: string;\n encoding: Encoding;",
"score": 27.048979157186118
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " for (const list of input) {\n result.push(...list);\n }\n return result;\n}\n/** Utility for tracking how long tiles take to generate, and where the time is going. */\nexport class Timer {\n marks: { [key in TimingCategory]?: number[][] } = {};\n urls: string[] = [];\n fetched: string[] = [];",
"score": 22.898781184981328
},
{
"filename": "src/types.ts",
"retrieved_chunk": " IsTransferrable {}\nexport interface Cancelable {\n cancel: () => void;\n}\nexport interface CancelablePromise<T> extends Cancelable {\n value: Promise<T>;\n}\nexport interface FetchResponse {\n data: Blob;\n expires?: string;",
"score": 21.033698435652614
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " * Caches, decodes, and processes raster tiles in a shared web worker.\n */\nexport default class RemoteDemManager implements DemManager {\n managerId: number;\n actor: Actor<WorkerDispatch>;\n loaded: Promise<any>;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,",
"score": 20.185767723178415
},
{
"filename": "src/types.ts",
"retrieved_chunk": " levelKey?: string;\n /** Name of the vector tile layer to put contour lines in */\n contourLayer?: string;\n /** Grid size of the vector tile (default 4096) */\n extent?: number;\n /** How many pixels to generate on each tile into the neighboring tile to reduce rendering artifacts */\n buffer?: number;\n /** When overzooming tiles, subsample to scale up to at least this size to make the contour lines smoother at higher zooms. */\n subsampleBelow?: number;\n}",
"score": 17.009075356573135
}
] | typescript | manager: DemManager; |
import { User } from '@prisma/client';
import DBClient from '../../prisma/prisma.client';
import { deleteFile } from '../facades/helper';
import { profilePictureRelativePath } from '../utils/constants';
const prisma = DBClient.getInstance().prisma;
export const getUserById = async (id: string) => {
const user = await prisma.user.findUnique({
where: { id: id },
select: {
id: true,
email: true,
username: true,
name: true,
isActive: false,
profilePicture: true,
forums: true,
refreshToken: false,
},
});
return user;
};
export const getUserByEmail = async (email: string) => {
const user = await prisma.user.findUnique({
where: { email: email },
select: {
id: true,
email: true,
username: true,
name: true,
password: true,
role: true,
isActive: true,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const getUserByUsername = async (username: string) => {
const user = await prisma.user.findUnique({
where: { username: username },
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const getUserByRefreshToken = async (refreshToken: string) => {
const user = await prisma.user.findFirst({
where: { refreshToken: refreshToken },
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const isEmailExists = async (email: string): Promise<boolean> => {
const user = await prisma.user.findUnique({
where: {
email: email,
},
});
return !!user;
};
export const isUsernameExists = async (username: string): Promise<boolean> => {
const user = await prisma.user.findUnique({
where: {
username: username,
},
});
return !!user;
};
export const createUser = async (user: User) => {
const result = await prisma.user.create({
data: { ...user },
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return result;
};
export const createActiveUser = async (user: User) => {
const result = await prisma.user.create({
data: { ...user },
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: true,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return result;
};
export const activateUser = async (id: string) => {
const user = await prisma.user.update({
where: { id: id },
data: {
isActive: true,
},
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const updateRefreshToken = async (id: string, refreshToken: string) => {
const user = await prisma.user.update({
where: { id: id },
data: {
refreshToken: refreshToken,
},
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const clearRefreshToken = async (id: string) => {
const user = await prisma.user.update({
where: { id: id },
data: {
refreshToken: '',
},
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const updateProfile = async (
id: string,
username: string,
name: string
) => {
const user = await prisma.user.update({
where: { id: id },
data: {
username: username,
name: name,
},
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const updateProfilePicture = async (
id: string,
profilePicture: string
) => {
const prevUser = await getUserById(id);
if (prevUser) {
if (prevUser.profilePicture !== '') {
deleteFile | (profilePictureRelativePath + prevUser.profilePicture); |
}
}
const user = await prisma.user.update({
where: { id: id },
data: {
profilePicture: profilePicture,
},
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const updateRoleDoctor = async (id: string) => {
const user = await prisma.user.update({
where: { id: id },
data: {
role: 'Doctor',
},
select: {
id: true,
email: true,
username: true,
name: true,
password: false,
role: true,
isActive: false,
profilePicture: true,
forums: true,
activationLink: false,
refreshToken: false,
},
});
return user;
};
export const getAllRoles = async () => {
const members = await prisma.user.findMany({
where: {
role: 'Member',
},
});
const doctors = await prisma.user.findMany({
where: {
role: 'Doctor',
},
});
const admins = await prisma.user.findMany({
where: {
role: 'Admin',
},
});
return { members, doctors, admins };
};
| src/databases/user.database.ts | TinTinWinata-io-fest-backend-9d0d374 | [
{
"filename": "src/utils/constants.ts",
"retrieved_chunk": "import { Secret } from \"jsonwebtoken\";\nexport const accessTokenSecret: Secret =\n process.env.ACCESS_TOKEN_SECRET || \"mbVBFoeO40bcE3AilczmnM7IcQY0xWQwsC7Hbuqu\";\nexport const refreshTokenSecret: Secret =\n process.env.REFRESH_TOKEN_SECRET ||\n \"CkwmqZBk2e8HPkwsxi0lbZrvqej7BYpmNmTvJZTL\";\nexport const profilePictureRelativePath: string =\n \"./src/public/profilePicture/\";\nexport const forumRelativePath: string = \"./src/public/forum/\";\nexport const maxForumAttachmentCount: number = 8;",
"score": 17.504407720039726
},
{
"filename": "src/controllers/user.controller.ts",
"retrieved_chunk": " }\n const { profilePicture } = req.body;\n const userId = req.jwtPayload && req.jwtPayload.id;\n const user = await uProfilePicture(userId, profilePicture);\n if (user) {\n return res.status(200).json(user);\n }\n return res.status(400).json({ errors: ['user not found!'] });\n } catch (error) {\n console.log(error);",
"score": 16.5054778545047
},
{
"filename": "src/facades/helper.ts",
"retrieved_chunk": "export const deleteFile = (filePath: string) => {\n fs.unlink(filePath, (err) => {\n if (err) {\n console.error(err);\n return;\n }\n });\n};\nexport const getPaginationOptions = (\n page: number,",
"score": 15.997877062721452
},
{
"filename": "src/databases/forum.database.ts",
"retrieved_chunk": " },\n },\n });\n return result;\n};\nexport const updateForum = async (\n id: string,\n title: string,\n description: string\n) => {",
"score": 15.093997480671781
},
{
"filename": "src/databases/activation.link.database.ts",
"retrieved_chunk": "import DBClient from \"../../prisma/prisma.client\";\nimport { ActivationLink } from \"@prisma/client\";\nconst prisma = DBClient.getInstance().prisma;\nexport const getActivationLinkById = async (id: string) => {\n const activationLink = await prisma.activationLink.findUnique({\n where: { id: id },\n });\n return activationLink;\n};\nexport const deleteActivationLinkById = async (id: string) => {",
"score": 14.924481830838992
}
] | typescript | (profilePictureRelativePath + prevUser.profilePicture); |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor | ?: Actor<WorkerDispatch>; |
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " * Caches, decodes, and processes raster tiles in a shared web worker.\n */\nexport default class RemoteDemManager implements DemManager {\n managerId: number;\n actor: Actor<WorkerDispatch>;\n loaded: Promise<any>;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,",
"score": 40.97932299039809
},
{
"filename": "src/actor.ts",
"retrieved_chunk": "}\ntype Message = Cancel | Response | Request;\ntype MethodsReturning<T, R> = {\n [K in keyof T]: T[K] extends (...args: any) => R ? T[K] : never;\n};\n/**\n * Utility for sending messages to a remote instance of `<T>` running in a web worker\n * from the main thread, or in the main thread running from a web worker.\n */\nexport default class Actor<T> {",
"score": 38.05773543288942
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": "import { prepareContourTile, prepareDemTile } from \"./utils\";\nconst noManager = (managerId: number): CancelablePromise<any> => ({\n cancel() {},\n value: Promise.reject(new Error(`No manager registered for ${managerId}`)),\n});\n/**\n * Receives messages from an actor in the web worker.\n */\nexport default class WorkerDispatch {\n /** There is one worker shared between all managers in the main thread using the plugin, so need to store each of their configurations. */",
"score": 37.73917910854996
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": "const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);\nconst workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);\nconst source = new DemSource({\n url: \"https://example/{z}/{x}/{y}.png\",\n cacheSize: 100,\n encoding: \"terrarium\",\n maxzoom: 11,\n worker: true,\n actor: mainActor,\n});",
"score": 28.89626050827482
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " maxzoom: number,\n timeoutMs: number,\n actor?: Actor<WorkerDispatch>,\n ) {\n const managerId = (this.managerId = ++id);\n this.actor = actor || defaultActor();\n this.loaded = this.actor.send(\"init\", [], undefined, {\n cacheSize,\n demUrlPattern,\n encoding,",
"score": 28.557234103841218
}
] | typescript | ?: Actor<WorkerDispatch>; |
import { ForumAttachmentType } from '@prisma/client';
import { Request, Response } from 'express';
import { v4 as uuidv4 } from 'uuid';
import {
createForumAttachment,
getAllForumAttachments,
} from '../databases/forum.attachment.database';
import {
createForum as cForum,
deleteForum as dForum,
getAllForum,
getCountForum,
getForumById,
getNewestForumsPagination,
getTopForumsPagination,
incrementForumSeen,
updateForum as uForum,
} from '../databases/forum.database';
import { getPaginationOptions } from '../facades/helper';
import { PaginationOptions } from '../interfaces/interface';
import { forumPerPage } from '../utils/constants';
export const getForum = async (req: Request, res: Response) => {
try {
const { forumId } = req.params;
const forum = await getForumById(forumId);
if (!forum) {
res.status(404).json({ errors: ['forum not found!'] });
}
res.status(200).json({ forum: forum });
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
export const newestForumPagination = async (req: Request, res: Response) => {
try {
const { page } = req.query;
let { search } = req.query;
if (search === undefined || search === null) {
search = '';
}
search = search?.toString();
let p: number = 1;
if (typeof page == 'string' && !isNaN(parseInt(page))) {
p = parseInt(page);
}
| const paginationOptions: PaginationOptions = getPaginationOptions(
p,
forumPerPage
); |
const forums = await getNewestForumsPagination(
paginationOptions.skip,
paginationOptions.take,
search
);
const totalForums = await getCountForum();
res.status(200).json({
forums: forums,
totalForums: totalForums,
perPage: forumPerPage,
});
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
export const getAll = async (req: Request, res: Response) => {
try {
const forums = await getAllForum();
res.status(200).json({
forums: forums,
});
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
export const topForumPagination = async (req: Request, res: Response) => {
try {
const { page } = req.query;
let { search } = req.query;
if (search === undefined || search === null) {
search = '';
}
search = search?.toString();
let p: number = 1;
if (typeof page == 'string' && !isNaN(parseInt(page))) {
p = parseInt(page);
}
const paginationOptions: PaginationOptions = getPaginationOptions(
p,
forumPerPage
);
const forums = await getTopForumsPagination(
paginationOptions.skip,
paginationOptions.take,
search
);
const totalForums = await getCountForum();
res.status(200).json({
forums: forums,
totalForums: totalForums,
perPage: forumPerPage,
});
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
export const createForum = async (req: Request, res: Response) => {
try {
if (req.fileValidationError) {
return res.status(400).json({ errors: [req.fileValidationError] });
}
const { title, description } = req.body;
const userId = req.jwtPayload && req.jwtPayload.id;
const forum = await cForum({
id: uuidv4(),
title: title,
description: description,
userId: userId,
seen: 0,
createdAt: new Date(Date.now()),
updatedAt: new Date(Date.now()),
});
if (!forum) {
return res.status(400).json({ errors: ['forum cannot be made!'] });
}
if (req.files && !(req.files instanceof Array)) {
// Validate file must be array
return res.status(400).json({ errors: ['file must be array'] });
}
const files = req.files;
if (files) {
// Validate if there's file in the form than create the attachment
const length = files.length;
for (let index = 0; index < length; index++) {
const file = files.at(index);
var type: ForumAttachmentType = 'Video';
if (!file) {
return res.status(400).json({ errors: ['error occurred'] });
}
if (
file.mimetype === 'image/png' ||
file.mimetype === 'image/jpg' ||
file.mimetype === 'image/jpeg'
) {
type = 'Image';
}
await createForumAttachment({
path: file.originalname,
forumId: forum.id,
type: type,
});
}
}
const forumAttachments = await getAllForumAttachments(forum.id);
return res
.status(200)
.json({ forum: forum, forumAttachments: forumAttachments });
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
export const forumSeen = async (req: Request, res: Response) => {
try {
const { forumId } = req.body;
const forum = await incrementForumSeen(forumId);
if (!forum) {
return res.status(400).json({ errors: ['forum not found'] });
}
return res.status(200).json({ forum: forum });
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
export const updateForum = async (req: Request, res: Response) => {
try {
const { forumId, title, description } = req.body;
const forum = await uForum(forumId, title, description);
if (!forum) {
return res.status(400).json({ errors: ['forum not found'] });
}
return res.status(200).json({ forum: forum });
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
export const deleteForum = async (req: Request, res: Response) => {
try {
const { forumId } = req.body;
const forum = await dForum(forumId);
if (!forum) {
return res.status(400).json({ errors: ['forum not found'] });
}
return res.status(200).json({ successes: ['forum successfully deleted!'] });
} catch (error) {
console.log(error);
res.status(400).json({ errors: ['error occurred'] });
}
};
| src/controllers/forum.controller.ts | TinTinWinata-io-fest-backend-9d0d374 | [
{
"filename": "src/facades/helper.ts",
"retrieved_chunk": " perPage: number\n): PaginationOptions => {\n const skip = (page - 1) * perPage;\n const take = perPage;\n const paginationOpt: PaginationOptions = {\n page: page,\n perPage: perPage,\n skip: skip,\n take: take,\n };",
"score": 34.60052500106968
},
{
"filename": "src/interfaces/interface.ts",
"retrieved_chunk": "export interface PaginationOptions {\n page: number;\n perPage: number;\n skip: number;\n take: number;\n}",
"score": 26.995973955387576
},
{
"filename": "src/facades/helper.ts",
"retrieved_chunk": "export const deleteFile = (filePath: string) => {\n fs.unlink(filePath, (err) => {\n if (err) {\n console.error(err);\n return;\n }\n });\n};\nexport const getPaginationOptions = (\n page: number,",
"score": 25.93238261949012
},
{
"filename": "src/facades/helper.ts",
"retrieved_chunk": " \"\n >\n <p>\n Welcome to CariTahu! There's just one\n more step before you get to the fun\n part.\n </p>\n <p>\n Verify your CariTahu account by clicking\n on the button below:",
"score": 21.09977253398847
},
{
"filename": "src/facades/helper.ts",
"retrieved_chunk": " </p>\n </td>\n </tr>\n </tbody>\n </table>\n </td>\n </tr>\n <tr>\n <td align=\"center\" style=\"padding: 0 10px 0 10px;\">\n <table",
"score": 14.98409606103689
}
] | typescript | const paginationOptions: PaginationOptions = getPaginationOptions(
p,
forumPerPage
); |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker | ? RemoteDemManager : LocalDemManager; |
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " ): CancelablePromise<FetchResponse> =>\n this.actor.send(\"fetchTile\", [], timer, this.managerId, z, x, y);\n fetchAndParseTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> =>\n this.actor.send(\"fetchAndParseTile\", [], timer, this.managerId, z, x, y);\n fetchContourTile = (",
"score": 31.372163235863372
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> => {\n const self = this;\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 29.77322124848883
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " this.managerId,\n z,\n x,\n y,\n options,\n );\n}",
"score": 29.075938055629887
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " fetchTile(\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse> {\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 26.801470750442697
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " this.start = start;\n this.end = end;\n this.points = [];\n this.append = this.append.bind(this);\n this.prepend = this.prepend.bind(this);\n }\n append(x: number, y: number) {\n this.points.push(Math.round(x), Math.round(y));\n }\n prepend(x: number, y: number) {",
"score": 26.113619117999185
}
] | typescript | ? RemoteDemManager : LocalDemManager; |
import { User } from '@prisma/client';
import axios from 'axios';
import { compare, hash } from 'bcrypt';
import { Request, Response } from 'express';
import jwt, { Jwt, JwtPayload, VerifyErrors } from 'jsonwebtoken';
import { v4 as uuidv4 } from 'uuid';
import { createActivationLink } from '../databases/activation.link.database';
import {
clearRefreshToken,
createActiveUser,
createUser,
getUserByEmail,
getUserByRefreshToken,
getUserByUsername,
updateRefreshToken,
} from '../databases/user.database';
import { generateRandomString, sendEmail } from '../facades/helper';
import { accessTokenSecret, refreshTokenSecret } from '../utils/constants';
export const login = async (req: Request, res: Response) => {
try {
const { email, password } = req.body;
const user = await getUserByEmail(email);
if (!user) {
return res.status(400).json({ errors: ['email not found!'] });
}
const match = await compare(password, user.password);
if (!match) {
return res.status(403).json({ errors: ['wrong credentials!'] });
}
if (!user.isActive) {
return res
.status(403)
.json({ errors: ['please verify your account before proceeding!'] });
}
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
const refreshToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
refreshTokenSecret,
{
expiresIn: '1d',
}
);
const user2 = await updateRefreshToken(user.id, refreshToken);
return res
.cookie('refreshToken', refreshToken, {
httpOnly: true,
sameSite: 'none',
secure: false,
maxAge: 24 * 60 * 60 * 1000,
})
.status(200)
.json({ user: user2, accessToken: accessToken });
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const loginGoogleToken = async (req: Request, res: Response) => {
try {
const { token } = req.body;
const response = await axios.get(
`https://oauth2.googleapis.com/tokeninfo?id_token=${token}`
);
if (response.status === 400) {
return res.status(400).json({ errors: ['token not found!'] });
}
const user = await getUserByEmail(response.data.email);
if (user) {
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
const refreshToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
refreshTokenSecret,
{
expiresIn: '1d',
}
);
const user2 = await updateRefreshToken(user.id, refreshToken);
return res
.cookie('refreshToken', refreshToken, {
httpOnly: true,
maxAge: 24 * 60 * 60 * 1000,
})
.status(200)
.json({ user: user2, accessToken: accessToken });
} else {
const user: User = {
email: response.data.email,
name: response.data.name,
profilePicture: response.data.picture,
role: 'Member',
id: uuidv4(),
username: generateRandomString('profile'),
refreshToken: '',
isActive: true,
password: '',
};
await createActiveUser(user);
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
const refreshToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
refreshTokenSecret,
{
expiresIn: '1d',
}
);
const user2 = await updateRefreshToken(user.id, refreshToken);
return res
.cookie('refreshToken', refreshToken, {
httpOnly: true,
maxAge: 24 * 60 * 60 * 1000,
})
.status(200)
.json({ user: user2, accessToken: accessToken });
}
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const register = async (req: Request, res: Response) => {
try {
const { email, name, username, password } = req.body;
const validateEmail = await getUserByEmail(email);
const validateUsername = await getUserByUsername(username);
if (validateEmail) {
return res.status(400).json({ errors: ['email you provided is taken!'] });
}
if (validateUsername) {
return res
.status(400)
.json({ errors: ['username you provided is taken!'] });
}
const saltRounds = 10;
const hashedPassword = await hash(password, saltRounds);
const user = await createUser({
id: uuidv4(),
email: email,
username: username,
name: name,
password: hashedPassword,
role: 'Member',
isActive: false,
profilePicture: '/profile.webp',
refreshToken: '',
});
const activationLink = await createActivationLink({
id: uuidv4(),
userId: user.id,
expirationDate: new Date(Date.now() + 3600 * 1000 * 2),
});
| await sendEmail(email, activationLink.id); |
return res.status(200).json({ user: user });
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const refreshToken = async (req: Request, res: Response) => {
try {
const refreshToken = req.cookies.refreshToken;
const user = await getUserByRefreshToken(refreshToken);
if (!user) {
return res.status(403).json({ errors: ['user not found!'] });
}
jwt.verify(
refreshToken,
refreshTokenSecret,
(
err: VerifyErrors | null,
decode: Jwt | JwtPayload | string | undefined
) => {
if (err) {
return res.status(400).json({ errors: [err.message] });
}
if (decode) {
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
res.status(200).json({ accessToken: accessToken });
}
}
);
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const logout = async (req: Request, res: Response) => {
try {
const refreshToken = req.cookies.refreshToken;
const user = await getUserByRefreshToken(refreshToken);
if (!user) {
return res.status(403).json({ errors: ['user not found!'] });
}
await clearRefreshToken(user.id);
return res
.status(200)
.clearCookie('refreshToken')
.json({ successes: ['logout successful!'] });
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
| src/controllers/auth.controller.ts | TinTinWinata-io-fest-backend-9d0d374 | [
{
"filename": "src/controllers/activation.link.controller.ts",
"retrieved_chunk": " expirationDate: new Date(Date.now() + 3600 * 1000 * 2),\n });\n if (activationLink && (await sendEmail(user.email, activationLink.id))) {\n await deleteActivationLinkById(activationLinkId);\n }\n return res.status(200).json({ successes: [\"email sent successfully!\"] });\n } catch (error) {\n console.log(error);\n res.status(400).json({ errors: [\"error occurred!\"] });\n }",
"score": 44.60359957275305
},
{
"filename": "src/controllers/forum.comment.controller.ts",
"retrieved_chunk": " const userId = req.jwtPayload && req.jwtPayload.id;\n console.log('2')\n const forumComment = await cForumComment({\n id: uuidv4(),\n comment: comment,\n forumId: forumId,\n userId: userId,\n createdAt: new Date(Date.now()),\n });\n console.log('3')",
"score": 34.29792026328631
},
{
"filename": "src/controllers/forum.reply.controller.ts",
"retrieved_chunk": " const forumReply = await cForumReply({\n id: uuidv4(),\n reply: reply,\n forumCommentId: forumCommentId,\n userId: userId,\n createdAt: new Date(Date.now()),\n });\n if (!forumReply) {\n return res.status(400).json({ errors: [\"forum reply cannot be made!\"] });\n }",
"score": 27.38295290736235
},
{
"filename": "src/controllers/forum.controller.ts",
"retrieved_chunk": " userId: userId,\n seen: 0,\n createdAt: new Date(Date.now()),\n updatedAt: new Date(Date.now()),\n });\n if (!forum) {\n return res.status(400).json({ errors: ['forum cannot be made!'] });\n }\n if (req.files && !(req.files instanceof Array)) {\n // Validate file must be array",
"score": 23.38798939018545
},
{
"filename": "src/controllers/activation.link.controller.ts",
"retrieved_chunk": "export const generateActivationLink = async (req: Request, res: Response) => {\n try {\n const { userId, activationLinkId } = req.body;\n const user = await getUserById(userId);\n if (!user) {\n return res.status(404).json({ errors: [\"user not found!\"] });\n }\n const activationLink = await createActivationLink({\n id: uuidv4(),\n userId: user.id,",
"score": 22.60500290094258
}
] | typescript | await sendEmail(email, activationLink.id); |
import { Request, Response } from "express";
import { v4 as uuidv4 } from "uuid";
import {
createActivationLink,
deleteActivationLinkById,
getActivationLinkById,
} from "../databases/activation.link.database";
import { activateUser as aUser, getUserById } from "../databases/user.database";
import { sendEmail } from "../facades/helper";
export const activateUser = async (req: Request, res: Response) => {
try {
const { activationLinkId } = req.body;
const activationLink = await getActivationLinkById(activationLinkId);
if (!activationLink) {
return res.status(404).json({ errors: ["activation link not found!"] });
}
if (Date.now() > activationLink.expirationDate.getTime()) {
return res.status(410).json({ errors: ["activation link expired!"] });
}
if (await aUser(activationLink.userId)) {
await deleteActivationLinkById(activationLink.id);
}
return res
.status(200)
.json({ successes: ["user activated successfully!"] });
} catch (error) {
console.log(error);
res.status(400).json({ errors: ["error occurred!"] });
}
};
export const generateActivationLink = async (req: Request, res: Response) => {
try {
const { userId, activationLinkId } = req.body;
const user = await getUserById(userId);
if (!user) {
return res.status(404).json({ errors: ["user not found!"] });
}
const activationLink = await createActivationLink({
id: uuidv4(),
userId: user.id,
expirationDate: new Date(Date.now() + 3600 * 1000 * 2),
});
| if (activationLink && (await sendEmail(user.email, activationLink.id))) { |
await deleteActivationLinkById(activationLinkId);
}
return res.status(200).json({ successes: ["email sent successfully!"] });
} catch (error) {
console.log(error);
res.status(400).json({ errors: ["error occurred!"] });
}
};
| src/controllers/activation.link.controller.ts | TinTinWinata-io-fest-backend-9d0d374 | [
{
"filename": "src/controllers/auth.controller.ts",
"retrieved_chunk": " profilePicture: '/profile.webp',\n refreshToken: '',\n });\n const activationLink = await createActivationLink({\n id: uuidv4(),\n userId: user.id,\n expirationDate: new Date(Date.now() + 3600 * 1000 * 2),\n });\n await sendEmail(email, activationLink.id);\n return res.status(200).json({ user: user });",
"score": 79.23273472177472
},
{
"filename": "src/controllers/forum.reply.controller.ts",
"retrieved_chunk": " const forumReply = await cForumReply({\n id: uuidv4(),\n reply: reply,\n forumCommentId: forumCommentId,\n userId: userId,\n createdAt: new Date(Date.now()),\n });\n if (!forumReply) {\n return res.status(400).json({ errors: [\"forum reply cannot be made!\"] });\n }",
"score": 42.01716501786234
},
{
"filename": "src/controllers/forum.comment.controller.ts",
"retrieved_chunk": " const userId = req.jwtPayload && req.jwtPayload.id;\n console.log('2')\n const forumComment = await cForumComment({\n id: uuidv4(),\n comment: comment,\n forumId: forumId,\n userId: userId,\n createdAt: new Date(Date.now()),\n });\n console.log('3')",
"score": 41.45745627793446
},
{
"filename": "src/controllers/forum.controller.ts",
"retrieved_chunk": " userId: userId,\n seen: 0,\n createdAt: new Date(Date.now()),\n updatedAt: new Date(Date.now()),\n });\n if (!forum) {\n return res.status(400).json({ errors: ['forum cannot be made!'] });\n }\n if (req.files && !(req.files instanceof Array)) {\n // Validate file must be array",
"score": 36.87918638074434
},
{
"filename": "src/controllers/user.controller.ts",
"retrieved_chunk": " }\n const { profilePicture } = req.body;\n const userId = req.jwtPayload && req.jwtPayload.id;\n const user = await uProfilePicture(userId, profilePicture);\n if (user) {\n return res.status(200).json(user);\n }\n return res.status(400).json({ errors: ['user not found!'] });\n } catch (error) {\n console.log(error);",
"score": 35.57532197100713
}
] | typescript | if (activationLink && (await sendEmail(user.email, activationLink.id))) { |
import { User } from '@prisma/client';
import axios from 'axios';
import { compare, hash } from 'bcrypt';
import { Request, Response } from 'express';
import jwt, { Jwt, JwtPayload, VerifyErrors } from 'jsonwebtoken';
import { v4 as uuidv4 } from 'uuid';
import { createActivationLink } from '../databases/activation.link.database';
import {
clearRefreshToken,
createActiveUser,
createUser,
getUserByEmail,
getUserByRefreshToken,
getUserByUsername,
updateRefreshToken,
} from '../databases/user.database';
import { generateRandomString, sendEmail } from '../facades/helper';
import { accessTokenSecret, refreshTokenSecret } from '../utils/constants';
export const login = async (req: Request, res: Response) => {
try {
const { email, password } = req.body;
const user = await getUserByEmail(email);
if (!user) {
return res.status(400).json({ errors: ['email not found!'] });
}
const match = await compare(password, user.password);
if (!match) {
return res.status(403).json({ errors: ['wrong credentials!'] });
}
if (!user.isActive) {
return res
.status(403)
.json({ errors: ['please verify your account before proceeding!'] });
}
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
const refreshToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
refreshTokenSecret,
{
expiresIn: '1d',
}
);
const user2 = await updateRefreshToken(user.id, refreshToken);
return res
.cookie('refreshToken', refreshToken, {
httpOnly: true,
sameSite: 'none',
secure: false,
maxAge: 24 * 60 * 60 * 1000,
})
.status(200)
.json({ user: user2, accessToken: accessToken });
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const loginGoogleToken = async (req: Request, res: Response) => {
try {
const { token } = req.body;
const response = await axios.get(
`https://oauth2.googleapis.com/tokeninfo?id_token=${token}`
);
if (response.status === 400) {
return res.status(400).json({ errors: ['token not found!'] });
}
const user = await getUserByEmail(response.data.email);
if (user) {
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
const refreshToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
refreshTokenSecret,
{
expiresIn: '1d',
}
);
const user2 = await updateRefreshToken(user.id, refreshToken);
return res
.cookie('refreshToken', refreshToken, {
httpOnly: true,
maxAge: 24 * 60 * 60 * 1000,
})
.status(200)
.json({ user: user2, accessToken: accessToken });
} else {
const user: User = {
email: response.data.email,
name: response.data.name,
profilePicture: response.data.picture,
role: 'Member',
id: uuidv4(),
| username: generateRandomString('profile'),
refreshToken: '',
isActive: true,
password: '',
}; |
await createActiveUser(user);
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
const refreshToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
refreshTokenSecret,
{
expiresIn: '1d',
}
);
const user2 = await updateRefreshToken(user.id, refreshToken);
return res
.cookie('refreshToken', refreshToken, {
httpOnly: true,
maxAge: 24 * 60 * 60 * 1000,
})
.status(200)
.json({ user: user2, accessToken: accessToken });
}
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const register = async (req: Request, res: Response) => {
try {
const { email, name, username, password } = req.body;
const validateEmail = await getUserByEmail(email);
const validateUsername = await getUserByUsername(username);
if (validateEmail) {
return res.status(400).json({ errors: ['email you provided is taken!'] });
}
if (validateUsername) {
return res
.status(400)
.json({ errors: ['username you provided is taken!'] });
}
const saltRounds = 10;
const hashedPassword = await hash(password, saltRounds);
const user = await createUser({
id: uuidv4(),
email: email,
username: username,
name: name,
password: hashedPassword,
role: 'Member',
isActive: false,
profilePicture: '/profile.webp',
refreshToken: '',
});
const activationLink = await createActivationLink({
id: uuidv4(),
userId: user.id,
expirationDate: new Date(Date.now() + 3600 * 1000 * 2),
});
await sendEmail(email, activationLink.id);
return res.status(200).json({ user: user });
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const refreshToken = async (req: Request, res: Response) => {
try {
const refreshToken = req.cookies.refreshToken;
const user = await getUserByRefreshToken(refreshToken);
if (!user) {
return res.status(403).json({ errors: ['user not found!'] });
}
jwt.verify(
refreshToken,
refreshTokenSecret,
(
err: VerifyErrors | null,
decode: Jwt | JwtPayload | string | undefined
) => {
if (err) {
return res.status(400).json({ errors: [err.message] });
}
if (decode) {
const accessToken = jwt.sign(
{ id: user.id, email: user.email, role: user.role },
accessTokenSecret,
{
expiresIn: '7d',
}
);
res.status(200).json({ accessToken: accessToken });
}
}
);
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
export const logout = async (req: Request, res: Response) => {
try {
const refreshToken = req.cookies.refreshToken;
const user = await getUserByRefreshToken(refreshToken);
if (!user) {
return res.status(403).json({ errors: ['user not found!'] });
}
await clearRefreshToken(user.id);
return res
.status(200)
.clearCookie('refreshToken')
.json({ successes: ['logout successful!'] });
} catch (error) {
console.log(error);
return res.status(400).json({ errors: ['error occurred!'] });
}
};
| src/controllers/auth.controller.ts | TinTinWinata-io-fest-backend-9d0d374 | [
{
"filename": "src/databases/user.database.ts",
"retrieved_chunk": " refreshToken: '',\n },\n select: {\n id: true,\n email: true,\n username: true,\n name: true,\n password: false,\n role: true,\n isActive: false,",
"score": 24.405879564216274
},
{
"filename": "src/databases/forum.database.ts",
"retrieved_chunk": " creator: {\n select: {\n id: true,\n email: true,\n role: true,\n username: true,\n name: true,\n password: false,\n isActive: true,\n profilePicture: true,",
"score": 23.454830077136208
},
{
"filename": "src/databases/user.database.ts",
"retrieved_chunk": " email: true,\n username: true,\n name: true,\n password: false,\n role: true,\n isActive: false,\n profilePicture: true,\n forums: true,\n activationLink: false,\n refreshToken: false,",
"score": 23.298148148291645
},
{
"filename": "src/databases/user.database.ts",
"retrieved_chunk": " select: {\n id: true,\n email: true,\n username: true,\n name: true,\n password: false,\n role: true,\n isActive: false,\n profilePicture: true,\n forums: true,",
"score": 23.006064465670452
},
{
"filename": "src/databases/user.database.ts",
"retrieved_chunk": " select: {\n id: true,\n email: true,\n username: true,\n name: true,\n password: false,\n role: true,\n isActive: false,\n profilePicture: true,\n forums: true,",
"score": 23.006064465670452
}
] | typescript | username: generateRandomString('profile'),
refreshToken: '',
isActive: true,
password: '',
}; |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
| source.onTiming((timing) => timings.push(timing)); |
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " expect(requests).toEqual({ 1: 1 });\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(1, getter)).toBe(2);\n expect(requests).toEqual({ 1: 1, 2: 1 });\n // prunes 2 (not 1) because 2 was most recently accessed\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(1, getter)).toBe(2);\n expect(await cache.get(2, getter)).toBe(3);",
"score": 56.815612547980955
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "import { HeightTile } from \"./height-tile\";\nconst initialTile = HeightTile.fromRawDem({\n width: 2,\n height: 2,\n data: Float32Array.from([0, 1, 2, 3]),\n});\ntest(\"raw tile\", () => {\n expect(initialTile.get(0, 0)).toBe(0);\n expect(initialTile.get(1, 0)).toBe(1);\n expect(initialTile.get(1, 1)).toBe(3);",
"score": 48.5360439369922
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " expect(local.received).toEqual([[4, 3, 2]]);\n const timer = new Timer(\"main\");\n timer.timeOrigin = 0;\n expect(await mainActor.send(\"remotePromise\", [], timer, 9).value).toBe(9);\n expect(timer.finish(\"url\")).toMatchObject({\n duration: 2,\n fetch: 1,\n marks: {\n fetch: [[1, 2]],\n main: [[1, 3]],",
"score": 43.38391348472157
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " HeightTile.combineNeighbors(neighbors)?.subsamplePixelCenters(2);\n expect(virtualTile?.get(0, 0)).toBe((7.75 + 3 * 13.75) / 4);\n expect(virtualTile?.get(-1, -1)).toBe((7.25 * 3 + 13.25) / 4);\n expect(virtualTile).toMatchObject({\n width: 4,\n height: 4,\n });\n});\ntest(\"subsample and average centers alignment between tiles\", () => {\n /* ___________ ____________",
"score": 39.35910913857626
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "});\ntest(\"split height tile\", () => {\n const split = initialTile.split(1, 0, 0);\n expect(split.get(0, 0)).toBe(0);\n expect(split.width).toBe(1);\n const split2 = initialTile.split(1, 1, 1);\n expect(split2.get(0, 0)).toBe(3);\n expect(split2.width).toBe(1);\n});\nconst neighbors: HeightTile[] = [];",
"score": 38.253149484543975
}
] | typescript | source.onTiming((timing) => timings.push(timing)); |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
| finish = (url: string): Timing => { |
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this.tilesFetched += timings.tilesUsed;
const offset = timings.origin - this.timeOrigin;
for (const category in timings.marks) {
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?.map((ns) => ns.map((n) => n + offset)) || []),
);
}
this.resources.push(
...timings.resources.map((rt) => applyOffset(rt, offset)),
);
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/actor.ts",
"retrieved_chunk": " id: number;\n error?: string;\n response?: any;\n timings: Timing;\n}\ninterface Request {\n type: \"request\";\n id?: number;\n name: string;\n args: any[];",
"score": 24.89993260678495
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " * A remote source of DEM tiles that can be connected to maplibre.\n */\nexport class DemSource {\n sharedDemProtocolId: string;\n contourProtocolId: string;\n contourProtocolUrlBase: string;\n manager: DemManager;\n sharedDemProtocolUrl: string;\n timingCallbacks: Array<(timing: Timing) => void> = [];\n constructor({",
"score": 20.87185178290069
},
{
"filename": "src/types.ts",
"retrieved_chunk": " managerId: number;\n demUrlPattern: string;\n cacheSize: number;\n encoding: Encoding;\n maxzoom: number;\n timeoutMs: number;\n}\nexport type TimingCategory = \"main\" | \"worker\" | \"fetch\" | \"decode\" | \"isoline\";\n/** Performance profile for a tile request */\nexport interface Timing {",
"score": 18.41670758135873
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": "class Remote {\n received: any[][] = [];\n canceled = false;\n remoteAction = (x: number, y: number, z: number): CancelablePromise<void> => {\n this.received.push([x, y, z]);\n return { cancel() {}, value: Promise.resolve() };\n };\n remotePromise = (x: number, timer?: Timer): CancelablePromise<number> => {\n const oldNow = performance.now;\n if (timer) timer.timeOrigin = 100;",
"score": 16.85789934596935
},
{
"filename": "src/isolines.test.ts",
"retrieved_chunk": " const size = Math.sqrt(flattened.length);\n return HeightTile.fromRawDem({\n width: size,\n height: size,\n data: Float32Array.from(flattened),\n });\n}\nfunction runTestWithRotations(\n name: string,\n interval: number,",
"score": 16.182622503471137
}
] | typescript | finish = (url: string): Timing => { |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
| const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local); |
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " value: new Promise(() => {}),\n });\n}\ntest(\"send and cancel messages\", async () => {\n performance.now = () => 1;\n const remote = new Remote();\n const local = new Local();\n const workerFromMainThread: Worker = {} as any as Worker;\n const mainThreadFromWorker: Worker = {} as any as Worker;\n workerFromMainThread.postMessage = (data) =>",
"score": 140.33616370019593
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " //@ts-ignore\n mainThreadFromWorker?.onmessage?.({ data });\n mainThreadFromWorker.postMessage = (data) =>\n //@ts-ignore\n workerFromMainThread?.onmessage?.({ data });\n const mainActor = new Actor<Remote>(workerFromMainThread, local);\n const workerActor = new Actor<Local>(mainThreadFromWorker, remote);\n mainActor.send(\"remoteAction\", [], undefined, 1, 2, 3);\n expect(remote.received).toEqual([[1, 2, 3]]);\n workerActor.send(\"localAction\", [], undefined, 4, 3, 2);",
"score": 100.15083051462125
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " return result as any as PerformanceResourceTiming;\n}",
"score": 44.30357925008324
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {\n this.callbacks = {};\n this.cancels = {};\n this.dest = dest;\n this.timeoutMs = timeoutMs;\n this.dest.onmessage = async ({ data }) => {\n const message: Message = data;\n if (message.type === \"cancel\") {\n const cancel = this.cancels[message.id];\n delete this.cancels[message.id];",
"score": 43.240697653591724
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": "}\nfunction defaultActor(): Actor<WorkerDispatch> {\n if (!_actor) {\n const worker = new Worker(CONFIG.workerUrl);\n const dispatch = new MainThreadDispatch();\n _actor = new Actor(worker, dispatch);\n }\n return _actor;\n}\n/**",
"score": 42.77929136861772
}
] | typescript | const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local); |
import express from 'express';
import dotenv from 'dotenv';
import cors from 'cors';
import morgan from 'morgan';
import http from 'http';
import cookieParser from 'cookie-parser';
import rateLimit from 'express-rate-limit';
import socket from './utils/socket.io/socketio.js';
//* Routers
import userRouter from './router/user.js';
import adminRouter from './router/admin.js';
import doctorRouter from './router/doctor.js';
import router from './router/router.js';
import conversationRouter from './router/conversation.js';
import messageRouter from './router/message.js';
import connection from './config/mongodbConnection.js';
const limiter = rateLimit({
windowMs: 15 * 60 * 1000,
max: 100,
standardHeaders: true,
legacyHeaders: false,
});
const app = express();
app.use(limiter);
dotenv.config();
/*
*connect mongodb
*/
connection();
/*
*Use Middlewares
*/
app.use(express.json());
app.use(cookieParser());
app.use(morgan('dev'));
app.use(
cors({
origin: [
process.env.DOCTOR_URL,
process.env.USER_URL,
process.env.ADMIN_URL,
],
}),
);
/*
*API Routes]
*/
| app.use('/api', router); |
app.use('/api/user', userRouter);
app.use('/api/admin', adminRouter);
app.use('/api/doctor', doctorRouter);
app.use('/api/conversation', conversationRouter);
app.use('/api/message', messageRouter);
/*
*Start Server
*/
app.use((req, res) => {
res.send('Hey thats a 404');
});
/*
*socket io
*/
const server = http.createServer(app);
socket(server);
const port = process.env.PORT || 8080;
// eslint-disable-next-line no-console
server.listen(port, () => console.log(`Server Started on http://localhost:${port}`));
| src/index.ts | maheswar-dileep-Halo-Doc-Server-b3a3810 | [
{
"filename": "src/utils/socket.io/socketio.ts",
"retrieved_chunk": "import { Server } from 'socket.io';\nimport mongoose from 'mongoose';\nimport dotenv from 'dotenv';\ndotenv.config();\nexport default function socketIo(server: any) {\n const io = new Server(server, {\n cors: {\n origin: [process.env.DOCTOR_URL, process.env.USER_URL, process.env.ADMIN_URL],\n methods: ['GET', 'POST'],\n },",
"score": 37.25799882292736
},
{
"filename": "src/controller/adminController.ts",
"retrieved_chunk": "cloudinary.config({\n cloud_name: process.env.CLOUDINARY_CLOUD_NAME,\n api_key: process.env.CLOUDINARY_API_KEY,\n api_secret: process.env.CLOUDINARY_API_SECRET,\n});\nconst stripe = new Stripe(process.env.STRIPE_SECRET, {\n apiVersion: '2022-11-15',\n});\n/*\n *Admin Controllers",
"score": 28.784319997237123
},
{
"filename": "src/utils/nodemailer.ts",
"retrieved_chunk": " pass: process.env.SMTP_PASS,\n },\n });\n const info = await transporter.sendMail({\n from: process.env.SMTP_USER, // sender address\n to: email, // list of receivers\n subject: 'Welcome To Halo-Doc', // Subject line\n html,\n });\n } catch (error) {",
"score": 22.421172229975568
},
{
"filename": "src/controller/userController.ts",
"retrieved_chunk": " ],\n customer: customer.id,\n mode: 'payment',\n success_url: `${process.env.CLIENT_URL}/success`,\n cancel_url: `${process.env.CLIENT_URL}/failure`,\n });\n return res.status(200).send({ success: true, message: 'payment successful', url: session.url });\n } catch (error) {\n console.log(error);\n return res.status(500).send({ success: false, message: 'Internal Server Error' });",
"score": 19.65403396698261
},
{
"filename": "src/config/mongodbConnection.ts",
"retrieved_chunk": "import mongoose from 'mongoose';\nmongoose.connection.once('connected', () => {\n console.log('db connected successfully');\n});\nconst connection = async () => {\n try {\n await mongoose.connect(process.env.MONGODB_URL);\n } catch (error) {\n console.log(error);\n }",
"score": 16.345181462571354
}
] | typescript | app.use('/api', router); |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][] | []): HeightTile { |
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
return HeightTile.fromRawDem({
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
const size = heightTile.width;
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile.height,
(x, y) => {
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
rotatedResult[ele] = isolines[ele].map((eles) => {
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " fetch: 3,\n wait: 1,\n marks: {\n main: [[1, 7]],\n worker: [[1, 7]],\n fetch: [\n [1, 4],\n [2, 4],\n [3, 4],\n ],",
"score": 41.47345075171733
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "import { HeightTile } from \"./height-tile\";\nconst initialTile = HeightTile.fromRawDem({\n width: 2,\n height: 2,\n data: Float32Array.from([0, 1, 2, 3]),\n});\ntest(\"raw tile\", () => {\n expect(initialTile.get(0, 0)).toBe(0);\n expect(initialTile.get(1, 0)).toBe(1);\n expect(initialTile.get(1, 1)).toBe(3);",
"score": 40.432242922113076
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " expect(virtualTile?.get(0, 2)).toBe(26);\n expect(virtualTile?.get(1, 2)).toBe(27);\n expect(virtualTile?.get(2, 2)).toBe(28);\n});\n// 0 1 | 2 3 | 4 5\n// 6 7 | 8 9 | 10 11\n// ------ ------- ------\n// 12 13 | 14 15 | 16 17\n// 18 19 | 20 21 | 22 23\n// ------ ------- ------",
"score": 40.14757749519217
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " expect(notSubsampled).toMatchObject({\n width: 3,\n height: 3,\n });\n expect(subsampled?.get(0, 0)).toBe(notSubsampled?.get(0, 0));\n expect(subsampled?.get(2, 2)).toBe(notSubsampled?.get(1, 1));\n expect(subsampled?.get(-2, -2)).toBe(notSubsampled?.get(-1, -1));\n});",
"score": 38.976965849898875
},
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " expect(requests).toEqual({ 1: 1 });\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(1, getter)).toBe(2);\n expect(requests).toEqual({ 1: 1, 2: 1 });\n // prunes 2 (not 1) because 2 was most recently accessed\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(1, getter)).toBe(2);\n expect(await cache.get(2, getter)).toBe(3);",
"score": 38.839667096151935
}
] | typescript | []): HeightTile { |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
| contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`; |
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " /** The \"virtual\" tile url using the protocol ID registered with maplibre */\n url: String;\n /** Timing origin that all marks are relative to. */\n origin: number;\n /** Overall duration of the request */\n duration: number;\n /** Time spent fetching all resources, or `undefined` if they were cached */\n fetch?: number;\n /** Time spent decoding all raster-rgb images, or `undefined` if it was cached */\n decode?: number;",
"score": 18.969426735314592
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " const options: GlobalContourTileOptions = {\n thresholds: {\n 10: [500],\n 11: [100, 1000],\n },\n };\n expect(decodeOptions(encodeOptions(options))).toEqual(options);\n});\ntest(\"extract levels from global contour options\", () => {\n // eslint-disable-next-line",
"score": 17.79343038130009
},
{
"filename": "src/decode-image.ts",
"retrieved_chunk": " cancel: () => {\n canceled = true;\n },\n };\n}\n/**\n * Parses a `raster-dem` image into a DemTile using `<img>` element drawn to a `<canvas>`.\n * Only works on the main thread, but works across all browsers.\n */\nfunction decodeImageOld(",
"score": 16.439203779034845
},
{
"filename": "src/cache.ts",
"retrieved_chunk": " },\n );\n let canceled = false;\n return {\n value,\n cancel: () => {\n if (result && result.cancel && !canceled) {\n canceled = true;\n if (--result.waiting <= 0) {\n result.cancel();",
"score": 16.241752323038796
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " * Returns a new tile scaled up by `factor` with pixel values that are subsampled using\n * bilinear interpolation between the original height tile values.\n *\n * The original and result tile are assumed to represent values taken at the center of each pixel.\n */\n subsamplePixelCenters = (factor: number): HeightTile => {\n const lerp = (a: number, b: number, f: number) =>\n isNaN(a) ? b : isNaN(b) ? a : a + (b - a) * f;\n if (factor <= 1) return this;\n const sub = 0.5 - 1 / (2 * factor);",
"score": 14.734139659328317
}
] | typescript | contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`; |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
| const timings: Timing[] = []; |
source.onTiming((timing) => timings.push(timing));
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " expect(requests).toEqual({ 1: 1 });\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(1, getter)).toBe(2);\n expect(requests).toEqual({ 1: 1, 2: 1 });\n // prunes 2 (not 1) because 2 was most recently accessed\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(1, getter)).toBe(2);\n expect(await cache.get(2, getter)).toBe(3);",
"score": 56.815612547980955
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "import { HeightTile } from \"./height-tile\";\nconst initialTile = HeightTile.fromRawDem({\n width: 2,\n height: 2,\n data: Float32Array.from([0, 1, 2, 3]),\n});\ntest(\"raw tile\", () => {\n expect(initialTile.get(0, 0)).toBe(0);\n expect(initialTile.get(1, 0)).toBe(1);\n expect(initialTile.get(1, 1)).toBe(3);",
"score": 48.5360439369922
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " expect(local.received).toEqual([[4, 3, 2]]);\n const timer = new Timer(\"main\");\n timer.timeOrigin = 0;\n expect(await mainActor.send(\"remotePromise\", [], timer, 9).value).toBe(9);\n expect(timer.finish(\"url\")).toMatchObject({\n duration: 2,\n fetch: 1,\n marks: {\n fetch: [[1, 2]],\n main: [[1, 3]],",
"score": 43.38391348472157
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " HeightTile.combineNeighbors(neighbors)?.subsamplePixelCenters(2);\n expect(virtualTile?.get(0, 0)).toBe((7.75 + 3 * 13.75) / 4);\n expect(virtualTile?.get(-1, -1)).toBe((7.25 * 3 + 13.25) / 4);\n expect(virtualTile).toMatchObject({\n width: 4,\n height: 4,\n });\n});\ntest(\"subsample and average centers alignment between tiles\", () => {\n /* ___________ ____________",
"score": 39.35910913857626
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "});\ntest(\"split height tile\", () => {\n const split = initialTile.split(1, 0, 0);\n expect(split.get(0, 0)).toBe(0);\n expect(split.width).toBe(1);\n const split2 = initialTile.split(1, 1, 1);\n expect(split2.get(0, 0)).toBe(3);\n expect(split2.width).toBe(1);\n});\nconst neighbors: HeightTile[] = [];",
"score": 38.253149484543975
}
] | typescript | const timings: Timing[] = []; |
import express from 'express';
import dotenv from 'dotenv';
import cors from 'cors';
import morgan from 'morgan';
import http from 'http';
import cookieParser from 'cookie-parser';
import rateLimit from 'express-rate-limit';
import socket from './utils/socket.io/socketio.js';
//* Routers
import userRouter from './router/user.js';
import adminRouter from './router/admin.js';
import doctorRouter from './router/doctor.js';
import router from './router/router.js';
import conversationRouter from './router/conversation.js';
import messageRouter from './router/message.js';
import connection from './config/mongodbConnection.js';
const limiter = rateLimit({
windowMs: 15 * 60 * 1000,
max: 100,
standardHeaders: true,
legacyHeaders: false,
});
const app = express();
app.use(limiter);
dotenv.config();
/*
*connect mongodb
*/
connection();
/*
*Use Middlewares
*/
app.use(express.json());
app.use(cookieParser());
app.use(morgan('dev'));
app.use(
cors({
origin: [
process.env.DOCTOR_URL,
process.env.USER_URL,
process.env.ADMIN_URL,
],
}),
);
/*
*API Routes]
*/
app.use( | '/api', router); |
app.use('/api/user', userRouter);
app.use('/api/admin', adminRouter);
app.use('/api/doctor', doctorRouter);
app.use('/api/conversation', conversationRouter);
app.use('/api/message', messageRouter);
/*
*Start Server
*/
app.use((req, res) => {
res.send('Hey thats a 404');
});
/*
*socket io
*/
const server = http.createServer(app);
socket(server);
const port = process.env.PORT || 8080;
// eslint-disable-next-line no-console
server.listen(port, () => console.log(`Server Started on http://localhost:${port}`));
| src/index.ts | maheswar-dileep-Halo-Doc-Server-b3a3810 | [
{
"filename": "src/utils/socket.io/socketio.ts",
"retrieved_chunk": "import { Server } from 'socket.io';\nimport mongoose from 'mongoose';\nimport dotenv from 'dotenv';\ndotenv.config();\nexport default function socketIo(server: any) {\n const io = new Server(server, {\n cors: {\n origin: [process.env.DOCTOR_URL, process.env.USER_URL, process.env.ADMIN_URL],\n methods: ['GET', 'POST'],\n },",
"score": 24.838665881951577
},
{
"filename": "src/controller/adminController.ts",
"retrieved_chunk": "cloudinary.config({\n cloud_name: process.env.CLOUDINARY_CLOUD_NAME,\n api_key: process.env.CLOUDINARY_API_KEY,\n api_secret: process.env.CLOUDINARY_API_SECRET,\n});\nconst stripe = new Stripe(process.env.STRIPE_SECRET, {\n apiVersion: '2022-11-15',\n});\n/*\n *Admin Controllers",
"score": 19.18954666482475
},
{
"filename": "src/utils/nodemailer.ts",
"retrieved_chunk": " pass: process.env.SMTP_PASS,\n },\n });\n const info = await transporter.sendMail({\n from: process.env.SMTP_USER, // sender address\n to: email, // list of receivers\n subject: 'Welcome To Halo-Doc', // Subject line\n html,\n });\n } catch (error) {",
"score": 14.947448153317046
},
{
"filename": "src/controller/userController.ts",
"retrieved_chunk": " ],\n customer: customer.id,\n mode: 'payment',\n success_url: `${process.env.CLIENT_URL}/success`,\n cancel_url: `${process.env.CLIENT_URL}/failure`,\n });\n return res.status(200).send({ success: true, message: 'payment successful', url: session.url });\n } catch (error) {\n console.log(error);\n return res.status(500).send({ success: false, message: 'Internal Server Error' });",
"score": 13.10268931132174
},
{
"filename": "src/config/mongodbConnection.ts",
"retrieved_chunk": "import mongoose from 'mongoose';\nmongoose.connection.once('connected', () => {\n console.log('db connected successfully');\n});\nconst connection = async () => {\n try {\n await mongoose.connect(process.env.MONGODB_URL);\n } catch (error) {\n console.log(error);\n }",
"score": 10.896787641714235
}
] | typescript | '/api', router); |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][][]): HeightTile {
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
return HeightTile.fromRawDem({
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
const size = heightTile.width;
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile.height,
| (x, y) => { |
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
rotatedResult[ele] = isolines[ele].map((eles) => {
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " split = (subz: number, subx: number, suby: number): HeightTile => {\n if (subz === 0) return this;\n const by = 1 << subz;\n const dx = (subx * this.width) / by;\n const dy = (suby * this.height) / by;\n return new HeightTile(this.width / by, this.height / by, (x, y) =>\n this.get(x + dx, y + dy),\n );\n };\n /**",
"score": 22.144327335968885
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " */\n materialize = (buffer: number = 2): HeightTile => {\n const stride = this.width + 2 * buffer;\n const data = new Float32Array(stride * (this.height + 2 * buffer));\n let idx = 0;\n for (let y = -buffer; y < this.height + buffer; y++) {\n for (let x = -buffer; x < this.width + buffer; x++) {\n data[idx++] = this.get(x, y);\n }\n }",
"score": 21.13123289379535
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " if (!mainTile) {\n return undefined;\n }\n const width = mainTile.width;\n const height = mainTile.height;\n return new HeightTile(width, height, (x, y) => {\n let gridIdx = 0;\n if (y < 0) {\n y += height;\n } else if (y < height) {",
"score": 20.993495419394883
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " return new HeightTile(\n this.width,\n this.height,\n (x, y) => data[(y + buffer) * stride + x + buffer],\n );\n };\n}",
"score": 19.89422786917441
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": "export default function generateIsolines(\n interval: number,\n tile: HeightTile,\n extent: number = 4096,\n buffer: number = 1,\n): { [ele: number]: number[][] } {\n if (!interval) {\n return {};\n }\n const multiplier = extent / (tile.width - 1);",
"score": 19.575762221643135
}
] | typescript | (x, y) => { |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
finish = (url: string): Timing => {
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this.tilesFetched += timings.tilesUsed;
const offset = timings.origin - this.timeOrigin;
for (const category in timings.marks) {
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?.map((ns) => ns.map((n) => n + offset)) || []),
);
}
this.resources.push(
...timings.resources | .map((rt) => applyOffset(rt, offset)),
); |
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/utils.ts",
"retrieved_chunk": " .map(([key, ...values]) => [key, values]),\n );\n}\nexport function encodeOptions({\n thresholds,\n ...rest\n}: GlobalContourTileOptions): string {\n return sortedEntries({ thresholds: encodeThresholds(thresholds), ...rest })\n .map(\n ([key, value]) =>",
"score": 31.70921949528206
},
{
"filename": "src/types.ts",
"retrieved_chunk": " /** Time spent generating isolines and rendering the vector tile, or `undefined` if it was cached */\n process?: number;\n wait: number;\n /** Number of tiles used for generation, even if they were cached */\n tilesUsed: number;\n /** Map from category (fetch, main, isoline) to list of start/end timestamps */\n marks: {\n [key in TimingCategory]?: number[][];\n };\n /** Detailed timing for all resources actually fetched (not cached) to generate this tile */",
"score": 29.426083195457686
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " const entries = Object.entries(object);\n entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n return entries;\n}\nfunction encodeThresholds(thresholds: {\n [n: number]: number | number[];\n}): string {\n return sortedEntries(thresholds)\n .map(([key, value]) =>\n [key, ...(typeof value === \"number\" ? [value] : value)].join(\"*\"),",
"score": 27.312769032771516
},
{
"filename": "src/vtpbf.ts",
"retrieved_chunk": " let keyIndex = keycache[key];\n if (value === null) continue; // don't encode null value properties\n if (typeof keyIndex === \"undefined\") {\n keys.push(key);\n keyIndex = keys.length - 1;\n keycache[key] = keyIndex;\n }\n pbf.writeVarint(keyIndex);\n const type = typeof value;\n if (type !== \"string\" && type !== \"boolean\" && type !== \"number\") {",
"score": 26.354425586527295
},
{
"filename": "src/cache.ts",
"retrieved_chunk": " get = (key: K, supplier: (key: K) => Promise<V>): Promise<V> =>\n this.getCancelable(key, (key) => ({\n value: supplier(key),\n cancel: () => {},\n })).value;\n getCancelable = (\n key: K,\n supplier: (key: K) => CancelablePromise<V>,\n ): { value: Promise<V>; cancel: () => void } => {\n let result: CacheItem<V> | undefined = this.items.get(key);",
"score": 24.950744513582652
}
] | typescript | .map((rt) => applyOffset(rt, offset)),
); |
import AsyncCache from "./cache";
import decodeImage from "./decode-image";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
import { encodeIndividualOptions, withTimeout } from "./utils";
import {
CancelablePromise,
ContourTile,
DemTile,
Encoding,
FetchResponse,
IndividualContourTileOptions,
} from "./types";
import encodeVectorTile, { GeomType } from "./vtpbf";
import { Timer } from "./performance";
/**
* Holds cached tile state, and exposes `fetchContourTile` which fetches the necessary
* tiles and returns an encoded contour vector tiles.
*/
export interface DemManager {
loaded: Promise<any>;
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse>;
fetchAndParseTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile>;
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile>;
}
/**
* Caches, decodes, and processes raster tiles in the current thread.
*/
export class LocalDemManager implements DemManager {
tileCache: AsyncCache<string, FetchResponse>;
parsedCache: AsyncCache<string, DemTile>;
contourCache: AsyncCache<string, ContourTile>;
demUrlPattern: string;
encoding: Encoding;
maxzoom: number;
timeoutMs: number;
loaded = Promise.resolve();
decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =
decodeImage;
constructor(
demUrlPattern: string,
cacheSize: number,
encoding: Encoding,
maxzoom: number,
timeoutMs: number,
) {
this.tileCache = new AsyncCache | (cacheSize); |
this.parsedCache = new AsyncCache(cacheSize);
this.contourCache = new AsyncCache(cacheSize);
this.timeoutMs = timeoutMs;
this.demUrlPattern = demUrlPattern;
this.encoding = encoding;
this.maxzoom = maxzoom;
}
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> {
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.tileCache.getCancelable(url, () => {
let cancel = () => {};
const options: RequestInit = {};
try {
const controller = new AbortController();
options.signal = controller.signal;
cancel = () => controller.abort();
} catch (e) {
// ignore
}
timer?.fetchTile(url);
const mark = timer?.marker("fetch");
return withTimeout(this.timeoutMs, {
value: fetch(url, options).then(async (response) => {
mark?.();
if (!response.ok) {
throw new Error(`Bad response: ${response.status} for ${url}`);
}
return {
data: await response.blob(),
expires: response.headers.get("expires") || undefined,
cacheControl: response.headers.get("cache-control") || undefined,
};
}),
cancel,
});
});
}
fetchAndParseTile = (
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile> => {
const self = this;
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.parsedCache.getCancelable(url, () => {
const tile = self.fetchTile(z, x, y, timer);
let canceled = false;
let alsoCancel = () => {};
return {
value: tile.value.then(async (response) => {
if (canceled) throw new Error("canceled");
const result = self.decodeImage(response.data, self.encoding);
alsoCancel = result.cancel;
const mark = timer?.marker("decode");
const value = await result.value;
mark?.();
return value;
}),
cancel: () => {
canceled = true;
alsoCancel();
tile.cancel();
},
};
});
};
fetchDem(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<HeightTile> {
const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
const subZ = z - zoom;
const div = 1 << subZ;
const newX = Math.floor(x / div);
const newY = Math.floor(y / div);
const { value, cancel } = this.fetchAndParseTile(zoom, newX, newY, timer);
const subX = x % div;
const subY = y % div;
return {
value: value.then((tile) =>
HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
};
}
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> {
const {
levels,
multiplier = 1,
buffer = 1,
extent = 4096,
contourLayer = "contours",
elevationKey = "ele",
levelKey = "level",
subsampleBelow = 100,
} = options;
// no levels means less than min zoom with levels specified
if (!levels || levels.length === 0) {
return {
cancel() {},
value: Promise.resolve({ arrayBuffer: new ArrayBuffer(0) }),
};
}
const key = [z, x, y, encodeIndividualOptions(options)].join("/");
return this.contourCache.getCancelable(key, () => {
const max = 1 << z;
let canceled = false;
const neighborPromises: (CancelablePromise<HeightTile> | null)[] = [];
for (let iy = y - 1; iy <= y + 1; iy++) {
for (let ix = x - 1; ix <= x + 1; ix++) {
neighborPromises.push(
iy < 0 || iy >= max
? null
: this.fetchDem(z, (ix + max) % max, iy, options, timer),
);
}
}
const value = Promise.all(neighborPromises.map((n) => n?.value)).then(
async (neighbors) => {
let virtualTile = HeightTile.combineNeighbors(neighbors);
if (!virtualTile || canceled) {
return { arrayBuffer: new Uint8Array().buffer };
}
const mark = timer?.marker("isoline");
if (virtualTile.width >= subsampleBelow) {
virtualTile = virtualTile.materialize(2);
} else {
while (virtualTile.width < subsampleBelow) {
virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
}
}
virtualTile = virtualTile
.averagePixelCentersToGrid()
.scaleElevation(multiplier)
.materialize(1);
const isolines = generateIsolines(
levels[0],
virtualTile,
extent,
buffer,
);
mark?.();
const result = encodeVectorTile({
extent,
layers: {
[contourLayer]: {
features: Object.entries(isolines).map(([eleString, geom]) => {
const ele = Number(eleString);
return {
type: GeomType.LINESTRING,
geometry: geom,
properties: {
[elevationKey]: ele,
[levelKey]: Math.max(
...levels.map((l, i) => (ele % l === 0 ? i : 0)),
),
},
};
}),
},
},
});
mark?.();
return { arrayBuffer: result.buffer };
},
);
return {
value,
cancel() {
canceled = true;
neighborPromises.forEach((n) => n && n.cancel());
},
};
});
}
}
| src/dem-manager.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " managerId: number;\n demUrlPattern: string;\n cacheSize: number;\n encoding: Encoding;\n maxzoom: number;\n timeoutMs: number;\n}\nexport type TimingCategory = \"main\" | \"worker\" | \"fetch\" | \"decode\" | \"isoline\";\n/** Performance profile for a tile request */\nexport interface Timing {",
"score": 32.19390594230047
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " maxzoom: number,\n timeoutMs: number,\n actor?: Actor<WorkerDispatch>,\n ) {\n const managerId = (this.managerId = ++id);\n this.actor = actor || defaultActor();\n this.loaded = this.actor.send(\"init\", [], undefined, {\n cacheSize,\n demUrlPattern,\n encoding,",
"score": 29.232290847124723
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " * Caches, decodes, and processes raster tiles in a shared web worker.\n */\nexport default class RemoteDemManager implements DemManager {\n managerId: number;\n actor: Actor<WorkerDispatch>;\n loaded: Promise<any>;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,",
"score": 26.751705301451103
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " managers: { [id: number]: LocalDemManager } = {};\n init = (message: InitMessage): CancelablePromise<void> => {\n this.managers[message.managerId] = new LocalDemManager(\n message.demUrlPattern,\n message.cacheSize,\n message.encoding,\n message.maxzoom,\n message.timeoutMs,\n );\n return { cancel() {}, value: Promise.resolve() };",
"score": 26.30908481041633
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " url: string;\n /** Number of most-recently-used tiles to cache */\n cacheSize?: number;\n /** Prefix for the maplibre protocol */\n id?: string;\n encoding?: \"terrarium\" | \"mapbox\";\n /** Maximum zoom of tiles contained in the source */\n maxzoom: number;\n timeoutMs?: number;\n /** Handle requests in a shared web worker to reduce UI-thread jank */",
"score": 20.501948492597105
}
] | typescript | (cacheSize); |
import { Timer } from "./performance";
import { CancelablePromise, IsTransferrable, Timing } from "./types";
import { withTimeout } from "./utils";
let id = 0;
interface Cancel {
type: "cancel";
id: number;
}
interface Response {
type: "response";
id: number;
error?: string;
response?: any;
timings: Timing;
}
interface Request {
type: "request";
id?: number;
name: string;
args: any[];
}
type Message = Cancel | Response | Request;
type MethodsReturning<T, R> = {
[K in keyof T]: T[K] extends (...args: any) => R ? T[K] : never;
};
/**
* Utility for sending messages to a remote instance of `<T>` running in a web worker
* from the main thread, or in the main thread running from a web worker.
*/
export default class Actor<T> {
callbacks: {
[id: number]: (
error: Error | undefined,
message: any,
timings: Timing,
) => void;
};
cancels: { [id: number]: () => void };
dest: Worker;
timeoutMs: number;
constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {
this.callbacks = {};
this.cancels = {};
this.dest = dest;
this.timeoutMs = timeoutMs;
this.dest.onmessage = async ({ data }) => {
const message: Message = data;
if (message.type === "cancel") {
const cancel = this.cancels[message.id];
delete this.cancels[message.id];
if (cancel) {
cancel();
}
} else if (message.type === "response") {
const callback = this.callbacks[message.id];
delete this.callbacks[message.id];
if (callback) {
callback(
message.error ? new Error(message.error) : undefined,
message.response,
message.timings,
);
}
} else if (message.type === "request") {
| const timer = new Timer("worker"); |
const handler: Function = (dispatcher as any)[message.name];
const request = handler.apply(handler, [...message.args, timer]);
const url = `${message.name}_${message.id}`;
if (message.id && request) {
this.cancels[message.id] = request.cancel;
try {
const response = await request.value;
const transferrables = (response as IsTransferrable)
?.transferrables;
this.postMessage(
{
id: message.id,
type: "response",
response,
timings: timer.finish(url),
},
transferrables,
);
} catch (e: any) {
this.postMessage({
id: message.id,
type: "response",
error: e?.toString() || "error",
timings: timer.finish(url),
});
}
delete this.cancels[message.id];
}
}
};
}
postMessage(message: Message, transferrables?: Transferable[]) {
this.dest.postMessage(message, transferrables || []);
}
/** Invokes a method by name with a set of arguments in the remote context. */
send<
R,
M extends MethodsReturning<T, CancelablePromise<R>>,
K extends keyof M & string,
P extends Parameters<M[K]>,
>(
name: K,
transferrables: Transferable[],
timer?: Timer,
...args: P
): CancelablePromise<R> {
const thisId = ++id;
const value: Promise<R> = new Promise((resolve, reject) => {
this.postMessage(
{ id: thisId, type: "request", name, args },
transferrables,
);
this.callbacks[thisId] = (error, result, timings) => {
timer?.addAll(timings);
if (error) reject(error);
else resolve(result);
};
});
return withTimeout(this.timeoutMs, {
value,
cancel: () => {
delete this.callbacks[thisId];
this.postMessage({ id: thisId, type: "cancel" });
},
});
}
}
| src/actor.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " managers: { [id: number]: LocalDemManager } = {};\n init = (message: InitMessage): CancelablePromise<void> => {\n this.managers[message.managerId] = new LocalDemManager(\n message.demUrlPattern,\n message.cacheSize,\n message.encoding,\n message.maxzoom,\n message.timeoutMs,\n );\n return { cancel() {}, value: Promise.resolve() };",
"score": 72.34501673629664
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " try {\n const data = await result.value;\n timing = timer.finish(request.url);\n if (canceled) return;\n response(undefined, data.arrayBuffer);\n } catch (error) {\n if (canceled) return;\n timing = timer.error(request.url);\n response(error as Error);\n }",
"score": 31.727711126405993
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " timing = timer.finish(request.url);\n if (canceled) return;\n const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();\n if (canceled) return;\n response(undefined, arrayBuffer, data.cacheControl, data.expires);\n } catch (error) {\n timing = timer.error(request.url);\n if (canceled) return;\n response(error as Error);\n }",
"score": 30.33079882457979
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " }\n timer?.fetchTile(url);\n const mark = timer?.marker(\"fetch\");\n return withTimeout(this.timeoutMs, {\n value: fetch(url, options).then(async (response) => {\n mark?.();\n if (!response.ok) {\n throw new Error(`Bad response: ${response.status} for ${url}`);\n }\n return {",
"score": 17.91128368962777
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " actor,\n );\n }\n /** Registers a callback to be invoked with a performance report after each tile is requested. */\n onTiming = (callback: (timing: Timing) => void) => {\n this.timingCallbacks.push(callback);\n };\n getDemTile(z: number, x: number, y: number): Promise<DemTile> {\n return this.manager.fetchAndParseTile(z, x, y).value;\n }",
"score": 17.838385849831877
}
] | typescript | const timer = new Timer("worker"); |
import AsyncCache from "./cache";
test("get()", async () => {
const requests: { [_: string]: any } = {};
const cache = new AsyncCache<number, number>(2);
const getter = async (k: number) => {
requests[k] = (requests[k] || 0) + 1;
return k + 1;
};
expect(await cache.get(1, getter)).toBe(2);
expect(await cache.get(1, getter)).toBe(2);
expect(requests).toEqual({ 1: 1 });
expect(await cache.get(2, getter)).toBe(3);
expect(await cache.get(2, getter)).toBe(3);
expect(await cache.get(1, getter)).toBe(2);
expect(requests).toEqual({ 1: 1, 2: 1 });
// prunes 2 (not 1) because 2 was most recently accessed
expect(await cache.get(3, getter)).toBe(4);
expect(await cache.get(3, getter)).toBe(4);
expect(await cache.get(1, getter)).toBe(2);
expect(await cache.get(2, getter)).toBe(3);
expect(requests).toEqual({ 1: 1, 2: 2, 3: 1 });
});
test("getCancelable()", () => {
let canceledFirst = false;
let canceledOthers = false;
const cache = new AsyncCache(2);
const result1 = cache.getCancelable(1, () => ({
value: new Promise(() => {}),
cancel: () => {
canceledFirst = true;
},
}));
const result2 = cache.getCancelable(1, () => ({
value: new Promise(() => {}),
cancel: () => {
canceledOthers = true;
},
}));
const result3 = cache.getCancelable(1, () => ({
value: new Promise(() => {}),
cancel: () => {
canceledOthers = true;
},
}));
expect(canceledFirst).toBeFalsy();
expect( | cache.size()).toBe(1); |
result1.cancel();
expect(canceledFirst).toBeFalsy();
expect(cache.size()).toBe(1);
result2.cancel();
expect(canceledFirst).toBeFalsy();
expect(cache.size()).toBe(1);
result3.cancel();
expect(canceledFirst).toBeTruthy();
expect(canceledOthers).toBeFalsy();
expect(cache.size()).toBe(0);
});
test("dont cache failures", async () => {
const cache = new AsyncCache(2);
let reject: (e: Error) => void = () => {};
const result = cache.getCancelable(1, () => ({
value: new Promise((_, rej) => {
reject = rej;
}),
cancel: () => {
throw new Error();
},
}));
const error = new Error();
reject(error);
await expect(result.value).rejects.toThrow(error);
let resolve: (any: any) => void = () => {};
const result2 = cache.getCancelable(1, () => ({
value: new Promise((res) => {
resolve = res;
}),
cancel: () => {
throw new Error();
},
}));
resolve("ok!");
await expect(result2.value).resolves.toBe("ok!");
});
| src/cache.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/utils.test.ts",
"retrieved_chunk": "test(\"withTimeout - resolve cancels timer\", async () => {\n const cancel = jest.fn();\n const result = withTimeout(1000, {\n value: Promise.resolve(true),\n cancel,\n });\n await expect(result.value).resolves.toBe(true);\n jest.advanceTimersByTime(10_000);\n expect(cancel).not.toBeCalled();\n await expect(result.value).resolves.toBe(true);",
"score": 21.229641620071824
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " },\n });\n const { cancel } = mainActor.send(\"remoteNever\", []);\n expect(remote.canceled).toBeFalsy();\n cancel();\n expect(remote.canceled).toBeTruthy();\n await expect(mainActor.send(\"remoteFail\", []).value).rejects.toThrowError(\n \"Error: error\",\n );\n});",
"score": 17.436333858730418
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " expect(cancel).not.toBeCalled();\n await expect(result.value).rejects.toBe(error);\n});\ntest(\"withTimeout - cancel cancels timer\", async () => {\n const cancel = jest.fn();\n const result = withTimeout(1000, {\n value: new Promise(() => {}),\n cancel,\n });\n result.cancel();",
"score": 17.41198704753486
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " const result = withTimeout(1000, {\n value: new Promise(() => {}),\n cancel,\n });\n jest.advanceTimersByTime(999);\n expect(cancel).not.toBeCalled();\n jest.advanceTimersByTime(2);\n expect(cancel).toBeCalledTimes(1);\n await expect(result.value).rejects.toThrow(new Error(\"timed out\"));\n});",
"score": 16.825633053381786
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " const virtualTile = HeightTile.combineNeighbors(neighbors);\n expect(virtualTile?.get(-1, -1)).toBe(7);\n expect(virtualTile?.get(0, -1)).toBe(8);\n expect(virtualTile?.get(1, -1)).toBe(9);\n expect(virtualTile?.get(2, -1)).toBe(10);\n expect(virtualTile?.get(-1, 0)).toBe(13);\n expect(virtualTile?.get(0, 0)).toBe(14);\n expect(virtualTile?.get(1, 0)).toBe(15);\n expect(virtualTile?.get(2, 0)).toBe(16);\n expect(virtualTile?.get(-1, 2)).toBe(25);",
"score": 15.329799223532364
}
] | typescript | cache.size()).toBe(1); |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
| `${this.contourProtocolUrlBase}?${encodeOptions(options)}`; |
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " /** The \"virtual\" tile url using the protocol ID registered with maplibre */\n url: String;\n /** Timing origin that all marks are relative to. */\n origin: number;\n /** Overall duration of the request */\n duration: number;\n /** Time spent fetching all resources, or `undefined` if they were cached */\n fetch?: number;\n /** Time spent decoding all raster-rgb images, or `undefined` if it was cached */\n decode?: number;",
"score": 18.969426735314592
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " const options: GlobalContourTileOptions = {\n thresholds: {\n 10: [500],\n 11: [100, 1000],\n },\n };\n expect(decodeOptions(encodeOptions(options))).toEqual(options);\n});\ntest(\"extract levels from global contour options\", () => {\n // eslint-disable-next-line",
"score": 17.79343038130009
},
{
"filename": "src/decode-image.ts",
"retrieved_chunk": " cancel: () => {\n canceled = true;\n },\n };\n}\n/**\n * Parses a `raster-dem` image into a DemTile using `<img>` element drawn to a `<canvas>`.\n * Only works on the main thread, but works across all browsers.\n */\nfunction decodeImageOld(",
"score": 16.439203779034845
},
{
"filename": "src/cache.ts",
"retrieved_chunk": " },\n );\n let canceled = false;\n return {\n value,\n cancel: () => {\n if (result && result.cancel && !canceled) {\n canceled = true;\n if (--result.waiting <= 0) {\n result.cancel();",
"score": 16.241752323038796
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " * Returns a new tile scaled up by `factor` with pixel values that are subsampled using\n * bilinear interpolation between the original height tile values.\n *\n * The original and result tile are assumed to represent values taken at the center of each pixel.\n */\n subsamplePixelCenters = (factor: number): HeightTile => {\n const lerp = (a: number, b: number, f: number) =>\n isNaN(a) ? b : isNaN(b) ? a : a + (b - a) * f;\n if (factor <= 1) return this;\n const sub = 0.5 - 1 / (2 * factor);",
"score": 14.734139659328317
}
] | typescript | `${this.contourProtocolUrlBase}?${encodeOptions(options)}`; |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
| (err, data) => { |
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " fetchTile(\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse> {\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 33.88063160452342
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> => {\n const self = this;\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 33.376837962333845
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " * A remote source of DEM tiles that can be connected to maplibre.\n */\nexport class DemSource {\n sharedDemProtocolId: string;\n contourProtocolId: string;\n contourProtocolUrlBase: string;\n manager: DemManager;\n sharedDemProtocolUrl: string;\n timingCallbacks: Array<(timing: Timing) => void> = [];\n constructor({",
"score": 24.630247447419155
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " actor,\n );\n }\n /** Registers a callback to be invoked with a performance report after each tile is requested. */\n onTiming = (callback: (timing: Timing) => void) => {\n this.timingCallbacks.push(callback);\n };\n getDemTile(z: number, x: number, y: number): Promise<DemTile> {\n return this.manager.fetchAndParseTile(z, x, y).value;\n }",
"score": 21.03046401572327
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " response: ResponseCallback,\n ): Cancelable => {\n const [z, x, y] = this.parseUrl(request.url);\n const timer = new Timer(\"main\");\n const result = this.manager.fetchTile(z, x, y, timer);\n let canceled = false;\n (async () => {\n let timing: Timing;\n try {\n const data = await result.value;",
"score": 20.78483304446072
}
] | typescript | (err, data) => { |
import Actor from "./actor";
import { Timer } from "./performance";
import { CancelablePromise } from "./types";
class Local {
received: any[][] = [];
localAction = (x: number, y: number, z: number): CancelablePromise<void> => {
this.received.push([x, y, z]);
return { cancel() {}, value: Promise.resolve() };
};
}
class Remote {
received: any[][] = [];
canceled = false;
remoteAction = (x: number, y: number, z: number): CancelablePromise<void> => {
this.received.push([x, y, z]);
return { cancel() {}, value: Promise.resolve() };
};
remotePromise = (x: number, timer?: Timer): CancelablePromise<number> => {
const oldNow = performance.now;
if (timer) timer.timeOrigin = 100;
performance.now = () => oldNow() - 100;
const finish = timer?.marker("fetch");
performance.now = () => oldNow() - 99;
finish?.();
performance.now = () => oldNow() + 2;
return {
cancel() {
throw new Error("not expected");
},
value: Promise.resolve(x),
};
};
remoteFail = (): CancelablePromise<number> => ({
cancel() {},
value: Promise.reject(new Error("error")),
});
remoteNever = (): CancelablePromise<number> => ({
cancel: () => {
this.canceled = true;
},
value: new Promise(() => {}),
});
}
test("send and cancel messages", async () => {
performance.now = () => 1;
const remote = new Remote();
const local = new Local();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
//@ts-ignore
mainThreadFromWorker?.onmessage?.({ data });
mainThreadFromWorker.postMessage = (data) =>
//@ts-ignore
workerFromMainThread?.onmessage?.({ data });
const mainActor = new Actor<Remote>(workerFromMainThread, local);
const workerActor = new Actor<Local>(mainThreadFromWorker, remote);
mainActor.send("remoteAction", [], undefined, 1, 2, 3);
expect(remote.received).toEqual([[1, 2, 3]]);
workerActor.send("localAction", [], undefined, 4, 3, 2);
expect(local.received).toEqual([[4, 3, 2]]);
const timer = new Timer("main");
timer.timeOrigin = 0;
expect(await mainActor.send("remotePromise", [], timer, 9).value).toBe(9);
| expect(timer.finish("url")).toMatchObject({ |
duration: 2,
fetch: 1,
marks: {
fetch: [[1, 2]],
main: [[1, 3]],
},
});
const { cancel } = mainActor.send("remoteNever", []);
expect(remote.canceled).toBeFalsy();
cancel();
expect(remote.canceled).toBeTruthy();
await expect(mainActor.send("remoteFail", []).value).rejects.toThrowError(
"Error: error",
);
});
| src/actor.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": "const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);\nconst workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);\nconst source = new DemSource({\n url: \"https://example/{z}/{x}/{y}.png\",\n cacheSize: 100,\n encoding: \"terrarium\",\n maxzoom: 11,\n worker: true,\n actor: mainActor,\n});",
"score": 72.13759987855691
},
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " expect(requests).toEqual({ 1: 1 });\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(1, getter)).toBe(2);\n expect(requests).toEqual({ 1: 1, 2: 1 });\n // prunes 2 (not 1) because 2 was most recently accessed\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(1, getter)).toBe(2);\n expect(await cache.get(2, getter)).toBe(3);",
"score": 56.276372875922796
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(tile.width).toBe(4);\n expect(tile.height).toBe(4);\n const tile2 = await source.getDemTile(1, 2, 3);\n expect(tile2.data).toEqual(expectedElevations);\n const timings: Timing[] = [];\n source.onTiming((timing) => timings.push(timing));\n const fetched = await new Promise((resolve, reject) => {\n source.sharedDemProtocol(\n {\n url: source.sharedDemProtocolUrl",
"score": 46.87161940863301
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " expect(virtualTile?.get(2, 2)).toBe((21 + 22 + 27 + 28) / 4);\n expect(virtualTile).toMatchObject({\n width: 3,\n height: 3,\n });\n});\ntest(\"subsample pixel centers\", () => {\n /* ___________ ____________\n | | |\n | old -1,-1 | old 0,-1 |",
"score": 43.6317973775611
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " expect(notSubsampled).toMatchObject({\n width: 3,\n height: 3,\n });\n expect(subsampled?.get(0, 0)).toBe(notSubsampled?.get(0, 0));\n expect(subsampled?.get(2, 2)).toBe(notSubsampled?.get(1, 1));\n expect(subsampled?.get(-2, -2)).toBe(notSubsampled?.get(-1, -1));\n});",
"score": 42.713292558648135
}
] | typescript | expect(timer.finish("url")).toMatchObject({ |
import { Timer } from "./performance";
import { CancelablePromise, IsTransferrable, Timing } from "./types";
import { withTimeout } from "./utils";
let id = 0;
interface Cancel {
type: "cancel";
id: number;
}
interface Response {
type: "response";
id: number;
error?: string;
response?: any;
timings: Timing;
}
interface Request {
type: "request";
id?: number;
name: string;
args: any[];
}
type Message = Cancel | Response | Request;
type MethodsReturning<T, R> = {
[K in keyof T]: T[K] extends (...args: any) => R ? T[K] : never;
};
/**
* Utility for sending messages to a remote instance of `<T>` running in a web worker
* from the main thread, or in the main thread running from a web worker.
*/
export default class Actor<T> {
callbacks: {
[id: number]: (
error: Error | undefined,
message: any,
timings: Timing,
) => void;
};
cancels: { [id: number]: () => void };
dest: Worker;
timeoutMs: number;
constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {
this.callbacks = {};
this.cancels = {};
this.dest = dest;
this.timeoutMs = timeoutMs;
this.dest.onmessage = async ({ data }) => {
const message: Message = data;
if (message.type === "cancel") {
const cancel = this.cancels[message.id];
delete this.cancels[message.id];
if (cancel) {
cancel();
}
} else if (message.type === "response") {
const callback = this.callbacks[message.id];
delete this.callbacks[message.id];
if (callback) {
callback(
message.error ? new Error(message.error) : undefined,
message.response,
message.timings,
);
}
} else if (message.type === "request") {
const timer = new Timer("worker");
const handler: Function = (dispatcher as any)[message.name];
const request = handler.apply(handler, [...message.args, timer]);
const url = `${message.name}_${message.id}`;
if (message.id && request) {
this.cancels[message.id] = request.cancel;
try {
const response = await request.value;
const transferrables = (response as IsTransferrable)
?.transferrables;
this.postMessage(
{
id: message.id,
type: "response",
response,
| timings: timer.finish(url),
},
transferrables,
); |
} catch (e: any) {
this.postMessage({
id: message.id,
type: "response",
error: e?.toString() || "error",
timings: timer.finish(url),
});
}
delete this.cancels[message.id];
}
}
};
}
postMessage(message: Message, transferrables?: Transferable[]) {
this.dest.postMessage(message, transferrables || []);
}
/** Invokes a method by name with a set of arguments in the remote context. */
send<
R,
M extends MethodsReturning<T, CancelablePromise<R>>,
K extends keyof M & string,
P extends Parameters<M[K]>,
>(
name: K,
transferrables: Transferable[],
timer?: Timer,
...args: P
): CancelablePromise<R> {
const thisId = ++id;
const value: Promise<R> = new Promise((resolve, reject) => {
this.postMessage(
{ id: thisId, type: "request", name, args },
transferrables,
);
this.callbacks[thisId] = (error, result, timings) => {
timer?.addAll(timings);
if (error) reject(error);
else resolve(result);
};
});
return withTimeout(this.timeoutMs, {
value,
cancel: () => {
delete this.callbacks[thisId];
this.postMessage({ id: thisId, type: "cancel" });
},
});
}
}
| src/actor.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " }\n timer?.fetchTile(url);\n const mark = timer?.marker(\"fetch\");\n return withTimeout(this.timeoutMs, {\n value: fetch(url, options).then(async (response) => {\n mark?.();\n if (!response.ok) {\n throw new Error(`Bad response: ${response.status} for ${url}`);\n }\n return {",
"score": 20.460848857937822
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " try {\n const data = await result.value;\n timing = timer.finish(request.url);\n if (canceled) return;\n response(undefined, data.arrayBuffer);\n } catch (error) {\n if (canceled) return;\n timing = timer.error(request.url);\n response(error as Error);\n }",
"score": 19.642684030567736
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " managers: { [id: number]: LocalDemManager } = {};\n init = (message: InitMessage): CancelablePromise<void> => {\n this.managers[message.managerId] = new LocalDemManager(\n message.demUrlPattern,\n message.cacheSize,\n message.encoding,\n message.maxzoom,\n message.timeoutMs,\n );\n return { cancel() {}, value: Promise.resolve() };",
"score": 18.95368490893442
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " timing = timer.finish(request.url);\n if (canceled) return;\n const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();\n if (canceled) return;\n response(undefined, arrayBuffer, data.cacheControl, data.expires);\n } catch (error) {\n timing = timer.error(request.url);\n if (canceled) return;\n response(error as Error);\n }",
"score": 18.236427086434162
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " timer?.useTile(url);\n return this.parsedCache.getCancelable(url, () => {\n const tile = self.fetchTile(z, x, y, timer);\n let canceled = false;\n let alsoCancel = () => {};\n return {\n value: tile.value.then(async (response) => {\n if (canceled) throw new Error(\"canceled\");\n const result = self.decodeImage(response.data, self.encoding);\n alsoCancel = result.cancel;",
"score": 15.235240670038266
}
] | typescript | timings: timer.finish(url),
},
transferrables,
); |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
| const source = new DemSource({ |
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " value: new Promise(() => {}),\n });\n}\ntest(\"send and cancel messages\", async () => {\n performance.now = () => 1;\n const remote = new Remote();\n const local = new Local();\n const workerFromMainThread: Worker = {} as any as Worker;\n const mainThreadFromWorker: Worker = {} as any as Worker;\n workerFromMainThread.postMessage = (data) =>",
"score": 146.76169464026876
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " //@ts-ignore\n mainThreadFromWorker?.onmessage?.({ data });\n mainThreadFromWorker.postMessage = (data) =>\n //@ts-ignore\n workerFromMainThread?.onmessage?.({ data });\n const mainActor = new Actor<Remote>(workerFromMainThread, local);\n const workerActor = new Actor<Local>(mainThreadFromWorker, remote);\n mainActor.send(\"remoteAction\", [], undefined, 1, 2, 3);\n expect(remote.received).toEqual([[1, 2, 3]]);\n workerActor.send(\"localAction\", [], undefined, 4, 3, 2);",
"score": 118.65347435526303
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": "}\nfunction defaultActor(): Actor<WorkerDispatch> {\n if (!_actor) {\n const worker = new Worker(CONFIG.workerUrl);\n const dispatch = new MainThreadDispatch();\n _actor = new Actor(worker, dispatch);\n }\n return _actor;\n}\n/**",
"score": 50.32789326077362
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " return result as any as PerformanceResourceTiming;\n}",
"score": 44.30357925008324
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {\n this.callbacks = {};\n this.cancels = {};\n this.dest = dest;\n this.timeoutMs = timeoutMs;\n this.dest.onmessage = async ({ data }) => {\n const message: Message = data;\n if (message.type === \"cancel\") {\n const cancel = this.cancels[message.id];\n delete this.cancels[message.id];",
"score": 43.49571787730994
}
] | typescript | const source = new DemSource({ |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][][]): HeightTile {
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
return HeightTile.fromRawDem({
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
const size = heightTile.width;
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile.height,
(x, y) => {
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
| rotatedResult[ele] = isolines[ele].map((eles) => { |
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " layers: {\n [contourLayer]: {\n features: Object.entries(isolines).map(([eleString, geom]) => {\n const ele = Number(eleString);\n return {\n type: GeomType.LINESTRING,\n geometry: geom,\n properties: {\n [elevationKey]: ele,\n [levelKey]: Math.max(",
"score": 45.18346325917892
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": "export default function generateIsolines(\n interval: number,\n tile: HeightTile,\n extent: number = 4096,\n buffer: number = 1,\n): { [ele: number]: number[][] } {\n if (!interval) {\n return {};\n }\n const multiplier = extent / (tile.width - 1);",
"score": 42.87149535349364
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " ...levels.map((l, i) => (ele % l === 0 ? i : 0)),\n ),\n },\n };\n }),\n },\n },\n });\n mark?.();\n return { arrayBuffer: result.buffer };",
"score": 31.484426620042882
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " }\n const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };\n expect(center).toMatchObject({\n x: 2049,\n y: 2052,\n });\n expect(timings).toMatchObject([\n {\n tilesUsed: 9,\n process: 0,",
"score": 25.59804534285012
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " let tld: number, trd: number, bld: number, brd: number;\n let r: number, c: number;\n const segments: { [ele: string]: number[][] } = {};\n const fragmentByStartByLevel: Map<number, Map<number, Fragment>> = new Map();\n const fragmentByEndByLevel: Map<number, Map<number, Fragment>> = new Map();\n function interpolate(\n point: [number, number],\n threshold: number,\n accept: (x: number, y: number) => void,\n ) {",
"score": 25.497087979678625
}
] | typescript | rotatedResult[ele] = isolines[ele].map((eles) => { |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
finish = (url: string): Timing => {
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this.tilesFetched += timings.tilesUsed;
const offset = timings.origin - this.timeOrigin;
for (const category in timings.marks) {
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?. | map((ns) => ns.map((n) => n + offset)) || []),
); |
}
this.resources.push(
...timings.resources.map((rt) => applyOffset(rt, offset)),
);
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " /** Time spent generating isolines and rendering the vector tile, or `undefined` if it was cached */\n process?: number;\n wait: number;\n /** Number of tiles used for generation, even if they were cached */\n tilesUsed: number;\n /** Map from category (fetch, main, isoline) to list of start/end timestamps */\n marks: {\n [key in TimingCategory]?: number[][];\n };\n /** Detailed timing for all resources actually fetched (not cached) to generate this tile */",
"score": 38.45018016436532
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " ): CancelablePromise<R> {\n const thisId = ++id;\n const value: Promise<R> = new Promise((resolve, reject) => {\n this.postMessage(\n { id: thisId, type: \"request\", name, args },\n transferrables,\n );\n this.callbacks[thisId] = (error, result, timings) => {\n timer?.addAll(timings);\n if (error) reject(error);",
"score": 34.892116744961854
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);\n expect(global.fetch).toBeCalledTimes(1);\n expect(global.fetch).toBeCalledWith(\n \"https://example/1/2/3.png\",\n expect.anything(),\n );\n expect(timings).toMatchObject([\n {\n duration: 0,\n marks: {",
"score": 30.80821995533174
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " try {\n const response = await request.value;\n const transferrables = (response as IsTransferrable)\n ?.transferrables;\n this.postMessage(\n {\n id: message.id,\n type: \"response\",\n response,\n timings: timer.finish(url),",
"score": 27.785286474484757
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " .map(([key, ...values]) => [key, values]),\n );\n}\nexport function encodeOptions({\n thresholds,\n ...rest\n}: GlobalContourTileOptions): string {\n return sortedEntries({ thresholds: encodeThresholds(thresholds), ...rest })\n .map(\n ([key, value]) =>",
"score": 27.08331692335106
}
] | typescript | map((ns) => ns.map((n) => n + offset)) || []),
); |
import { Timer } from "./performance";
import { CancelablePromise, IsTransferrable, Timing } from "./types";
import { withTimeout } from "./utils";
let id = 0;
interface Cancel {
type: "cancel";
id: number;
}
interface Response {
type: "response";
id: number;
error?: string;
response?: any;
timings: Timing;
}
interface Request {
type: "request";
id?: number;
name: string;
args: any[];
}
type Message = Cancel | Response | Request;
type MethodsReturning<T, R> = {
[K in keyof T]: T[K] extends (...args: any) => R ? T[K] : never;
};
/**
* Utility for sending messages to a remote instance of `<T>` running in a web worker
* from the main thread, or in the main thread running from a web worker.
*/
export default class Actor<T> {
callbacks: {
[id: number]: (
error: Error | undefined,
message: any,
timings: Timing,
) => void;
};
cancels: { [id: number]: () => void };
dest: Worker;
timeoutMs: number;
constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {
this.callbacks = {};
this.cancels = {};
this.dest = dest;
this.timeoutMs = timeoutMs;
this.dest.onmessage = async ({ data }) => {
const message: Message = data;
if (message.type === "cancel") {
const cancel = this.cancels[message.id];
delete this.cancels[message.id];
if (cancel) {
cancel();
}
} else if (message.type === "response") {
const callback = this.callbacks[message.id];
delete this.callbacks[message.id];
if (callback) {
callback(
message.error ? new Error(message.error) : undefined,
message.response,
message.timings,
);
}
} else if (message.type === "request") {
const timer = new Timer("worker");
const handler: Function = (dispatcher as any)[message.name];
const request = handler.apply(handler, [...message.args, timer]);
const url = `${message.name}_${message.id}`;
if (message.id && request) {
this.cancels[message.id] = request.cancel;
try {
const response = await request.value;
const transferrables = (response as IsTransferrable)
?.transferrables;
this.postMessage(
{
id: message.id,
type: "response",
response,
timings: timer.finish(url),
},
transferrables,
);
} catch (e: any) {
this.postMessage({
id: message.id,
type: "response",
error: e?.toString() || "error",
timings: timer.finish(url),
});
}
delete this.cancels[message.id];
}
}
};
}
postMessage(message: Message, transferrables?: Transferable[]) {
this.dest.postMessage(message, transferrables || []);
}
/** Invokes a method by name with a set of arguments in the remote context. */
send<
R,
M extends MethodsReturning<T, CancelablePromise<R>>,
K extends keyof M & string,
P extends Parameters<M[K]>,
>(
name: K,
transferrables: Transferable[],
timer?: Timer,
...args: P
): CancelablePromise<R> {
const thisId = ++id;
const value: Promise<R> = new Promise((resolve, reject) => {
this.postMessage(
{ id: thisId, type: "request", name, args },
transferrables,
);
this.callbacks[thisId] = (error, result, timings) => {
timer | ?.addAll(timings); |
if (error) reject(error);
else resolve(result);
};
});
return withTimeout(this.timeoutMs, {
value,
cancel: () => {
delete this.callbacks[thisId];
this.postMessage({ id: thisId, type: "cancel" });
},
});
}
}
| src/actor.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " };\n };\n remoteFail = (): CancelablePromise<number> => ({\n cancel() {},\n value: Promise.reject(new Error(\"error\")),\n });\n remoteNever = (): CancelablePromise<number> => ({\n cancel: () => {\n this.canceled = true;\n },",
"score": 22.194274780199148
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " fetchTile = (url: string): void => {\n if (this.fetched.indexOf(url) < 0) {\n this.fetched.push(url);\n }\n };\n addAll = (timings: Timing) => {\n this.tilesFetched += timings.tilesUsed;\n const offset = timings.origin - this.timeOrigin;\n for (const category in timings.marks) {\n const key = category as TimingCategory;",
"score": 22.19225390246819
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": "});\ntest(\"withTimeout - reject cancels timer\", async () => {\n const cancel = jest.fn();\n const error = new Error(\"rejected\");\n const result = withTimeout(1000, {\n value: Promise.reject(error),\n cancel,\n });\n await expect(result.value).rejects.toBe(error);\n jest.advanceTimersByTime(10_000);",
"score": 21.43001321377728
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " managers: { [id: number]: LocalDemManager } = {};\n init = (message: InitMessage): CancelablePromise<void> => {\n this.managers[message.managerId] = new LocalDemManager(\n message.demUrlPattern,\n message.cacheSize,\n message.encoding,\n message.maxzoom,\n message.timeoutMs,\n );\n return { cancel() {}, value: Promise.resolve() };",
"score": 20.628608272475024
},
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " const result = cache.getCancelable(1, () => ({\n value: new Promise((_, rej) => {\n reject = rej;\n }),\n cancel: () => {\n throw new Error();\n },\n }));\n const error = new Error();\n reject(error);",
"score": 20.604559847140848
}
] | typescript | ?.addAll(timings); |
import AsyncCache from "./cache";
import decodeImage from "./decode-image";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
import { encodeIndividualOptions, withTimeout } from "./utils";
import {
CancelablePromise,
ContourTile,
DemTile,
Encoding,
FetchResponse,
IndividualContourTileOptions,
} from "./types";
import encodeVectorTile, { GeomType } from "./vtpbf";
import { Timer } from "./performance";
/**
* Holds cached tile state, and exposes `fetchContourTile` which fetches the necessary
* tiles and returns an encoded contour vector tiles.
*/
export interface DemManager {
loaded: Promise<any>;
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse>;
fetchAndParseTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile>;
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile>;
}
/**
* Caches, decodes, and processes raster tiles in the current thread.
*/
export class LocalDemManager implements DemManager {
| tileCache: AsyncCache<string, FetchResponse>; |
parsedCache: AsyncCache<string, DemTile>;
contourCache: AsyncCache<string, ContourTile>;
demUrlPattern: string;
encoding: Encoding;
maxzoom: number;
timeoutMs: number;
loaded = Promise.resolve();
decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =
decodeImage;
constructor(
demUrlPattern: string,
cacheSize: number,
encoding: Encoding,
maxzoom: number,
timeoutMs: number,
) {
this.tileCache = new AsyncCache(cacheSize);
this.parsedCache = new AsyncCache(cacheSize);
this.contourCache = new AsyncCache(cacheSize);
this.timeoutMs = timeoutMs;
this.demUrlPattern = demUrlPattern;
this.encoding = encoding;
this.maxzoom = maxzoom;
}
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> {
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.tileCache.getCancelable(url, () => {
let cancel = () => {};
const options: RequestInit = {};
try {
const controller = new AbortController();
options.signal = controller.signal;
cancel = () => controller.abort();
} catch (e) {
// ignore
}
timer?.fetchTile(url);
const mark = timer?.marker("fetch");
return withTimeout(this.timeoutMs, {
value: fetch(url, options).then(async (response) => {
mark?.();
if (!response.ok) {
throw new Error(`Bad response: ${response.status} for ${url}`);
}
return {
data: await response.blob(),
expires: response.headers.get("expires") || undefined,
cacheControl: response.headers.get("cache-control") || undefined,
};
}),
cancel,
});
});
}
fetchAndParseTile = (
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile> => {
const self = this;
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.parsedCache.getCancelable(url, () => {
const tile = self.fetchTile(z, x, y, timer);
let canceled = false;
let alsoCancel = () => {};
return {
value: tile.value.then(async (response) => {
if (canceled) throw new Error("canceled");
const result = self.decodeImage(response.data, self.encoding);
alsoCancel = result.cancel;
const mark = timer?.marker("decode");
const value = await result.value;
mark?.();
return value;
}),
cancel: () => {
canceled = true;
alsoCancel();
tile.cancel();
},
};
});
};
fetchDem(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<HeightTile> {
const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
const subZ = z - zoom;
const div = 1 << subZ;
const newX = Math.floor(x / div);
const newY = Math.floor(y / div);
const { value, cancel } = this.fetchAndParseTile(zoom, newX, newY, timer);
const subX = x % div;
const subY = y % div;
return {
value: value.then((tile) =>
HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
};
}
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> {
const {
levels,
multiplier = 1,
buffer = 1,
extent = 4096,
contourLayer = "contours",
elevationKey = "ele",
levelKey = "level",
subsampleBelow = 100,
} = options;
// no levels means less than min zoom with levels specified
if (!levels || levels.length === 0) {
return {
cancel() {},
value: Promise.resolve({ arrayBuffer: new ArrayBuffer(0) }),
};
}
const key = [z, x, y, encodeIndividualOptions(options)].join("/");
return this.contourCache.getCancelable(key, () => {
const max = 1 << z;
let canceled = false;
const neighborPromises: (CancelablePromise<HeightTile> | null)[] = [];
for (let iy = y - 1; iy <= y + 1; iy++) {
for (let ix = x - 1; ix <= x + 1; ix++) {
neighborPromises.push(
iy < 0 || iy >= max
? null
: this.fetchDem(z, (ix + max) % max, iy, options, timer),
);
}
}
const value = Promise.all(neighborPromises.map((n) => n?.value)).then(
async (neighbors) => {
let virtualTile = HeightTile.combineNeighbors(neighbors);
if (!virtualTile || canceled) {
return { arrayBuffer: new Uint8Array().buffer };
}
const mark = timer?.marker("isoline");
if (virtualTile.width >= subsampleBelow) {
virtualTile = virtualTile.materialize(2);
} else {
while (virtualTile.width < subsampleBelow) {
virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
}
}
virtualTile = virtualTile
.averagePixelCentersToGrid()
.scaleElevation(multiplier)
.materialize(1);
const isolines = generateIsolines(
levels[0],
virtualTile,
extent,
buffer,
);
mark?.();
const result = encodeVectorTile({
extent,
layers: {
[contourLayer]: {
features: Object.entries(isolines).map(([eleString, geom]) => {
const ele = Number(eleString);
return {
type: GeomType.LINESTRING,
geometry: geom,
properties: {
[elevationKey]: ele,
[levelKey]: Math.max(
...levels.map((l, i) => (ele % l === 0 ? i : 0)),
),
},
};
}),
},
},
});
mark?.();
return { arrayBuffer: result.buffer };
},
);
return {
value,
cancel() {
canceled = true;
neighborPromises.forEach((n) => n && n.cancel());
},
};
});
}
}
| src/dem-manager.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " * Caches, decodes, and processes raster tiles in a shared web worker.\n */\nexport default class RemoteDemManager implements DemManager {\n managerId: number;\n actor: Actor<WorkerDispatch>;\n loaded: Promise<any>;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,",
"score": 44.53610146127108
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " z: number,\n x: number,\n y: number,\n options: IndividualContourTileOptions,\n timer?: Timer,\n ): CancelablePromise<ContourTile> =>\n this.actor.send(\n \"fetchContourTile\",\n [],\n timer,",
"score": 26.375330567561946
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " );\n fetchContourTile = (\n managerId: number,\n z: number,\n x: number,\n y: number,\n options: IndividualContourTileOptions,\n timer?: Timer,\n ): CancelablePromise<ContourTile> =>\n prepareContourTile(",
"score": 25.955705928101118
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": "import { LocalDemManager } from \"./dem-manager\";\nimport { Timer } from \"./performance\";\nimport {\n CancelablePromise,\n ContourTile,\n FetchResponse,\n IndividualContourTileOptions,\n InitMessage,\n TransferrableDemTile,\n} from \"./types\";",
"score": 23.907622971786076
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " for (const list of input) {\n result.push(...list);\n }\n return result;\n}\n/** Utility for tracking how long tiles take to generate, and where the time is going. */\nexport class Timer {\n marks: { [key in TimingCategory]?: number[][] } = {};\n urls: string[] = [];\n fetched: string[] = [];",
"score": 19.95905178038667
}
] | typescript | tileCache: AsyncCache<string, FetchResponse>; |
import AsyncCache from "./cache";
import decodeImage from "./decode-image";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
import { encodeIndividualOptions, withTimeout } from "./utils";
import {
CancelablePromise,
ContourTile,
DemTile,
Encoding,
FetchResponse,
IndividualContourTileOptions,
} from "./types";
import encodeVectorTile, { GeomType } from "./vtpbf";
import { Timer } from "./performance";
/**
* Holds cached tile state, and exposes `fetchContourTile` which fetches the necessary
* tiles and returns an encoded contour vector tiles.
*/
export interface DemManager {
loaded: Promise<any>;
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse>;
fetchAndParseTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile>;
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile>;
}
/**
* Caches, decodes, and processes raster tiles in the current thread.
*/
export class LocalDemManager implements DemManager {
tileCache: AsyncCache<string, FetchResponse>;
parsedCache: AsyncCache<string, DemTile>;
contourCache: AsyncCache<string, ContourTile>;
demUrlPattern: string;
encoding: Encoding;
maxzoom: number;
timeoutMs: number;
loaded = Promise.resolve();
decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =
decodeImage;
constructor(
demUrlPattern: string,
cacheSize: number,
encoding: Encoding,
maxzoom: number,
timeoutMs: number,
) {
this.tileCache = new AsyncCache(cacheSize);
this.parsedCache = new AsyncCache(cacheSize);
this.contourCache = new AsyncCache(cacheSize);
this.timeoutMs = timeoutMs;
this.demUrlPattern = demUrlPattern;
this.encoding = encoding;
this.maxzoom = maxzoom;
}
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> {
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.tileCache.getCancelable(url, () => {
let cancel = () => {};
const options: RequestInit = {};
try {
const controller = new AbortController();
options.signal = controller.signal;
cancel = () => controller.abort();
} catch (e) {
// ignore
}
timer?.fetchTile(url);
const mark = timer?.marker("fetch");
return withTimeout(this.timeoutMs, {
value: fetch(url, options).then(async (response) => {
mark?.();
if (!response.ok) {
throw new Error(`Bad response: ${response.status} for ${url}`);
}
return {
data: await response.blob(),
expires: response.headers.get("expires") || undefined,
cacheControl: response.headers.get("cache-control") || undefined,
};
}),
cancel,
});
});
}
fetchAndParseTile = (
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile> => {
const self = this;
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.parsedCache.getCancelable(url, () => {
const tile = self.fetchTile(z, x, y, timer);
let canceled = false;
let alsoCancel = () => {};
return {
value: tile.value.then(async (response) => {
if (canceled) throw new Error("canceled");
const result = self.decodeImage(response.data, self.encoding);
alsoCancel = result.cancel;
const mark = timer?.marker("decode");
const value = await result.value;
mark?.();
return value;
}),
cancel: () => {
canceled = true;
alsoCancel();
tile.cancel();
},
};
});
};
fetchDem(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<HeightTile> {
const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
const subZ = z - zoom;
const div = 1 << subZ;
const newX = Math.floor(x / div);
const newY = Math.floor(y / div);
const { value, cancel } = this.fetchAndParseTile(zoom, newX, newY, timer);
const subX = x % div;
const subY = y % div;
return {
value: value.then((tile) =>
HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
};
}
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> {
const {
levels,
multiplier = 1,
buffer = 1,
extent = 4096,
contourLayer = "contours",
elevationKey = "ele",
levelKey = "level",
subsampleBelow = 100,
} = options;
// no levels means less than min zoom with levels specified
if (!levels || levels.length === 0) {
return {
cancel() {},
value: Promise.resolve({ arrayBuffer: new ArrayBuffer(0) }),
};
}
| const key = [z, x, y, encodeIndividualOptions(options)].join("/"); |
return this.contourCache.getCancelable(key, () => {
const max = 1 << z;
let canceled = false;
const neighborPromises: (CancelablePromise<HeightTile> | null)[] = [];
for (let iy = y - 1; iy <= y + 1; iy++) {
for (let ix = x - 1; ix <= x + 1; ix++) {
neighborPromises.push(
iy < 0 || iy >= max
? null
: this.fetchDem(z, (ix + max) % max, iy, options, timer),
);
}
}
const value = Promise.all(neighborPromises.map((n) => n?.value)).then(
async (neighbors) => {
let virtualTile = HeightTile.combineNeighbors(neighbors);
if (!virtualTile || canceled) {
return { arrayBuffer: new Uint8Array().buffer };
}
const mark = timer?.marker("isoline");
if (virtualTile.width >= subsampleBelow) {
virtualTile = virtualTile.materialize(2);
} else {
while (virtualTile.width < subsampleBelow) {
virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
}
}
virtualTile = virtualTile
.averagePixelCentersToGrid()
.scaleElevation(multiplier)
.materialize(1);
const isolines = generateIsolines(
levels[0],
virtualTile,
extent,
buffer,
);
mark?.();
const result = encodeVectorTile({
extent,
layers: {
[contourLayer]: {
features: Object.entries(isolines).map(([eleString, geom]) => {
const ele = Number(eleString);
return {
type: GeomType.LINESTRING,
geometry: geom,
properties: {
[elevationKey]: ele,
[levelKey]: Math.max(
...levels.map((l, i) => (ele % l === 0 ? i : 0)),
),
},
};
}),
},
},
});
mark?.();
return { arrayBuffer: result.buffer };
},
);
return {
value,
cancel() {
canceled = true;
neighborPromises.forEach((n) => n && n.cancel());
},
};
});
}
}
| src/dem-manager.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " ...rest,\n levels: [100, 1000],\n });\n expect(getOptionsForZoom(fullGlobalOptions, 12)).toEqual({\n ...rest,\n levels: [100, 1000],\n });\n});\ntest(\"encode individual options\", () => {\n const options: IndividualContourTileOptions = {",
"score": 37.49260973891219
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " return sortedEntries(options)\n .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)\n .join(\",\");\n}\nexport function getOptionsForZoom(\n options: GlobalContourTileOptions,\n zoom: number,\n): IndividualContourTileOptions {\n const { thresholds, ...rest } = options;\n let levels: number[] = [];",
"score": 35.49284142902849
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " let maxLessThanOrEqualTo: number = -Infinity;\n Object.entries(thresholds).forEach(([zString, value]) => {\n const z = Number(zString);\n if (z <= zoom && z > maxLessThanOrEqualTo) {\n maxLessThanOrEqualTo = z;\n levels = typeof value === \"number\" ? [value] : value;\n }\n });\n return {\n levels,",
"score": 34.36142284943975
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " levels: [1, 2],\n contourLayer: \"contour layer\",\n elevationKey: \"elevation key\",\n extent: 123,\n levelKey: \"level key\",\n multiplier: 123,\n overzoom: 3,\n };\n const origEncoded = encodeIndividualOptions(options);\n expect(encodeIndividualOptions(options)).toBe(origEncoded);",
"score": 33.452129477287116
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " const options: GlobalContourTileOptions = {\n thresholds: {\n 10: [500],\n 11: [100, 1000],\n },\n };\n expect(decodeOptions(encodeOptions(options))).toEqual(options);\n});\ntest(\"extract levels from global contour options\", () => {\n // eslint-disable-next-line",
"score": 29.855842120127534
}
] | typescript | const key = [z, x, y, encodeIndividualOptions(options)].join("/"); |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][][]): HeightTile {
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
return HeightTile.fromRawDem({
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
const size = heightTile.width;
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile.height,
(x, y) => {
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
| const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0); |
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
rotatedResult[ele] = isolines[ele].map((eles) => {
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " }\n const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };\n expect(center).toMatchObject({\n x: 2049,\n y: 2052,\n });\n expect(timings).toMatchObject([\n {\n tilesUsed: 9,\n process: 0,",
"score": 34.89646033343114
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " if (!mainTile) {\n return undefined;\n }\n const width = mainTile.width;\n const height = mainTile.height;\n return new HeightTile(width, height, (x, y) => {\n let gridIdx = 0;\n if (y < 0) {\n y += height;\n } else if (y < height) {",
"score": 25.204219889837837
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " this.start = start;\n this.end = end;\n this.points = [];\n this.append = this.append.bind(this);\n this.prepend = this.prepend.bind(this);\n }\n append(x: number, y: number) {\n this.points.push(Math.round(x), Math.round(y));\n }\n prepend(x: number, y: number) {",
"score": 22.776454527494412
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": "export default function generateIsolines(\n interval: number,\n tile: HeightTile,\n extent: number = 4096,\n buffer: number = 1,\n): { [ele: number]: number[][] } {\n if (!interval) {\n return {};\n }\n const multiplier = extent / (tile.width - 1);",
"score": 22.458497195387714
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " [],\n];\nfunction index(width: number, x: number, y: number, point: [number, number]) {\n x = x * 2 + point[0];\n y = y * 2 + point[1];\n return x + y * (width + 1) * 2;\n}\nfunction ratio(a: number, b: number, c: number) {\n return (b - a) / (c - a);\n}",
"score": 22.354495151736202
}
] | typescript | const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0); |
import Actor from "./actor";
import { Timer } from "./performance";
import { CancelablePromise } from "./types";
class Local {
received: any[][] = [];
localAction = (x: number, y: number, z: number): CancelablePromise<void> => {
this.received.push([x, y, z]);
return { cancel() {}, value: Promise.resolve() };
};
}
class Remote {
received: any[][] = [];
canceled = false;
remoteAction = (x: number, y: number, z: number): CancelablePromise<void> => {
this.received.push([x, y, z]);
return { cancel() {}, value: Promise.resolve() };
};
remotePromise = (x: number, timer?: Timer): CancelablePromise<number> => {
const oldNow = performance.now;
if (timer) timer.timeOrigin = 100;
performance.now = () => oldNow() - 100;
const finish = timer?.marker("fetch");
performance.now = () => oldNow() - 99;
finish?.();
performance.now = () => oldNow() + 2;
return {
cancel() {
throw new Error("not expected");
},
value: Promise.resolve(x),
};
};
remoteFail = (): CancelablePromise<number> => ({
cancel() {},
value: Promise.reject(new Error("error")),
});
remoteNever = (): CancelablePromise<number> => ({
cancel: () => {
this.canceled = true;
},
value: new Promise(() => {}),
});
}
test("send and cancel messages", async () => {
performance.now = () => 1;
const remote = new Remote();
const local = new Local();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
//@ts-ignore
mainThreadFromWorker?.onmessage?.({ data });
mainThreadFromWorker.postMessage = (data) =>
//@ts-ignore
workerFromMainThread?.onmessage?.({ data });
const mainActor | = new Actor<Remote>(workerFromMainThread, local); |
const workerActor = new Actor<Local>(mainThreadFromWorker, remote);
mainActor.send("remoteAction", [], undefined, 1, 2, 3);
expect(remote.received).toEqual([[1, 2, 3]]);
workerActor.send("localAction", [], undefined, 4, 3, 2);
expect(local.received).toEqual([[4, 3, 2]]);
const timer = new Timer("main");
timer.timeOrigin = 0;
expect(await mainActor.send("remotePromise", [], timer, 9).value).toBe(9);
expect(timer.finish("url")).toMatchObject({
duration: 2,
fetch: 1,
marks: {
fetch: [[1, 2]],
main: [[1, 3]],
},
});
const { cancel } = mainActor.send("remoteNever", []);
expect(remote.canceled).toBeFalsy();
cancel();
expect(remote.canceled).toBeTruthy();
await expect(mainActor.send("remoteFail", []).value).rejects.toThrowError(
"Error: error",
);
});
| src/actor.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " return { value: Promise.resolve(value), cancel() {} };\n});\nconst remote = new WorkerDispatch();\nconst local = new MainThreadDispatch();\nconst workerFromMainThread: Worker = {} as any as Worker;\nconst mainThreadFromWorker: Worker = {} as any as Worker;\nworkerFromMainThread.postMessage = (data) =>\n mainThreadFromWorker?.onmessage?.({ data } as any);\nmainThreadFromWorker.postMessage = (data) =>\n workerFromMainThread?.onmessage?.({ data } as any);",
"score": 148.64943622344884
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": "const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);\nconst workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);\nconst source = new DemSource({\n url: \"https://example/{z}/{x}/{y}.png\",\n cacheSize: 100,\n encoding: \"terrarium\",\n maxzoom: 11,\n worker: true,\n actor: mainActor,\n});",
"score": 50.44639887570156
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {\n this.callbacks = {};\n this.cancels = {};\n this.dest = dest;\n this.timeoutMs = timeoutMs;\n this.dest.onmessage = async ({ data }) => {\n const message: Message = data;\n if (message.type === \"cancel\") {\n const cancel = this.cancels[message.id];\n delete this.cancels[message.id];",
"score": 38.33770701526221
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " return result as any as PerformanceResourceTiming;\n}",
"score": 27.860195862146018
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": "}\nfunction defaultActor(): Actor<WorkerDispatch> {\n if (!_actor) {\n const worker = new Worker(CONFIG.workerUrl);\n const dispatch = new MainThreadDispatch();\n _actor = new Actor(worker, dispatch);\n }\n return _actor;\n}\n/**",
"score": 26.765345717341887
}
] | typescript | = new Actor<Remote>(workerFromMainThread, local); |
/* eslint-disable no-restricted-globals */
import type Actor from "./actor";
import { offscreenCanvasSupported } from "./utils";
import type { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Encoding } from "./types";
let offscreenCanvas: OffscreenCanvas;
let offscreenContext: OffscreenCanvasRenderingContext2D | null;
let canvas: HTMLCanvasElement;
let canvasContext: CanvasRenderingContext2D | null;
/**
* Parses a `raster-dem` image into a DemTile using OffscreenCanvas and createImageBitmap
* only supported on newer browsers.
*/
function decodeImageModern(
blob: Blob,
encoding: Encoding,
): CancelablePromise<DemTile> {
let canceled = false;
const promise = createImageBitmap(blob).then((img) => {
if (canceled) return null as any as DemTile;
if (!offscreenCanvas) {
offscreenCanvas = new OffscreenCanvas(img.width, img.height);
offscreenContext = offscreenCanvas.getContext("2d", {
willReadFrequently: true,
}) as OffscreenCanvasRenderingContext2D;
}
return getElevations(img, encoding, offscreenCanvas, offscreenContext);
});
return {
value: promise,
cancel: () => {
canceled = true;
},
};
}
/**
* Parses a `raster-dem` image into a DemTile using `<img>` element drawn to a `<canvas>`.
* Only works on the main thread, but works across all browsers.
*/
function decodeImageOld(
blob: Blob,
encoding: Encoding,
): CancelablePromise<DemTile> {
if (!canvas) {
canvas = document.createElement("canvas");
canvasContext = canvas.getContext("2d", {
willReadFrequently: true,
}) as CanvasRenderingContext2D;
}
let canceled = false;
const img: HTMLImageElement = new Image();
const value = new Promise<HTMLImageElement>((resolve, reject) => {
img.onload = () => {
if (!canceled) resolve(img);
URL.revokeObjectURL(img.src);
img.onload = null;
};
img.onerror = () => reject(new Error("Could not load image."));
img.src = blob.size ? URL.createObjectURL(blob) : "";
}).then((img: HTMLImageElement) =>
getElevations(img, encoding, canvas, canvasContext),
);
return {
value,
cancel: () => {
canceled = true;
img.src = "";
},
};
}
/**
* Parses a `raster-dem` image in a worker that doesn't support OffscreenCanvas and createImageBitmap
* by running decodeImageOld on the main thread and returning the result.
*/
function decodeImageOnMainThread(
blob: Blob,
encoding: Encoding,
): CancelablePromise<DemTile> {
return ((self as any).actor as Actor<MainThreadDispatch>).send(
"decodeImage",
[],
undefined,
blob,
encoding,
);
}
function isWorker(): boolean {
return (
// @ts-ignore
typeof WorkerGlobalScope !== "undefined" &&
typeof self !== "undefined" &&
// @ts-ignore
self instanceof WorkerGlobalScope
);
}
const defaultDecoder: (
blob: Blob,
encoding: Encoding,
| ) => CancelablePromise<DemTile> = offscreenCanvasSupported()
? decodeImageModern
: isWorker()
? decodeImageOnMainThread
: decodeImageOld; |
export default defaultDecoder;
function getElevations(
img: ImageBitmap | HTMLImageElement,
encoding: Encoding,
canvas: HTMLCanvasElement | OffscreenCanvas,
canvasContext:
| CanvasRenderingContext2D
| OffscreenCanvasRenderingContext2D
| null,
): DemTile {
canvas.width = img.width;
canvas.height = img.height;
if (!canvasContext) throw new Error("failed to get context");
canvasContext.drawImage(img, 0, 0, img.width, img.height);
const rgba = canvasContext.getImageData(0, 0, img.width, img.height).data;
return decodeParsedImage(img.width, img.height, encoding, rgba);
}
export function decodeParsedImage(
width: number,
height: number,
encoding: Encoding,
input: Uint8ClampedArray,
): DemTile {
const decoder: (r: number, g: number, b: number) => number =
encoding === "mapbox"
? (r, g, b) => -10000 + (r * 256 * 256 + g * 256 + b) * 0.1
: (r, g, b) => r * 256 + g + b / 256 - 32768;
const data = new Float32Array(width * height);
for (let i = 0; i < input.length; i += 4) {
data[i / 4] = decoder(input[i], input[i + 1], input[i + 2]);
}
return { width, height, data };
}
| src/decode-image.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " maxzoom: number;\n timeoutMs: number;\n loaded = Promise.resolve();\n decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =\n decodeImage;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,\n maxzoom: number,",
"score": 24.61015071269138
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " Encoding,\n FetchResponse,\n IndividualContourTileOptions,\n} from \"./types\";\nimport { prepareDemTile } from \"./utils\";\nlet _actor: Actor<WorkerDispatch> | undefined;\nlet id = 0;\nexport class MainThreadDispatch {\n decodeImage = (blob: Blob, encoding: Encoding) =>\n prepareDemTile(decodeImage(blob, encoding), false);",
"score": 19.7318626804305
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": "}\n/**\n * Caches, decodes, and processes raster tiles in the current thread.\n */\nexport class LocalDemManager implements DemManager {\n tileCache: AsyncCache<string, FetchResponse>;\n parsedCache: AsyncCache<string, DemTile>;\n contourCache: AsyncCache<string, ContourTile>;\n demUrlPattern: string;\n encoding: Encoding;",
"score": 9.444821752247393
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": "import AsyncCache from \"./cache\";\nimport decodeImage from \"./decode-image\";\nimport { HeightTile } from \"./height-tile\";\nimport generateIsolines from \"./isolines\";\nimport { encodeIndividualOptions, withTimeout } from \"./utils\";\nimport {\n CancelablePromise,\n ContourTile,\n DemTile,\n Encoding,",
"score": 8.817294369331801
},
{
"filename": "src/types.ts",
"retrieved_chunk": " managerId: number;\n demUrlPattern: string;\n cacheSize: number;\n encoding: Encoding;\n maxzoom: number;\n timeoutMs: number;\n}\nexport type TimingCategory = \"main\" | \"worker\" | \"fetch\" | \"decode\" | \"isoline\";\n/** Performance profile for a tile request */\nexport interface Timing {",
"score": 6.8813657826643055
}
] | typescript | ) => CancelablePromise<DemTile> = offscreenCanvasSupported()
? decodeImageModern
: isWorker()
? decodeImageOnMainThread
: decodeImageOld; |
import AsyncCache from "./cache";
import decodeImage from "./decode-image";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
import { encodeIndividualOptions, withTimeout } from "./utils";
import {
CancelablePromise,
ContourTile,
DemTile,
Encoding,
FetchResponse,
IndividualContourTileOptions,
} from "./types";
import encodeVectorTile, { GeomType } from "./vtpbf";
import { Timer } from "./performance";
/**
* Holds cached tile state, and exposes `fetchContourTile` which fetches the necessary
* tiles and returns an encoded contour vector tiles.
*/
export interface DemManager {
loaded: Promise<any>;
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse>;
fetchAndParseTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile>;
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile>;
}
/**
* Caches, decodes, and processes raster tiles in the current thread.
*/
export class LocalDemManager implements DemManager {
tileCache: AsyncCache<string, FetchResponse>;
parsedCache: AsyncCache<string, DemTile>;
contourCache: AsyncCache<string, ContourTile>;
demUrlPattern: string;
encoding: Encoding;
maxzoom: number;
timeoutMs: number;
loaded = Promise.resolve();
decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =
decodeImage;
constructor(
demUrlPattern: string,
cacheSize: number,
encoding: Encoding,
maxzoom: number,
timeoutMs: number,
) {
this.tileCache = new AsyncCache(cacheSize);
this.parsedCache = new AsyncCache(cacheSize);
this.contourCache = new AsyncCache(cacheSize);
this.timeoutMs = timeoutMs;
this.demUrlPattern = demUrlPattern;
this.encoding = encoding;
this.maxzoom = maxzoom;
}
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> {
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.tileCache.getCancelable(url, () => {
let cancel = () => {};
const options: RequestInit = {};
try {
const controller = new AbortController();
options.signal = controller.signal;
cancel = () => controller.abort();
} catch (e) {
// ignore
}
timer?. | fetchTile(url); |
const mark = timer?.marker("fetch");
return withTimeout(this.timeoutMs, {
value: fetch(url, options).then(async (response) => {
mark?.();
if (!response.ok) {
throw new Error(`Bad response: ${response.status} for ${url}`);
}
return {
data: await response.blob(),
expires: response.headers.get("expires") || undefined,
cacheControl: response.headers.get("cache-control") || undefined,
};
}),
cancel,
});
});
}
fetchAndParseTile = (
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile> => {
const self = this;
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.parsedCache.getCancelable(url, () => {
const tile = self.fetchTile(z, x, y, timer);
let canceled = false;
let alsoCancel = () => {};
return {
value: tile.value.then(async (response) => {
if (canceled) throw new Error("canceled");
const result = self.decodeImage(response.data, self.encoding);
alsoCancel = result.cancel;
const mark = timer?.marker("decode");
const value = await result.value;
mark?.();
return value;
}),
cancel: () => {
canceled = true;
alsoCancel();
tile.cancel();
},
};
});
};
fetchDem(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<HeightTile> {
const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
const subZ = z - zoom;
const div = 1 << subZ;
const newX = Math.floor(x / div);
const newY = Math.floor(y / div);
const { value, cancel } = this.fetchAndParseTile(zoom, newX, newY, timer);
const subX = x % div;
const subY = y % div;
return {
value: value.then((tile) =>
HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
};
}
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> {
const {
levels,
multiplier = 1,
buffer = 1,
extent = 4096,
contourLayer = "contours",
elevationKey = "ele",
levelKey = "level",
subsampleBelow = 100,
} = options;
// no levels means less than min zoom with levels specified
if (!levels || levels.length === 0) {
return {
cancel() {},
value: Promise.resolve({ arrayBuffer: new ArrayBuffer(0) }),
};
}
const key = [z, x, y, encodeIndividualOptions(options)].join("/");
return this.contourCache.getCancelable(key, () => {
const max = 1 << z;
let canceled = false;
const neighborPromises: (CancelablePromise<HeightTile> | null)[] = [];
for (let iy = y - 1; iy <= y + 1; iy++) {
for (let ix = x - 1; ix <= x + 1; ix++) {
neighborPromises.push(
iy < 0 || iy >= max
? null
: this.fetchDem(z, (ix + max) % max, iy, options, timer),
);
}
}
const value = Promise.all(neighborPromises.map((n) => n?.value)).then(
async (neighbors) => {
let virtualTile = HeightTile.combineNeighbors(neighbors);
if (!virtualTile || canceled) {
return { arrayBuffer: new Uint8Array().buffer };
}
const mark = timer?.marker("isoline");
if (virtualTile.width >= subsampleBelow) {
virtualTile = virtualTile.materialize(2);
} else {
while (virtualTile.width < subsampleBelow) {
virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
}
}
virtualTile = virtualTile
.averagePixelCentersToGrid()
.scaleElevation(multiplier)
.materialize(1);
const isolines = generateIsolines(
levels[0],
virtualTile,
extent,
buffer,
);
mark?.();
const result = encodeVectorTile({
extent,
layers: {
[contourLayer]: {
features: Object.entries(isolines).map(([eleString, geom]) => {
const ele = Number(eleString);
return {
type: GeomType.LINESTRING,
geometry: geom,
properties: {
[elevationKey]: ele,
[levelKey]: Math.max(
...levels.map((l, i) => (ele % l === 0 ? i : 0)),
),
},
};
}),
},
},
});
mark?.();
return { arrayBuffer: result.buffer };
},
);
return {
value,
cancel() {
canceled = true;
neighborPromises.forEach((n) => n && n.cancel());
},
};
});
}
}
| src/dem-manager.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/actor.ts",
"retrieved_chunk": " },\n transferrables,\n );\n } catch (e: any) {\n this.postMessage({\n id: message.id,\n type: \"response\",\n error: e?.toString() || \"error\",\n timings: timer.finish(url),\n });",
"score": 16.819716640255574
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " try {\n const data = await result.value;\n timing = timer.finish(request.url);\n if (canceled) return;\n response(undefined, data.arrayBuffer);\n } catch (error) {\n if (canceled) return;\n timing = timer.error(request.url);\n response(error as Error);\n }",
"score": 15.402119696399623
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " response: ResponseCallback,\n ): Cancelable => {\n const [z, x, y] = this.parseUrl(request.url);\n const timer = new Timer(\"main\");\n const result = this.manager.fetchTile(z, x, y, timer);\n let canceled = false;\n (async () => {\n let timing: Timing;\n try {\n const data = await result.value;",
"score": 14.296171213546083
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " * Callback to be used with maplibre addProtocol to generate contour vector tiles according\n * to options encoded in the tile URL pattern generated by `contourProtocolUrl`.\n */\n contourProtocol = (\n request: RequestParameters,\n response: ResponseCallback,\n ): Cancelable => {\n const timer = new Timer(\"main\");\n const [z, x, y] = this.parseUrl(request.url);\n const options = decodeOptions(request.url);",
"score": 13.246859929511105
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " this.managers[managerId]?.fetchContourTile(z, x, y, options, timer) ||\n noManager(managerId),\n );\n}",
"score": 11.660981866216474
}
] | typescript | fetchTile(url); |
import AsyncCache from "./cache";
import decodeImage from "./decode-image";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
import { encodeIndividualOptions, withTimeout } from "./utils";
import {
CancelablePromise,
ContourTile,
DemTile,
Encoding,
FetchResponse,
IndividualContourTileOptions,
} from "./types";
import encodeVectorTile, { GeomType } from "./vtpbf";
import { Timer } from "./performance";
/**
* Holds cached tile state, and exposes `fetchContourTile` which fetches the necessary
* tiles and returns an encoded contour vector tiles.
*/
export interface DemManager {
loaded: Promise<any>;
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse>;
fetchAndParseTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile>;
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile>;
}
/**
* Caches, decodes, and processes raster tiles in the current thread.
*/
export class LocalDemManager implements DemManager {
tileCache: AsyncCache<string, FetchResponse>;
parsedCache: AsyncCache<string, DemTile>;
contourCache: AsyncCache<string, ContourTile>;
demUrlPattern: string;
encoding: Encoding;
maxzoom: number;
timeoutMs: number;
loaded = Promise.resolve();
decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =
decodeImage;
constructor(
demUrlPattern: string,
cacheSize: number,
encoding: Encoding,
maxzoom: number,
timeoutMs: number,
) {
this.tileCache = new AsyncCache(cacheSize);
this.parsedCache = new AsyncCache(cacheSize);
this.contourCache = new AsyncCache(cacheSize);
this.timeoutMs = timeoutMs;
this.demUrlPattern = demUrlPattern;
this.encoding = encoding;
this.maxzoom = maxzoom;
}
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> {
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
| timer?.useTile(url); |
return this.tileCache.getCancelable(url, () => {
let cancel = () => {};
const options: RequestInit = {};
try {
const controller = new AbortController();
options.signal = controller.signal;
cancel = () => controller.abort();
} catch (e) {
// ignore
}
timer?.fetchTile(url);
const mark = timer?.marker("fetch");
return withTimeout(this.timeoutMs, {
value: fetch(url, options).then(async (response) => {
mark?.();
if (!response.ok) {
throw new Error(`Bad response: ${response.status} for ${url}`);
}
return {
data: await response.blob(),
expires: response.headers.get("expires") || undefined,
cacheControl: response.headers.get("cache-control") || undefined,
};
}),
cancel,
});
});
}
fetchAndParseTile = (
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile> => {
const self = this;
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.parsedCache.getCancelable(url, () => {
const tile = self.fetchTile(z, x, y, timer);
let canceled = false;
let alsoCancel = () => {};
return {
value: tile.value.then(async (response) => {
if (canceled) throw new Error("canceled");
const result = self.decodeImage(response.data, self.encoding);
alsoCancel = result.cancel;
const mark = timer?.marker("decode");
const value = await result.value;
mark?.();
return value;
}),
cancel: () => {
canceled = true;
alsoCancel();
tile.cancel();
},
};
});
};
fetchDem(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<HeightTile> {
const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
const subZ = z - zoom;
const div = 1 << subZ;
const newX = Math.floor(x / div);
const newY = Math.floor(y / div);
const { value, cancel } = this.fetchAndParseTile(zoom, newX, newY, timer);
const subX = x % div;
const subY = y % div;
return {
value: value.then((tile) =>
HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
};
}
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> {
const {
levels,
multiplier = 1,
buffer = 1,
extent = 4096,
contourLayer = "contours",
elevationKey = "ele",
levelKey = "level",
subsampleBelow = 100,
} = options;
// no levels means less than min zoom with levels specified
if (!levels || levels.length === 0) {
return {
cancel() {},
value: Promise.resolve({ arrayBuffer: new ArrayBuffer(0) }),
};
}
const key = [z, x, y, encodeIndividualOptions(options)].join("/");
return this.contourCache.getCancelable(key, () => {
const max = 1 << z;
let canceled = false;
const neighborPromises: (CancelablePromise<HeightTile> | null)[] = [];
for (let iy = y - 1; iy <= y + 1; iy++) {
for (let ix = x - 1; ix <= x + 1; ix++) {
neighborPromises.push(
iy < 0 || iy >= max
? null
: this.fetchDem(z, (ix + max) % max, iy, options, timer),
);
}
}
const value = Promise.all(neighborPromises.map((n) => n?.value)).then(
async (neighbors) => {
let virtualTile = HeightTile.combineNeighbors(neighbors);
if (!virtualTile || canceled) {
return { arrayBuffer: new Uint8Array().buffer };
}
const mark = timer?.marker("isoline");
if (virtualTile.width >= subsampleBelow) {
virtualTile = virtualTile.materialize(2);
} else {
while (virtualTile.width < subsampleBelow) {
virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
}
}
virtualTile = virtualTile
.averagePixelCentersToGrid()
.scaleElevation(multiplier)
.materialize(1);
const isolines = generateIsolines(
levels[0],
virtualTile,
extent,
buffer,
);
mark?.();
const result = encodeVectorTile({
extent,
layers: {
[contourLayer]: {
features: Object.entries(isolines).map(([eleString, geom]) => {
const ele = Number(eleString);
return {
type: GeomType.LINESTRING,
geometry: geom,
properties: {
[elevationKey]: ele,
[levelKey]: Math.max(
...levels.map((l, i) => (ele % l === 0 ? i : 0)),
),
},
};
}),
},
},
});
mark?.();
return { arrayBuffer: result.buffer };
},
);
return {
value,
cancel() {
canceled = true;
neighborPromises.forEach((n) => n && n.cancel());
},
};
});
}
}
| src/dem-manager.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " ): CancelablePromise<FetchResponse> =>\n this.actor.send(\"fetchTile\", [], timer, this.managerId, z, x, y);\n fetchAndParseTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> =>\n this.actor.send(\"fetchAndParseTile\", [], timer, this.managerId, z, x, y);\n fetchContourTile = (",
"score": 51.42372163045933
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " };\n fetchTile = (\n managerId: number,\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse> =>\n this.managers[managerId]?.fetchTile(z, x, y, timer) || noManager(managerId);\n fetchAndParseTile = (",
"score": 50.09597922775595
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " managerId: number,\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<TransferrableDemTile> =>\n prepareDemTile(\n this.managers[managerId]?.fetchAndParseTile(z, x, y, timer) ||\n noManager(managerId),\n true,",
"score": 45.71076272610547
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " thresholds: {\n 10: 10,\n },\n overzoom: 0,\n })\n .replace(\"{z}\", \"10\")\n .replace(\"{x}\", \"21\")\n .replace(\"{y}\", \"30\"),\n },\n (err, data) => {",
"score": 44.506304320574124
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " .replace(\"{z}\", \"1\")\n .replace(\"{x}\", \"2\")\n .replace(\"{y}\", \"3\"),\n },\n (err, data) => {\n if (err) reject(err);\n else resolve(data);\n },\n );\n });",
"score": 43.33816824496665
}
] | typescript | timer?.useTile(url); |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<( | timing: Timing) => void> = []; |
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": "}\n/**\n * Caches, decodes, and processes raster tiles in the current thread.\n */\nexport class LocalDemManager implements DemManager {\n tileCache: AsyncCache<string, FetchResponse>;\n parsedCache: AsyncCache<string, DemTile>;\n contourCache: AsyncCache<string, ContourTile>;\n demUrlPattern: string;\n encoding: Encoding;",
"score": 27.04897915718612
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " for (const list of input) {\n result.push(...list);\n }\n return result;\n}\n/** Utility for tracking how long tiles take to generate, and where the time is going. */\nexport class Timer {\n marks: { [key in TimingCategory]?: number[][] } = {};\n urls: string[] = [];\n fetched: string[] = [];",
"score": 22.708984239260108
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " * Caches, decodes, and processes raster tiles in a shared web worker.\n */\nexport default class RemoteDemManager implements DemManager {\n managerId: number;\n actor: Actor<WorkerDispatch>;\n loaded: Promise<any>;\n constructor(\n demUrlPattern: string,\n cacheSize: number,\n encoding: Encoding,",
"score": 20.185767723178415
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(tile.width).toBe(4);\n expect(tile.height).toBe(4);\n const tile2 = await source.getDemTile(1, 2, 3);\n expect(tile2.data).toEqual(expectedElevations);\n const timings: Timing[] = [];\n source.onTiming((timing) => timings.push(timing));\n const fetched = await new Promise((resolve, reject) => {\n source.sharedDemProtocol(\n {\n url: source.sharedDemProtocolUrl",
"score": 18.626070663848047
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " id: number;\n error?: string;\n response?: any;\n timings: Timing;\n}\ninterface Request {\n type: \"request\";\n id?: number;\n name: string;\n args: any[];",
"score": 17.051659054718975
}
] | typescript | timing: Timing) => void> = []; |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
| ) => Cancelable; |
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " data: await response.blob(),\n expires: response.headers.get(\"expires\") || undefined,\n cacheControl: response.headers.get(\"cache-control\") || undefined,\n };\n }),\n cancel,\n });\n });\n }\n fetchAndParseTile = (",
"score": 37.79778994698639
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " id: number;\n error?: string;\n response?: any;\n timings: Timing;\n}\ninterface Request {\n type: \"request\";\n id?: number;\n name: string;\n args: any[];",
"score": 27.80374600438082
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " if (cancel) {\n cancel();\n }\n } else if (message.type === \"response\") {\n const callback = this.callbacks[message.id];\n delete this.callbacks[message.id];\n if (callback) {\n callback(\n message.error ? new Error(message.error) : undefined,\n message.response,",
"score": 25.251068106261418
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " callbacks: {\n [id: number]: (\n error: Error | undefined,\n message: any,\n timings: Timing,\n ) => void;\n };\n cancels: { [id: number]: () => void };\n dest: Worker;\n timeoutMs: number;",
"score": 25.201639833936426
},
{
"filename": "src/types.ts",
"retrieved_chunk": " IsTransferrable {}\nexport interface Cancelable {\n cancel: () => void;\n}\nexport interface CancelablePromise<T> extends Cancelable {\n value: Promise<T>;\n}\nexport interface FetchResponse {\n data: Blob;\n expires?: string;",
"score": 24.100689897704868
}
] | typescript | ) => Cancelable; |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager. | fetchAndParseTile(z, x, y).value; |
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " ): CancelablePromise<FetchResponse> =>\n this.actor.send(\"fetchTile\", [], timer, this.managerId, z, x, y);\n fetchAndParseTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> =>\n this.actor.send(\"fetchAndParseTile\", [], timer, this.managerId, z, x, y);\n fetchContourTile = (",
"score": 38.711618501540286
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": "import Actor from \"./actor\";\nimport { Timer } from \"./performance\";\nimport { CancelablePromise } from \"./types\";\nclass Local {\n received: any[][] = [];\n localAction = (x: number, y: number, z: number): CancelablePromise<void> => {\n this.received.push([x, y, z]);\n return { cancel() {}, value: Promise.resolve() };\n };\n}",
"score": 36.72716056092847
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": "class Remote {\n received: any[][] = [];\n canceled = false;\n remoteAction = (x: number, y: number, z: number): CancelablePromise<void> => {\n this.received.push([x, y, z]);\n return { cancel() {}, value: Promise.resolve() };\n };\n remotePromise = (x: number, timer?: Timer): CancelablePromise<number> => {\n const oldNow = performance.now;\n if (timer) timer.timeOrigin = 100;",
"score": 33.2976580115959
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " if (cancel) {\n cancel();\n }\n } else if (message.type === \"response\") {\n const callback = this.callbacks[message.id];\n delete this.callbacks[message.id];\n if (callback) {\n callback(\n message.error ? new Error(message.error) : undefined,\n message.response,",
"score": 30.08983686372493
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> => {\n const self = this;\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 29.41139116850679
}
] | typescript | fetchAndParseTile(z, x, y).value; |
import AsyncCache from "./cache";
import decodeImage from "./decode-image";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
import { encodeIndividualOptions, withTimeout } from "./utils";
import {
CancelablePromise,
ContourTile,
DemTile,
Encoding,
FetchResponse,
IndividualContourTileOptions,
} from "./types";
import encodeVectorTile, { GeomType } from "./vtpbf";
import { Timer } from "./performance";
/**
* Holds cached tile state, and exposes `fetchContourTile` which fetches the necessary
* tiles and returns an encoded contour vector tiles.
*/
export interface DemManager {
loaded: Promise<any>;
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse>;
fetchAndParseTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile>;
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile>;
}
/**
* Caches, decodes, and processes raster tiles in the current thread.
*/
export class LocalDemManager implements DemManager {
tileCache: AsyncCache<string, FetchResponse>;
parsedCache: AsyncCache<string, DemTile>;
contourCache: AsyncCache<string, ContourTile>;
demUrlPattern: string;
encoding: Encoding;
maxzoom: number;
timeoutMs: number;
loaded = Promise.resolve();
decodeImage: (blob: Blob, encoding: Encoding) => CancelablePromise<DemTile> =
decodeImage;
constructor(
demUrlPattern: string,
cacheSize: number,
encoding: Encoding,
maxzoom: number,
timeoutMs: number,
) {
this.tileCache = new AsyncCache(cacheSize);
this.parsedCache = new AsyncCache(cacheSize);
this.contourCache = new AsyncCache(cacheSize);
this.timeoutMs = timeoutMs;
this.demUrlPattern = demUrlPattern;
this.encoding = encoding;
this.maxzoom = maxzoom;
}
fetchTile(
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> {
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.tileCache.getCancelable(url, () => {
let cancel = () => {};
const options: RequestInit = {};
try {
const controller = new AbortController();
options.signal = controller.signal;
cancel = () => controller.abort();
} catch (e) {
// ignore
}
timer?.fetchTile(url);
const mark = timer?.marker("fetch");
return withTimeout(this.timeoutMs, {
value: fetch(url, options).then(async (response) => {
mark?.();
if (!response.ok) {
throw new Error(`Bad response: ${response.status} for ${url}`);
}
return {
data: await response.blob(),
expires: response.headers.get("expires") || undefined,
cacheControl: response.headers.get("cache-control") || undefined,
};
}),
cancel,
});
});
}
fetchAndParseTile = (
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<DemTile> => {
const self = this;
const url = this.demUrlPattern
.replace("{z}", z.toString())
.replace("{x}", x.toString())
.replace("{y}", y.toString());
timer?.useTile(url);
return this.parsedCache.getCancelable(url, () => {
const tile = self.fetchTile(z, x, y, timer);
let canceled = false;
let alsoCancel = () => {};
return {
value: tile.value.then(async (response) => {
if (canceled) throw new Error("canceled");
const result = self.decodeImage(response.data, self.encoding);
alsoCancel = result.cancel;
const mark = timer?.marker("decode");
const value = await result.value;
mark?.();
return value;
}),
cancel: () => {
canceled = true;
alsoCancel();
tile.cancel();
},
};
});
};
fetchDem(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<HeightTile> {
const zoom = Math.min(z - (options.overzoom || 0), this.maxzoom);
const subZ = z - zoom;
const div = 1 << subZ;
const newX = Math.floor(x / div);
const newY = Math.floor(y / div);
const { value, cancel } = this.fetchAndParseTile(zoom, newX, newY, timer);
const subX = x % div;
const subY = y % div;
return {
value: value.then((tile) =>
| HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
}; |
}
fetchContourTile(
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> {
const {
levels,
multiplier = 1,
buffer = 1,
extent = 4096,
contourLayer = "contours",
elevationKey = "ele",
levelKey = "level",
subsampleBelow = 100,
} = options;
// no levels means less than min zoom with levels specified
if (!levels || levels.length === 0) {
return {
cancel() {},
value: Promise.resolve({ arrayBuffer: new ArrayBuffer(0) }),
};
}
const key = [z, x, y, encodeIndividualOptions(options)].join("/");
return this.contourCache.getCancelable(key, () => {
const max = 1 << z;
let canceled = false;
const neighborPromises: (CancelablePromise<HeightTile> | null)[] = [];
for (let iy = y - 1; iy <= y + 1; iy++) {
for (let ix = x - 1; ix <= x + 1; ix++) {
neighborPromises.push(
iy < 0 || iy >= max
? null
: this.fetchDem(z, (ix + max) % max, iy, options, timer),
);
}
}
const value = Promise.all(neighborPromises.map((n) => n?.value)).then(
async (neighbors) => {
let virtualTile = HeightTile.combineNeighbors(neighbors);
if (!virtualTile || canceled) {
return { arrayBuffer: new Uint8Array().buffer };
}
const mark = timer?.marker("isoline");
if (virtualTile.width >= subsampleBelow) {
virtualTile = virtualTile.materialize(2);
} else {
while (virtualTile.width < subsampleBelow) {
virtualTile = virtualTile.subsamplePixelCenters(2).materialize(2);
}
}
virtualTile = virtualTile
.averagePixelCentersToGrid()
.scaleElevation(multiplier)
.materialize(1);
const isolines = generateIsolines(
levels[0],
virtualTile,
extent,
buffer,
);
mark?.();
const result = encodeVectorTile({
extent,
layers: {
[contourLayer]: {
features: Object.entries(isolines).map(([eleString, geom]) => {
const ele = Number(eleString);
return {
type: GeomType.LINESTRING,
geometry: geom,
properties: {
[elevationKey]: ele,
[levelKey]: Math.max(
...levels.map((l, i) => (ele % l === 0 ? i : 0)),
),
},
};
}),
},
},
});
mark?.();
return { arrayBuffer: result.buffer };
},
);
return {
value,
cancel() {
canceled = true;
neighborPromises.forEach((n) => n && n.cancel());
},
};
});
}
}
| src/dem-manager.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " * the 4 adjacent pixel values.\n */\n averagePixelCentersToGrid = (radius: number = 1): HeightTile =>\n new HeightTile(this.width + 1, this.height + 1, (x, y) => {\n let sum = 0,\n count = 0,\n v = 0;\n for (let newX = x - radius; newX < x + radius; newX++) {\n for (let newY = y - radius; newY < y + radius; newY++) {\n if (!isNaN((v = this.get(newX, newY)))) {",
"score": 36.022069433135535
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " /** Construct a height tile from raw DEM pixel values */\n static fromRawDem(demTile: DemTile): HeightTile {\n return new HeightTile(demTile.width, demTile.height, (x, y) => {\n const value = demTile.data[y * demTile.width + x];\n return defaultIsValid(value) ? value : NaN;\n });\n }\n /**\n * Construct a height tile from a DEM tile plus it's 8 neighbors, so that\n * you can request `x` or `y` outside the bounds of the original tile.",
"score": 23.771915839185823
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": "class Remote {\n received: any[][] = [];\n canceled = false;\n remoteAction = (x: number, y: number, z: number): CancelablePromise<void> => {\n this.received.push([x, y, z]);\n return { cancel() {}, value: Promise.resolve() };\n };\n remotePromise = (x: number, timer?: Timer): CancelablePromise<number> => {\n const oldNow = performance.now;\n if (timer) timer.timeOrigin = 100;",
"score": 19.516976680453975
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " ): CancelablePromise<FetchResponse> =>\n this.actor.send(\"fetchTile\", [], timer, this.managerId, z, x, y);\n fetchAndParseTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> =>\n this.actor.send(\"fetchAndParseTile\", [], timer, this.managerId, z, x, y);\n fetchContourTile = (",
"score": 19.295852994253984
},
{
"filename": "src/dem-source.ts",
"retrieved_chunk": " actor,\n );\n }\n /** Registers a callback to be invoked with a performance report after each tile is requested. */\n onTiming = (callback: (timing: Timing) => void) => {\n this.timingCallbacks.push(callback);\n };\n getDemTile(z: number, x: number, y: number): Promise<DemTile> {\n return this.manager.fetchAndParseTile(z, x, y).value;\n }",
"score": 18.676067708604684
}
] | typescript | HeightTile.fromRawDem(tile).split(subZ, subX, subY),
),
cancel,
}; |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options | : GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`; |
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " /** The \"virtual\" tile url using the protocol ID registered with maplibre */\n url: String;\n /** Timing origin that all marks are relative to. */\n origin: number;\n /** Overall duration of the request */\n duration: number;\n /** Time spent fetching all resources, or `undefined` if they were cached */\n fetch?: number;\n /** Time spent decoding all raster-rgb images, or `undefined` if it was cached */\n decode?: number;",
"score": 18.969426735314592
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " const options: GlobalContourTileOptions = {\n thresholds: {\n 10: [500],\n 11: [100, 1000],\n },\n };\n expect(decodeOptions(encodeOptions(options))).toEqual(options);\n});\ntest(\"extract levels from global contour options\", () => {\n // eslint-disable-next-line",
"score": 17.79343038130009
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " * Returns a new tile scaled up by `factor` with pixel values that are subsampled using\n * bilinear interpolation between the original height tile values.\n *\n * The original and result tile are assumed to represent values taken at the center of each pixel.\n */\n subsamplePixelCenters = (factor: number): HeightTile => {\n const lerp = (a: number, b: number, f: number) =>\n isNaN(a) ? b : isNaN(b) ? a : a + (b - a) * f;\n if (factor <= 1) return this;\n const sub = 0.5 - 1 / (2 * factor);",
"score": 14.734139659328317
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " ? this\n : new HeightTile(\n this.width,\n this.height,\n (x, y) => this.get(x, y) * multiplier,\n );\n /**\n * Precompute every value from `-bufer, -buffer` to `width + buffer, height + buffer` and serve them\n * out of a `Float32Array`. Until this method is called, all `get` requests are lazy and call all previous\n * methods in the chain up to the root DEM tile.",
"score": 14.716884494381375
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " }\n delete this.cancels[message.id];\n }\n }\n };\n }\n postMessage(message: Message, transferrables?: Transferable[]) {\n this.dest.postMessage(message, transferrables || []);\n }\n /** Invokes a method by name with a set of arguments in the remote context. */",
"score": 13.626692900670264
}
] | typescript | : GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`; |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer. | error(request.url); |
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " timer?.useTile(url);\n return this.parsedCache.getCancelable(url, () => {\n const tile = self.fetchTile(z, x, y, timer);\n let canceled = false;\n let alsoCancel = () => {};\n return {\n value: tile.value.then(async (response) => {\n if (canceled) throw new Error(\"canceled\");\n const result = self.decodeImage(response.data, self.encoding);\n alsoCancel = result.cancel;",
"score": 43.10342161159894
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " data: await response.blob(),\n expires: response.headers.get(\"expires\") || undefined,\n cacheControl: response.headers.get(\"cache-control\") || undefined,\n };\n }),\n cancel,\n });\n });\n }\n fetchAndParseTile = (",
"score": 43.0795753717823
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " try {\n const response = await request.value;\n const transferrables = (response as IsTransferrable)\n ?.transferrables;\n this.postMessage(\n {\n id: message.id,\n type: \"response\",\n response,\n timings: timer.finish(url),",
"score": 41.29574188519633
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " },\n transferrables,\n );\n } catch (e: any) {\n this.postMessage({\n id: message.id,\n type: \"response\",\n error: e?.toString() || \"error\",\n timings: timer.finish(url),\n });",
"score": 34.837035993277006
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(tile.width).toBe(4);\n expect(tile.height).toBe(4);\n const tile2 = await source.getDemTile(1, 2, 3);\n expect(tile2.data).toEqual(expectedElevations);\n const timings: Timing[] = [];\n source.onTiming((timing) => timings.push(timing));\n const fetched = await new Promise((resolve, reject) => {\n source.sharedDemProtocol(\n {\n url: source.sharedDemProtocolUrl",
"score": 31.30873499383747
}
] | typescript | error(request.url); |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
| const tile = await source.getDemTile(1, 2, 3); |
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/setup-jest.ts",
"retrieved_chunk": "import \"whatwg-fetch\";\nglobal.fetch = jest.fn();\nperformance.now = () => Date.now();",
"score": 27.024723705428958
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " const result = withTimeout(1000, {\n value: new Promise(() => {}),\n cancel,\n });\n jest.advanceTimersByTime(999);\n expect(cancel).not.toBeCalled();\n jest.advanceTimersByTime(2);\n expect(cancel).toBeCalledTimes(1);\n await expect(result.value).rejects.toThrow(new Error(\"timed out\"));\n});",
"score": 26.219142657452444
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": "});\ntest(\"withTimeout - reject cancels timer\", async () => {\n const cancel = jest.fn();\n const error = new Error(\"rejected\");\n const result = withTimeout(1000, {\n value: Promise.reject(error),\n cancel,\n });\n await expect(result.value).rejects.toBe(error);\n jest.advanceTimersByTime(10_000);",
"score": 25.19080315316007
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": "test(\"withTimeout - resolve cancels timer\", async () => {\n const cancel = jest.fn();\n const result = withTimeout(1000, {\n value: Promise.resolve(true),\n cancel,\n });\n await expect(result.value).resolves.toBe(true);\n jest.advanceTimersByTime(10_000);\n expect(cancel).not.toBeCalled();\n await expect(result.value).resolves.toBe(true);",
"score": 22.635571337395245
},
{
"filename": "src/utils.test.ts",
"retrieved_chunk": " expect(cancel).toBeCalledTimes(1);\n jest.advanceTimersByTime(10_000);\n expect(cancel).toBeCalledTimes(1);\n});",
"score": 19.44352902566161
}
] | typescript | const tile = await source.getDemTile(1, 2, 3); |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor | = new Actor<WorkerDispatch>(workerFromMainThread, local); |
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " value: new Promise(() => {}),\n });\n}\ntest(\"send and cancel messages\", async () => {\n performance.now = () => 1;\n const remote = new Remote();\n const local = new Local();\n const workerFromMainThread: Worker = {} as any as Worker;\n const mainThreadFromWorker: Worker = {} as any as Worker;\n workerFromMainThread.postMessage = (data) =>",
"score": 140.33616370019593
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " //@ts-ignore\n mainThreadFromWorker?.onmessage?.({ data });\n mainThreadFromWorker.postMessage = (data) =>\n //@ts-ignore\n workerFromMainThread?.onmessage?.({ data });\n const mainActor = new Actor<Remote>(workerFromMainThread, local);\n const workerActor = new Actor<Local>(mainThreadFromWorker, remote);\n mainActor.send(\"remoteAction\", [], undefined, 1, 2, 3);\n expect(remote.received).toEqual([[1, 2, 3]]);\n workerActor.send(\"localAction\", [], undefined, 4, 3, 2);",
"score": 100.15083051462125
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " return result as any as PerformanceResourceTiming;\n}",
"score": 44.30357925008324
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " constructor(dest: Worker, dispatcher: any, timeoutMs: number = 20_000) {\n this.callbacks = {};\n this.cancels = {};\n this.dest = dest;\n this.timeoutMs = timeoutMs;\n this.dest.onmessage = async ({ data }) => {\n const message: Message = data;\n if (message.type === \"cancel\") {\n const cancel = this.cancels[message.id];\n delete this.cancels[message.id];",
"score": 43.240697653591724
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": "}\nfunction defaultActor(): Actor<WorkerDispatch> {\n if (!_actor) {\n const worker = new Worker(CONFIG.workerUrl);\n const dispatch = new MainThreadDispatch();\n _actor = new Actor(worker, dispatch);\n }\n return _actor;\n}\n/**",
"score": 42.77929136861772
}
] | typescript | = new Actor<WorkerDispatch>(workerFromMainThread, local); |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source.onTiming( | (timing) => timings.push(timing)); |
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " expect(requests).toEqual({ 1: 1 });\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(1, getter)).toBe(2);\n expect(requests).toEqual({ 1: 1, 2: 1 });\n // prunes 2 (not 1) because 2 was most recently accessed\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(1, getter)).toBe(2);\n expect(await cache.get(2, getter)).toBe(3);",
"score": 56.815612547980955
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "import { HeightTile } from \"./height-tile\";\nconst initialTile = HeightTile.fromRawDem({\n width: 2,\n height: 2,\n data: Float32Array.from([0, 1, 2, 3]),\n});\ntest(\"raw tile\", () => {\n expect(initialTile.get(0, 0)).toBe(0);\n expect(initialTile.get(1, 0)).toBe(1);\n expect(initialTile.get(1, 1)).toBe(3);",
"score": 48.5360439369922
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " expect(local.received).toEqual([[4, 3, 2]]);\n const timer = new Timer(\"main\");\n timer.timeOrigin = 0;\n expect(await mainActor.send(\"remotePromise\", [], timer, 9).value).toBe(9);\n expect(timer.finish(\"url\")).toMatchObject({\n duration: 2,\n fetch: 1,\n marks: {\n fetch: [[1, 2]],\n main: [[1, 3]],",
"score": 43.38391348472157
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " HeightTile.combineNeighbors(neighbors)?.subsamplePixelCenters(2);\n expect(virtualTile?.get(0, 0)).toBe((7.75 + 3 * 13.75) / 4);\n expect(virtualTile?.get(-1, -1)).toBe((7.25 * 3 + 13.25) / 4);\n expect(virtualTile).toMatchObject({\n width: 4,\n height: 4,\n });\n});\ntest(\"subsample and average centers alignment between tiles\", () => {\n /* ___________ ____________",
"score": 39.35910913857626
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "});\ntest(\"split height tile\", () => {\n const split = initialTile.split(1, 0, 0);\n expect(split.get(0, 0)).toBe(0);\n expect(split.width).toBe(1);\n const split2 = initialTile.split(1, 1, 1);\n expect(split2.get(0, 0)).toBe(3);\n expect(split2.width).toBe(1);\n});\nconst neighbors: HeightTile[] = [];",
"score": 38.253149484543975
}
] | typescript | (timing) => timings.push(timing)); |
import { DemManager, LocalDemManager } from "./dem-manager";
import { decodeOptions, encodeOptions, getOptionsForZoom } from "./utils";
import RemoteDemManager from "./remote-dem-manager";
import { DemTile, Cancelable, GlobalContourTileOptions, Timing } from "./types";
import type WorkerDispatch from "./worker-dispatch";
import Actor from "./actor";
import { Timer } from "./performance";
if (!Blob.prototype.arrayBuffer) {
Blob.prototype.arrayBuffer = function arrayBuffer() {
return new Promise<ArrayBuffer>((resolve, reject) => {
const fileReader = new FileReader();
fileReader.onload = (event) =>
resolve(event.target?.result as ArrayBuffer);
fileReader.onerror = reject;
fileReader.readAsArrayBuffer(this);
});
};
}
// for maplibre interop
type RequestParameters = {
url: string;
headers?: any;
method?: "GET" | "POST" | "PUT";
body?: string;
type?: "string" | "json" | "arrayBuffer";
credentials?: "same-origin" | "include";
collectResourceTiming?: boolean;
};
type ResponseCallback = (
error?: Error | undefined,
data?: any | undefined,
cacheControl?: string | undefined,
expires?: string | undefined,
) => void;
type Protocol = (
request: RequestParameters,
response: ResponseCallback,
) => Cancelable;
const used = new Set<string>();
/**
* A remote source of DEM tiles that can be connected to maplibre.
*/
export class DemSource {
sharedDemProtocolId: string;
contourProtocolId: string;
contourProtocolUrlBase: string;
manager: DemManager;
sharedDemProtocolUrl: string;
timingCallbacks: Array<(timing: Timing) => void> = [];
constructor({
url,
cacheSize = 100,
id = "dem",
encoding = "terrarium",
maxzoom = 12,
worker = true,
timeoutMs = 10_000,
actor,
}: {
/** Remote DEM tile url using `{z}` `{x}` and `{y}` placeholders */
url: string;
/** Number of most-recently-used tiles to cache */
cacheSize?: number;
/** Prefix for the maplibre protocol */
id?: string;
encoding?: "terrarium" | "mapbox";
/** Maximum zoom of tiles contained in the source */
maxzoom: number;
timeoutMs?: number;
/** Handle requests in a shared web worker to reduce UI-thread jank */
worker?: boolean;
actor?: Actor<WorkerDispatch>;
}) {
let protocolPrefix = id;
let i = 1;
while (used.has(protocolPrefix)) {
protocolPrefix = id + i++;
}
used.add(protocolPrefix);
this.sharedDemProtocolId = `${protocolPrefix}-shared`;
this.contourProtocolId = `${protocolPrefix}-contour`;
this.sharedDemProtocolUrl = `${this.sharedDemProtocolId}://{z}/{x}/{y}`;
this.contourProtocolUrlBase = `${this.contourProtocolId}://{z}/{x}/{y}`;
const ManagerClass = worker ? RemoteDemManager : LocalDemManager;
this.manager = new ManagerClass(
url,
cacheSize,
encoding,
maxzoom,
timeoutMs,
actor,
);
}
/** Registers a callback to be invoked with a performance report after each tile is requested. */
onTiming = (callback: (timing: Timing) => void) => {
this.timingCallbacks.push(callback);
};
getDemTile(z: number, x: number, y: number): Promise<DemTile> {
return this.manager.fetchAndParseTile(z, x, y).value;
}
/**
* Adds contour and shared DEM protocol handlers to maplibre.
*
* @param maplibre maplibre global object
*/
setupMaplibre = (maplibre: {
addProtocol: (id: string, protcol: Protocol) => void;
}) => {
maplibre.addProtocol(this.sharedDemProtocolId, this.sharedDemProtocol);
maplibre.addProtocol(this.contourProtocolId, this.contourProtocol);
};
parseUrl(url: string): [number, number, number] {
const [, z, x, y] = /\/\/(\d+)\/(\d+)\/(\d+)/.exec(url) || [];
return [Number(z), Number(x), Number(y)];
}
/**
* Callback to be used with maplibre addProtocol to re-use cached DEM tiles across sources.
*/
sharedDemProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const [z, x, y] = this.parseUrl(request.url);
const timer = new Timer("main");
const result = this.manager.fetchTile(z, x, y, timer);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
| timing = timer.finish(request.url); |
if (canceled) return;
const arrayBuffer: ArrayBuffer = await data.data.arrayBuffer();
if (canceled) return;
response(undefined, arrayBuffer, data.cacheControl, data.expires);
} catch (error) {
timing = timer.error(request.url);
if (canceled) return;
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = false;
result.cancel();
},
};
};
/**
* Callback to be used with maplibre addProtocol to generate contour vector tiles according
* to options encoded in the tile URL pattern generated by `contourProtocolUrl`.
*/
contourProtocol = (
request: RequestParameters,
response: ResponseCallback,
): Cancelable => {
const timer = new Timer("main");
const [z, x, y] = this.parseUrl(request.url);
const options = decodeOptions(request.url);
const result = this.manager.fetchContourTile(
z,
x,
y,
getOptionsForZoom(options, z),
timer,
);
let canceled = false;
(async () => {
let timing: Timing;
try {
const data = await result.value;
timing = timer.finish(request.url);
if (canceled) return;
response(undefined, data.arrayBuffer);
} catch (error) {
if (canceled) return;
timing = timer.error(request.url);
response(error as Error);
}
this.timingCallbacks.forEach((cb) => cb(timing));
})();
return {
cancel: () => {
canceled = true;
result.cancel();
},
};
};
/**
* Returns a URL with the correct maplibre protocol prefix and all `option` encoded in request parameters.
*/
contourProtocolUrl = (options: GlobalContourTileOptions) =>
`${this.contourProtocolUrlBase}?${encodeOptions(options)}`;
}
| src/dem-source.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " timer?.useTile(url);\n return this.parsedCache.getCancelable(url, () => {\n const tile = self.fetchTile(z, x, y, timer);\n let canceled = false;\n let alsoCancel = () => {};\n return {\n value: tile.value.then(async (response) => {\n if (canceled) throw new Error(\"canceled\");\n const result = self.decodeImage(response.data, self.encoding);\n alsoCancel = result.cancel;",
"score": 52.47558867979916
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " fetchTile(\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse> {\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 39.884275627174716
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " ): CancelablePromise<FetchResponse> =>\n this.actor.send(\"fetchTile\", [], timer, this.managerId, z, x, y);\n fetchAndParseTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> =>\n this.actor.send(\"fetchAndParseTile\", [], timer, this.managerId, z, x, y);\n fetchContourTile = (",
"score": 37.841438196046454
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " try {\n const response = await request.value;\n const transferrables = (response as IsTransferrable)\n ?.transferrables;\n this.postMessage(\n {\n id: message.id,\n type: \"response\",\n response,\n timings: timer.finish(url),",
"score": 37.648261552675145
},
{
"filename": "src/worker-dispatch.ts",
"retrieved_chunk": " };\n fetchTile = (\n managerId: number,\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse> =>\n this.managers[managerId]?.fetchTile(z, x, y, timer) || noManager(managerId);\n fetchAndParseTile = (",
"score": 37.01190471480418
}
] | typescript | timing = timer.finish(request.url); |
import { HeightTile } from "./height-tile";
const initialTile = HeightTile.fromRawDem({
width: 2,
height: 2,
data: Float32Array.from([0, 1, 2, 3]),
});
test("raw tile", () => {
expect(initialTile.get(0, 0)).toBe(0);
expect(initialTile.get(1, 0)).toBe(1);
expect(initialTile.get(1, 1)).toBe(3);
});
test("split height tile", () => {
const split = initialTile.split(1, 0, 0);
expect(split.get(0, 0)).toBe(0);
expect(split.width).toBe(1);
const split2 = initialTile.split(1, 1, 1);
expect(split2.get(0, 0)).toBe(3);
expect(split2.width).toBe(1);
});
const neighbors: HeightTile[] = [];
for (let i = 0; i < 9; i++) {
const row = Math.floor(i / 3);
const start = i * 2 + row * 6;
neighbors.push(
HeightTile.fromRawDem({
width: 2,
height: 2,
data: Float32Array.from([start, start + 1, start + 6, start + 7]),
}),
);
}
// 0 1 | 2 3 | 4 5
// 6 7 | 8 9 | 10 11
// ------ ------- ------
// 12 13 | 14 15 | 16 17
// 18 19 | 20 21 | 22 23
// ------ ------- ------
// 24 25 | 26 27 | 28 29
// 30 31 | 32 33 | 34 35
test("neighboring tiles", () => {
| const virtualTile = HeightTile.combineNeighbors(neighbors); |
expect(virtualTile?.get(-1, -1)).toBe(7);
expect(virtualTile?.get(0, -1)).toBe(8);
expect(virtualTile?.get(1, -1)).toBe(9);
expect(virtualTile?.get(2, -1)).toBe(10);
expect(virtualTile?.get(-1, 0)).toBe(13);
expect(virtualTile?.get(0, 0)).toBe(14);
expect(virtualTile?.get(1, 0)).toBe(15);
expect(virtualTile?.get(2, 0)).toBe(16);
expect(virtualTile?.get(-1, 2)).toBe(25);
expect(virtualTile?.get(0, 2)).toBe(26);
expect(virtualTile?.get(1, 2)).toBe(27);
expect(virtualTile?.get(2, 2)).toBe(28);
});
// 0 1 | 2 3 | 4 5
// 6 7 | 8 9 | 10 11
// ------ ------- ------
// 12 13 | 14 15 | 16 17
// 18 19 | 20 21 | 22 23
// ------ ------- ------
// 24 25 | 26 27 | 28 29
// 30 31 | 32 33 | 34 35
test("average pixel centers to grid", () => {
const virtualTile =
HeightTile.combineNeighbors(neighbors)?.averagePixelCentersToGrid();
// 7,8,13,14
expect(virtualTile?.get(0, 0)).toBe((7 + 8 + 13 + 14) / 4);
expect(virtualTile?.get(1, 0)).toBe((8 + 9 + 14 + 15) / 4);
expect(virtualTile?.get(2, 0)).toBe((9 + 10 + 15 + 16) / 4);
expect(virtualTile?.get(0, 2)).toBe((19 + 20 + 25 + 26) / 4);
expect(virtualTile?.get(2, 2)).toBe((21 + 22 + 27 + 28) / 4);
expect(virtualTile).toMatchObject({
width: 3,
height: 3,
});
});
test("subsample pixel centers", () => {
/* ___________ ____________
| | |
| old -1,-1 | old 0,-1 |
| 7 | 8 |
|new -1,-1>x | x<new 0,-1|
|_____________|____________|
| | |
| new -1,0>x | x<new 0,0 |
| 13 | 14 |
| old -1,0 | old 0,0 |
|_____________|____________|
*/
const virtualTile =
HeightTile.combineNeighbors(neighbors)?.subsamplePixelCenters(2);
expect(virtualTile?.get(0, 0)).toBe((7.75 + 3 * 13.75) / 4);
expect(virtualTile?.get(-1, -1)).toBe((7.25 * 3 + 13.25) / 4);
expect(virtualTile).toMatchObject({
width: 4,
height: 4,
});
});
test("subsample and average centers alignment between tiles", () => {
/* ___________ ____________
| | |
| old -1,-1 | old 0,-1 |
| 7 | 8 |
|new -1,-1>x | x<new 0,-1|
|_____________|____________|
| | |
| new -1,0>x | x<new 0,0 |
| 13 | 14 |
| old -1,0 | old 0,0 |
|_____________|____________|
*/
const subsampled = HeightTile.combineNeighbors(neighbors)
?.subsamplePixelCenters(2)
.averagePixelCentersToGrid();
const notSubsampled =
HeightTile.combineNeighbors(neighbors)?.averagePixelCentersToGrid();
expect(subsampled).toMatchObject({
width: 5,
height: 5,
});
expect(notSubsampled).toMatchObject({
width: 3,
height: 3,
});
expect(subsampled?.get(0, 0)).toBe(notSubsampled?.get(0, 0));
expect(subsampled?.get(2, 2)).toBe(notSubsampled?.get(1, 1));
expect(subsampled?.get(-2, -2)).toBe(notSubsampled?.get(-1, -1));
});
| src/height-tile.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " [5, 9],\n [6, 9],\n [7, 9],\n [8, 9],\n ],\n decode: [\n [10, 18],\n [11, 18],\n [12, 18],\n [13, 18],",
"score": 52.845071410912745
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " [14, 18],\n [15, 18],\n [16, 18],\n [17, 18],\n [18, 18],\n ],\n isoline: [[18, 18, 18]],\n },\n decode: 8,\n fetch: 9,",
"score": 42.70800290953058
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " decode: [\n [5, 7],\n [6, 7],\n [7, 7],\n ],\n isoline: [[7, 7, 7]],\n },\n resources: [\n { duration: 1, startTime: 7, name: \"https://example/10/22/29.png\" },\n { duration: 1, startTime: 7, name: \"https://example/10/22/30.png\" },",
"score": 34.345695942371556
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " { duration: 1, startTime: 7, name: \"https://example/10/22/31.png\" },\n ],\n url: \"dem-contour://10/21/30?overzoom=0&thresholds=10*10\",\n });\n});\ntest(\"decode image from worker\", async () => {\n const result = await workerActor.send(\n \"decodeImage\",\n [],\n undefined,",
"score": 29.99207156287603
},
{
"filename": "src/vtpbf.test.ts",
"retrieved_chunk": "});\ntest(\"multi line\", () => {\n const encoded = encodeVectorTile({\n layers: {\n contours: {\n features: [\n {\n geometry: [\n [0, 1, 2, 3],\n [9, 8, 7, 6],",
"score": 26.666549016396782
}
] | typescript | const virtualTile = HeightTile.combineNeighbors(neighbors); |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source. | onTiming((timing) => timings.push(timing)); |
const fetched = await new Promise((resolve, reject) => {
source.sharedDemProtocol(
{
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " expect(requests).toEqual({ 1: 1 });\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(1, getter)).toBe(2);\n expect(requests).toEqual({ 1: 1, 2: 1 });\n // prunes 2 (not 1) because 2 was most recently accessed\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(1, getter)).toBe(2);\n expect(await cache.get(2, getter)).toBe(3);",
"score": 56.815612547980955
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "import { HeightTile } from \"./height-tile\";\nconst initialTile = HeightTile.fromRawDem({\n width: 2,\n height: 2,\n data: Float32Array.from([0, 1, 2, 3]),\n});\ntest(\"raw tile\", () => {\n expect(initialTile.get(0, 0)).toBe(0);\n expect(initialTile.get(1, 0)).toBe(1);\n expect(initialTile.get(1, 1)).toBe(3);",
"score": 48.5360439369922
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " expect(local.received).toEqual([[4, 3, 2]]);\n const timer = new Timer(\"main\");\n timer.timeOrigin = 0;\n expect(await mainActor.send(\"remotePromise\", [], timer, 9).value).toBe(9);\n expect(timer.finish(\"url\")).toMatchObject({\n duration: 2,\n fetch: 1,\n marks: {\n fetch: [[1, 2]],\n main: [[1, 3]],",
"score": 43.38391348472157
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " HeightTile.combineNeighbors(neighbors)?.subsamplePixelCenters(2);\n expect(virtualTile?.get(0, 0)).toBe((7.75 + 3 * 13.75) / 4);\n expect(virtualTile?.get(-1, -1)).toBe((7.25 * 3 + 13.25) / 4);\n expect(virtualTile).toMatchObject({\n width: 4,\n height: 4,\n });\n});\ntest(\"subsample and average centers alignment between tiles\", () => {\n /* ___________ ____________",
"score": 39.35910913857626
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "});\ntest(\"split height tile\", () => {\n const split = initialTile.split(1, 0, 0);\n expect(split.get(0, 0)).toBe(0);\n expect(split.width).toBe(1);\n const split2 = initialTile.split(1, 1, 1);\n expect(split2.get(0, 0)).toBe(3);\n expect(split2.width).toBe(1);\n});\nconst neighbors: HeightTile[] = [];",
"score": 38.253149484543975
}
] | typescript | onTiming((timing) => timings.push(timing)); |
import { flattenDeep } from "lodash";
import Actor from "./actor";
import WorkerDispatch from "./worker-dispatch";
import { DemSource } from "./dem-source";
import { MainThreadDispatch } from "./remote-dem-manager";
import { CancelablePromise, DemTile, Timing } from "./types";
import { VectorTile } from "@mapbox/vector-tile";
import Pbf from "pbf";
beforeEach(() => {
jest.useFakeTimers({ now: 0, doNotFake: ["performance"] });
});
afterEach(() => {
jest.useRealTimers();
});
jest.mock("./decode-image", () => (): CancelablePromise<DemTile> => {
jest.advanceTimersByTime(1);
// eslint-disable-next-line global-require
const flattenDeep = require("lodash/flattenDeep");
const value: DemTile = {
data: Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
),
width: 4,
height: 4,
};
return { value: Promise.resolve(value), cancel() {} };
});
const remote = new WorkerDispatch();
const local = new MainThreadDispatch();
const workerFromMainThread: Worker = {} as any as Worker;
const mainThreadFromWorker: Worker = {} as any as Worker;
workerFromMainThread.postMessage = (data) =>
mainThreadFromWorker?.onmessage?.({ data } as any);
mainThreadFromWorker.postMessage = (data) =>
workerFromMainThread?.onmessage?.({ data } as any);
const mainActor = new Actor<WorkerDispatch>(workerFromMainThread, local);
const workerActor = new Actor<MainThreadDispatch>(mainThreadFromWorker, remote);
const source = new DemSource({
url: "https://example/{z}/{x}/{y}.png",
cacheSize: 100,
encoding: "terrarium",
maxzoom: 11,
worker: true,
actor: mainActor,
});
const expectedElevations = Float32Array.from(
flattenDeep([
[5, 5, 5, 5],
[5, 15, 15, 5],
[5, 15, 15, 5],
[5, 5, 5, 5],
]),
);
test("e2e fetch tile and shared DEM protocol share cache", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const tile = await source.getDemTile(1, 2, 3);
expect(tile.data).toEqual(expectedElevations);
expect(tile.width).toBe(4);
expect(tile.height).toBe(4);
const tile2 = await source.getDemTile(1, 2, 3);
expect(tile2.data).toEqual(expectedElevations);
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const fetched = await new Promise((resolve, reject) => {
| source.sharedDemProtocol(
{ |
url: source.sharedDemProtocolUrl
.replace("{z}", "1")
.replace("{x}", "2")
.replace("{y}", "3"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);
expect(global.fetch).toBeCalledTimes(1);
expect(global.fetch).toBeCalledWith(
"https://example/1/2/3.png",
expect.anything(),
);
expect(timings).toMatchObject([
{
duration: 0,
marks: {
main: [[2, 2]],
worker: [[2, 2]],
},
resources: [],
url: "dem-shared://1/2/3",
wait: 0,
},
]);
});
test("e2e contour tile", async () => {
global.fetch = jest.fn().mockImplementation(async () => {
jest.advanceTimersByTime(1);
return new Response(
new Blob([Uint8Array.from([1, 2])], { type: "image/png" }),
{
status: 200,
},
);
});
const timings: Timing[] = [];
source.onTiming((timing) => timings.push(timing));
const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
buffer: 0,
contourLayer: "c",
elevationKey: "e",
levelKey: "l",
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "20")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
const tile = new VectorTile(new Pbf(contourTile));
expect(tile.layers.c.name).toBe("c");
expect(tile.layers.c.extent).toBe(4096);
expect(tile.layers.c.length).toBe(1);
expect(tile.layers.c.feature(0).properties).toEqual({
e: 10,
l: 0,
});
const geom = tile.layers.c.feature(0).loadGeometry()[0];
expect(geom.length).toEqual(253);
let xSum = 0,
ySum = 0;
for (const { x, y } of geom) {
xSum += x;
ySum += y;
}
const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };
expect(center).toMatchObject({
x: 2049,
y: 2052,
});
expect(timings).toMatchObject([
{
tilesUsed: 9,
process: 0,
duration: 18,
marks: {
main: [[0, 18]],
worker: [[0, 18]],
fetch: [
[0, 9],
[1, 9],
[2, 9],
[3, 9],
[4, 9],
[5, 9],
[6, 9],
[7, 9],
[8, 9],
],
decode: [
[10, 18],
[11, 18],
[12, 18],
[13, 18],
[14, 18],
[15, 18],
[16, 18],
[17, 18],
[18, 18],
],
isoline: [[18, 18, 18]],
},
decode: 8,
fetch: 9,
resources: [],
url: "dem-contour://10/20/30?buffer=0&contourLayer=c&elevationKey=e&levelKey=l&overzoom=0&thresholds=10*10",
wait: 1,
},
]);
// fetch adjacent tile where 6/9 neighbors are already cached
jest.setSystemTime(1);
performance.getEntriesByName = (name) => [
{
duration: 1,
name,
entryType: "resource",
startTime: performance.now(),
} as PerformanceResourceTiming,
];
await new Promise((resolve, reject) => {
source.contourProtocol(
{
url: source
.contourProtocolUrl({
thresholds: {
10: 10,
},
overzoom: 0,
})
.replace("{z}", "10")
.replace("{x}", "21")
.replace("{y}", "30"),
},
(err, data) => {
if (err) reject(err);
else resolve(data);
},
);
});
expect(timings[1]).toMatchObject({
tilesUsed: 9,
process: 0,
duration: 6,
decode: 2,
fetch: 3,
wait: 1,
marks: {
main: [[1, 7]],
worker: [[1, 7]],
fetch: [
[1, 4],
[2, 4],
[3, 4],
],
decode: [
[5, 7],
[6, 7],
[7, 7],
],
isoline: [[7, 7, 7]],
},
resources: [
{ duration: 1, startTime: 7, name: "https://example/10/22/29.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/30.png" },
{ duration: 1, startTime: 7, name: "https://example/10/22/31.png" },
],
url: "dem-contour://10/21/30?overzoom=0&thresholds=10*10",
});
});
test("decode image from worker", async () => {
const result = await workerActor.send(
"decodeImage",
[],
undefined,
new Blob([], { type: "image/png" }),
"terrarium",
).value;
expect(result).toMatchObject({
width: 4,
height: 4,
data: expectedElevations,
});
});
| src/e2e.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/cache.test.ts",
"retrieved_chunk": " expect(requests).toEqual({ 1: 1 });\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(2, getter)).toBe(3);\n expect(await cache.get(1, getter)).toBe(2);\n expect(requests).toEqual({ 1: 1, 2: 1 });\n // prunes 2 (not 1) because 2 was most recently accessed\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(3, getter)).toBe(4);\n expect(await cache.get(1, getter)).toBe(2);\n expect(await cache.get(2, getter)).toBe(3);",
"score": 50.1848847193709
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "import { HeightTile } from \"./height-tile\";\nconst initialTile = HeightTile.fromRawDem({\n width: 2,\n height: 2,\n data: Float32Array.from([0, 1, 2, 3]),\n});\ntest(\"raw tile\", () => {\n expect(initialTile.get(0, 0)).toBe(0);\n expect(initialTile.get(1, 0)).toBe(1);\n expect(initialTile.get(1, 1)).toBe(3);",
"score": 40.45682551416956
},
{
"filename": "src/actor.test.ts",
"retrieved_chunk": " expect(local.received).toEqual([[4, 3, 2]]);\n const timer = new Timer(\"main\");\n timer.timeOrigin = 0;\n expect(await mainActor.send(\"remotePromise\", [], timer, 9).value).toBe(9);\n expect(timer.finish(\"url\")).toMatchObject({\n duration: 2,\n fetch: 1,\n marks: {\n fetch: [[1, 2]],\n main: [[1, 3]],",
"score": 38.64719904360001
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " HeightTile.combineNeighbors(neighbors)?.subsamplePixelCenters(2);\n expect(virtualTile?.get(0, 0)).toBe((7.75 + 3 * 13.75) / 4);\n expect(virtualTile?.get(-1, -1)).toBe((7.25 * 3 + 13.25) / 4);\n expect(virtualTile).toMatchObject({\n width: 4,\n height: 4,\n });\n});\ntest(\"subsample and average centers alignment between tiles\", () => {\n /* ___________ ____________",
"score": 34.916910981530336
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "});\ntest(\"split height tile\", () => {\n const split = initialTile.split(1, 0, 0);\n expect(split.get(0, 0)).toBe(0);\n expect(split.width).toBe(1);\n const split2 = initialTile.split(1, 1, 1);\n expect(split2.get(0, 0)).toBe(3);\n expect(split2.width).toBe(1);\n});\nconst neighbors: HeightTile[] = [];",
"score": 33.687295550885466
}
] | typescript | source.sharedDemProtocol(
{ |
/*
Adapted from d3-contour https://github.com/d3/d3-contour
Copyright 2012-2023 Mike Bostock
Permission to use, copy, modify, and/or distribute this software for any purpose
with or without fee is hereby granted, provided that the above copyright notice
and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
*/
import type { HeightTile } from "./height-tile";
class Fragment {
start: number;
end: number;
points: number[];
constructor(start: number, end: number) {
this.start = start;
this.end = end;
this.points = [];
this.append = this.append.bind(this);
this.prepend = this.prepend.bind(this);
}
append(x: number, y: number) {
this.points.push(Math.round(x), Math.round(y));
}
prepend(x: number, y: number) {
this.points.splice(0, 0, Math.round(x), Math.round(y));
}
lineString() {
return this.toArray();
}
isEmpty() {
return this.points.length < 2;
}
appendFragment(other: Fragment) {
this.points.push(...other.points);
this.end = other.end;
}
toArray() {
return this.points;
}
}
const CASES: [number, number][][][] = [
[],
[
[
[1, 2],
[0, 1],
],
],
[
[
[2, 1],
[1, 2],
],
],
[
[
[2, 1],
[0, 1],
],
],
[
[
[1, 0],
[2, 1],
],
],
[
[
[1, 2],
[0, 1],
],
[
[1, 0],
[2, 1],
],
],
[
[
[1, 0],
[1, 2],
],
],
[
[
[1, 0],
[0, 1],
],
],
[
[
[0, 1],
[1, 0],
],
],
[
[
[1, 2],
[1, 0],
],
],
[
[
[0, 1],
[1, 0],
],
[
[2, 1],
[1, 2],
],
],
[
[
[2, 1],
[1, 0],
],
],
[
[
[0, 1],
[2, 1],
],
],
[
[
[1, 2],
[2, 1],
],
],
[
[
[0, 1],
[1, 2],
],
],
[],
];
function index(width: number, x: number, y: number, point: [number, number]) {
x = x * 2 + point[0];
y = y * 2 + point[1];
return x + y * (width + 1) * 2;
}
function ratio(a: number, b: number, c: number) {
return (b - a) / (c - a);
}
/**
* Generates contour lines from a HeightTile
*
* @param interval Vertical distance between contours
* @param tile The input height tile, where values represent the height at the top-left of each pixel
* @param extent Vector tile extent (default 4096)
* @param buffer How many pixels into each neighboring tile to include in a tile
* @returns an object where keys are the elevation, and values are a list of `[x1, y1, x2, y2, ...]`
* contour lines in tile coordinates
*/
export default function generateIsolines(
interval: number,
tile: HeightTile,
extent: number = 4096,
buffer: number = 1,
): { [ele: number]: number[][] } {
if (!interval) {
return {};
}
const multiplier = extent / (tile.width - 1);
let tld: number, trd: number, bld: number, brd: number;
let r: number, c: number;
const segments: { [ele: string]: number[][] } = {};
const fragmentByStartByLevel: Map<number, Map<number, Fragment>> = new Map();
const fragmentByEndByLevel: Map<number, Map<number, Fragment>> = new Map();
function interpolate(
point: [number, number],
threshold: number,
accept: (x: number, y: number) => void,
) {
if (point[0] === 0) {
// left
accept(
multiplier * (c - 1),
multiplier * (r - ratio(bld, threshold, tld)),
);
} else if (point[0] === 2) {
// right
accept(multiplier * c, multiplier * (r - ratio(brd, threshold, trd)));
} else if (point[1] === 0) {
// top
accept(
multiplier * (c - ratio(trd, threshold, tld)),
multiplier * (r - 1),
);
} else {
// bottom
accept(multiplier * (c - ratio(brd, threshold, bld)), multiplier * r);
}
}
// Most marching-squares implementations (d3-contour, gdal-contour) make one pass through the matrix per threshold.
// This implementation makes a single pass through the matrix, building up all of the contour lines at the
// same time to improve performance.
for (r = 1 - buffer; r < tile.height + buffer; r++) {
trd = tile. | get(0, r - 1); |
brd = tile.get(0, r);
let minR = Math.min(trd, brd);
let maxR = Math.max(trd, brd);
for (c = 1 - buffer; c < tile.width + buffer; c++) {
tld = trd;
bld = brd;
trd = tile.get(c, r - 1);
brd = tile.get(c, r);
const minL = minR;
const maxL = maxR;
minR = Math.min(trd, brd);
maxR = Math.max(trd, brd);
if (isNaN(tld) || isNaN(trd) || isNaN(brd) || isNaN(bld)) {
continue;
}
const min = Math.min(minL, minR);
const max = Math.max(maxL, maxR);
const start = Math.ceil(min / interval) * interval;
const end = Math.floor(max / interval) * interval;
for (let threshold = start; threshold <= end; threshold += interval) {
const tl = tld > threshold;
const tr = trd > threshold;
const bl = bld > threshold;
const br = brd > threshold;
for (const segment of CASES[
(tl ? 8 : 0) | (tr ? 4 : 0) | (br ? 2 : 0) | (bl ? 1 : 0)
]) {
let fragmentByStart = fragmentByStartByLevel.get(threshold);
if (!fragmentByStart)
fragmentByStartByLevel.set(
threshold,
(fragmentByStart = new Map()),
);
let fragmentByEnd = fragmentByEndByLevel.get(threshold);
if (!fragmentByEnd)
fragmentByEndByLevel.set(threshold, (fragmentByEnd = new Map()));
const start = segment[0];
const end = segment[1];
const startIndex = index(tile.width, c, r, start);
const endIndex = index(tile.width, c, r, end);
let f, g;
if ((f = fragmentByEnd.get(startIndex))) {
fragmentByEnd.delete(startIndex);
if ((g = fragmentByStart.get(endIndex))) {
fragmentByStart.delete(endIndex);
if (f === g) {
// closing a ring
interpolate(end, threshold, f.append);
if (!f.isEmpty()) {
let list = segments[threshold];
if (!list) {
segments[threshold] = list = [];
}
list.push(f.lineString());
}
} else {
// connecting 2 segments
f.appendFragment(g);
fragmentByEnd.set((f.end = g.end), f);
}
} else {
// adding to the end of f
interpolate(end, threshold, f.append);
fragmentByEnd.set((f.end = endIndex), f);
}
} else if ((f = fragmentByStart.get(endIndex))) {
fragmentByStart.delete(endIndex);
// extending the start of f
interpolate(start, threshold, f.prepend);
fragmentByStart.set((f.start = startIndex), f);
} else {
// starting a new fragment
const newFrag = new Fragment(startIndex, endIndex);
interpolate(start, threshold, newFrag.append);
interpolate(end, threshold, newFrag.append);
fragmentByStart.set(startIndex, newFrag);
fragmentByEnd.set(endIndex, newFrag);
}
}
}
}
}
for (const [level, fragmentByStart] of fragmentByStartByLevel.entries()) {
let list: number[][] | null = null;
for (const value of fragmentByStart.values()) {
if (!value.isEmpty()) {
if (list == null) {
list = segments[level] || (segments[level] = []);
}
list.push(value.lineString());
}
}
}
return segments;
}
| src/isolines.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " levelKey?: string;\n /** Name of the vector tile layer to put contour lines in */\n contourLayer?: string;\n /** Grid size of the vector tile (default 4096) */\n extent?: number;\n /** How many pixels to generate on each tile into the neighboring tile to reduce rendering artifacts */\n buffer?: number;\n /** When overzooming tiles, subsample to scale up to at least this size to make the contour lines smoother at higher zooms. */\n subsampleBelow?: number;\n}",
"score": 51.8872887124527
},
{
"filename": "src/decode-image.ts",
"retrieved_chunk": "export function decodeParsedImage(\n width: number,\n height: number,\n encoding: Encoding,\n input: Uint8ClampedArray,\n): DemTile {\n const decoder: (r: number, g: number, b: number) => number =\n encoding === \"mapbox\"\n ? (r, g, b) => -10000 + (r * 256 * 256 + g * 256 + b) * 0.1\n : (r, g, b) => r * 256 + g + b / 256 - 32768;",
"score": 45.88469845741177
},
{
"filename": "src/types.ts",
"retrieved_chunk": " * the z10 `raster-dem` tile plus its 8 neighbors\n *\n * Setting to 1 requests a z9 tile and uses one quadrant of it so that it only needs up to 3\n * neighboring tiles to get the neighboring elevation data. It also improves performance with\n * 512x512 or larger `raster-dem` tiles.\n */\n overzoom?: number;\n /** Key for the elevation property to set on each contour line. */\n elevationKey?: string;\n /** Key for the \"level\" property to set on each contour line. Minor lines have level=0, major have level=1 */",
"score": 42.89732769436303
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " ? this\n : new HeightTile(\n this.width,\n this.height,\n (x, y) => this.get(x, y) * multiplier,\n );\n /**\n * Precompute every value from `-bufer, -buffer` to `width + buffer, height + buffer` and serve them\n * out of a `Float32Array`. Until this method is called, all `get` requests are lazy and call all previous\n * methods in the chain up to the root DEM tile.",
"score": 42.82137957658459
},
{
"filename": "src/types.ts",
"retrieved_chunk": " cacheControl?: string;\n}\n/** Parameters to use when creating a contour vector tile from raw elevation data */\nexport interface ContourTileOptions {\n /** Factor to scale the elevation meters by to support different units (default 1 for meters) */\n multiplier?: number;\n /**\n * Request `raster-dem` tiles from lower zoom levels to generate the contour vector tile.\n *\n * The default value is 0, which means to generate a contour vector tile at z10, it gets",
"score": 40.857157851952316
}
] | typescript | get(0, r - 1); |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][][]): HeightTile {
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
return HeightTile.fromRawDem({
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
| const size = heightTile.width; |
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile.height,
(x, y) => {
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
rotatedResult[ele] = isolines[ele].map((eles) => {
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/isolines.ts",
"retrieved_chunk": "export default function generateIsolines(\n interval: number,\n tile: HeightTile,\n extent: number = 4096,\n buffer: number = 1,\n): { [ele: number]: number[][] } {\n if (!interval) {\n return {};\n }\n const multiplier = extent / (tile.width - 1);",
"score": 26.72214313059284
},
{
"filename": "src/performance.ts",
"retrieved_chunk": " resources: PerformanceResourceTiming[] = [];\n markFinish: () => void;\n tilesFetched: number = 0;\n timeOrigin: number = timeOrigin;\n constructor(name: TimingCategory) {\n this.markFinish = this.marker(name);\n }\n finish = (url: string): Timing => {\n this.markFinish();\n const get = (type: TimingCategory): number | undefined => {",
"score": 18.80998437772999
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " id: number;\n error?: string;\n response?: any;\n timings: Timing;\n}\ninterface Request {\n type: \"request\";\n id?: number;\n name: string;\n args: any[];",
"score": 18.33933274304884
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " let tld: number, trd: number, bld: number, brd: number;\n let r: number, c: number;\n const segments: { [ele: string]: number[][] } = {};\n const fragmentByStartByLevel: Map<number, Map<number, Fragment>> = new Map();\n const fragmentByEndByLevel: Map<number, Map<number, Fragment>> = new Map();\n function interpolate(\n point: [number, number],\n threshold: number,\n accept: (x: number, y: number) => void,\n ) {",
"score": 16.261247333940975
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": "import { DemTile } from \"./types\";\nconst MIN_VALID_M = -12000;\nconst MAX_VALID_M = 9000;\nfunction defaultIsValid(number: number): boolean {\n return !isNaN(number) && number >= MIN_VALID_M && number <= MAX_VALID_M;\n}\n/** A tile containing elevation values aligned to a grid. */\nexport class HeightTile {\n get: (x: number, y: number) => number;\n width: number;",
"score": 14.890949989212817
}
] | typescript | const size = heightTile.width; |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][][]): HeightTile {
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
| return HeightTile.fromRawDem({ |
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
const size = heightTile.width;
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile.height,
(x, y) => {
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
rotatedResult[ele] = isolines[ele].map((eles) => {
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " flattenDeep([\n [5, 5, 5, 5],\n [5, 15, 15, 5],\n [5, 15, 15, 5],\n [5, 5, 5, 5],\n ]),\n ),\n width: 4,\n height: 4,\n };",
"score": 42.329473976948144
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": "const expectedElevations = Float32Array.from(\n flattenDeep([\n [5, 5, 5, 5],\n [5, 15, 15, 5],\n [5, 15, 15, 5],\n [5, 5, 5, 5],\n ]),\n);\ntest(\"e2e fetch tile and shared DEM protocol share cache\", async () => {\n global.fetch = jest.fn().mockImplementation(async () => {",
"score": 39.90239357114088
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": " */\n const subsampled = HeightTile.combineNeighbors(neighbors)\n ?.subsamplePixelCenters(2)\n .averagePixelCentersToGrid();\n const notSubsampled =\n HeightTile.combineNeighbors(neighbors)?.averagePixelCentersToGrid();\n expect(subsampled).toMatchObject({\n width: 5,\n height: 5,\n });",
"score": 35.457758782890004
},
{
"filename": "src/height-tile.test.ts",
"retrieved_chunk": "import { HeightTile } from \"./height-tile\";\nconst initialTile = HeightTile.fromRawDem({\n width: 2,\n height: 2,\n data: Float32Array.from([0, 1, 2, 3]),\n});\ntest(\"raw tile\", () => {\n expect(initialTile.get(0, 0)).toBe(0);\n expect(initialTile.get(1, 0)).toBe(1);\n expect(initialTile.get(1, 1)).toBe(3);",
"score": 33.09071339956782
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " * Returns a new tile scaled up by `factor` with pixel values that are subsampled using\n * bilinear interpolation between the original height tile values.\n *\n * The original and result tile are assumed to represent values taken at the center of each pixel.\n */\n subsamplePixelCenters = (factor: number): HeightTile => {\n const lerp = (a: number, b: number, f: number) =>\n isNaN(a) ? b : isNaN(b) ? a : a + (b - a) * f;\n if (factor <= 1) return this;\n const sub = 0.5 - 1 / (2 * factor);",
"score": 32.053249167885724
}
] | typescript | return HeightTile.fromRawDem({ |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][][]): HeightTile {
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
return HeightTile.fromRawDem({
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
const size = heightTile.width;
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile.height,
(x, y) => {
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
const | isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0); |
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
rotatedResult[ele] = isolines[ele].map((eles) => {
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " }\n const center = { x: Math.round(xSum / 253), y: Math.round(ySum / 253) };\n expect(center).toMatchObject({\n x: 2049,\n y: 2052,\n });\n expect(timings).toMatchObject([\n {\n tilesUsed: 9,\n process: 0,",
"score": 29.53911201729179
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": "export default function generateIsolines(\n interval: number,\n tile: HeightTile,\n extent: number = 4096,\n buffer: number = 1,\n): { [ele: number]: number[][] } {\n if (!interval) {\n return {};\n }\n const multiplier = extent / (tile.width - 1);",
"score": 21.020177669934267
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " this.start = start;\n this.end = end;\n this.points = [];\n this.append = this.append.bind(this);\n this.prepend = this.prepend.bind(this);\n }\n append(x: number, y: number) {\n this.points.push(Math.round(x), Math.round(y));\n }\n prepend(x: number, y: number) {",
"score": 18.262369536812663
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " [],\n];\nfunction index(width: number, x: number, y: number, point: [number, number]) {\n x = x * 2 + point[0];\n y = y * 2 + point[1];\n return x + y * (width + 1) * 2;\n}\nfunction ratio(a: number, b: number, c: number) {\n return (b - a) / (c - a);\n}",
"score": 16.575144436669998
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " split = (subz: number, subx: number, suby: number): HeightTile => {\n if (subz === 0) return this;\n const by = 1 << subz;\n const dx = (subx * this.width) / by;\n const dy = (suby * this.height) / by;\n return new HeightTile(this.width / by, this.height / by, (x, y) =>\n this.get(x + dx, y + dy),\n );\n };\n /**",
"score": 15.609572060906105
}
] | typescript | isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0); |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
finish = (url: string): Timing => {
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this.tilesFetched += timings.tilesUsed;
| const offset = timings.origin - this.timeOrigin; |
for (const category in timings.marks) {
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?.map((ns) => ns.map((n) => n + offset)) || []),
);
}
this.resources.push(
...timings.resources.map((rt) => applyOffset(rt, offset)),
);
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(tile.width).toBe(4);\n expect(tile.height).toBe(4);\n const tile2 = await source.getDemTile(1, 2, 3);\n expect(tile2.data).toEqual(expectedElevations);\n const timings: Timing[] = [];\n source.onTiming((timing) => timings.push(timing));\n const fetched = await new Promise((resolve, reject) => {\n source.sharedDemProtocol(\n {\n url: source.sharedDemProtocolUrl",
"score": 30.50717586956546
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " ): CancelablePromise<R> {\n const thisId = ++id;\n const value: Promise<R> = new Promise((resolve, reject) => {\n this.postMessage(\n { id: thisId, type: \"request\", name, args },\n transferrables,\n );\n this.callbacks[thisId] = (error, result, timings) => {\n timer?.addAll(timings);\n if (error) reject(error);",
"score": 26.619864428648736
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " },\n transferrables,\n );\n } catch (e: any) {\n this.postMessage({\n id: message.id,\n type: \"response\",\n error: e?.toString() || \"error\",\n timings: timer.finish(url),\n });",
"score": 25.899631648842753
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " try {\n const response = await request.value;\n const transferrables = (response as IsTransferrable)\n ?.transferrables;\n this.postMessage(\n {\n id: message.id,\n type: \"response\",\n response,\n timings: timer.finish(url),",
"score": 24.19303069368294
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " source.onTiming((timing) => timings.push(timing));\n const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {\n source.contourProtocol(\n {\n url: source\n .contourProtocolUrl({\n thresholds: {\n 10: 10,\n },\n buffer: 0,",
"score": 22.66546638001386
}
] | typescript | const offset = timings.origin - this.timeOrigin; |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
finish = (url: string): Timing => {
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this.tilesFetched += timings.tilesUsed;
const offset = timings.origin - this.timeOrigin;
for (const category in timings.marks) {
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?.map((ns) => ns | .map((n) => n + offset)) || []),
); |
}
this.resources.push(
...timings.resources.map((rt) => applyOffset(rt, offset)),
);
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " /** Time spent generating isolines and rendering the vector tile, or `undefined` if it was cached */\n process?: number;\n wait: number;\n /** Number of tiles used for generation, even if they were cached */\n tilesUsed: number;\n /** Map from category (fetch, main, isoline) to list of start/end timestamps */\n marks: {\n [key in TimingCategory]?: number[][];\n };\n /** Detailed timing for all resources actually fetched (not cached) to generate this tile */",
"score": 38.45018016436532
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " ): CancelablePromise<R> {\n const thisId = ++id;\n const value: Promise<R> = new Promise((resolve, reject) => {\n this.postMessage(\n { id: thisId, type: \"request\", name, args },\n transferrables,\n );\n this.callbacks[thisId] = (error, result, timings) => {\n timer?.addAll(timings);\n if (error) reject(error);",
"score": 34.892116744961854
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(fetched).toEqual(Uint8Array.from([1, 2]).buffer);\n expect(global.fetch).toBeCalledTimes(1);\n expect(global.fetch).toBeCalledWith(\n \"https://example/1/2/3.png\",\n expect.anything(),\n );\n expect(timings).toMatchObject([\n {\n duration: 0,\n marks: {",
"score": 30.80821995533174
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " try {\n const response = await request.value;\n const transferrables = (response as IsTransferrable)\n ?.transferrables;\n this.postMessage(\n {\n id: message.id,\n type: \"response\",\n response,\n timings: timer.finish(url),",
"score": 27.785286474484757
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " .map(([key, ...values]) => [key, values]),\n );\n}\nexport function encodeOptions({\n thresholds,\n ...rest\n}: GlobalContourTileOptions): string {\n return sortedEntries({ thresholds: encodeThresholds(thresholds), ...rest })\n .map(\n ([key, value]) =>",
"score": 27.08331692335106
}
] | typescript | .map((n) => n + offset)) || []),
); |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
finish = (url: string): Timing => {
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this.tilesFetched += timings.tilesUsed;
const offset = timings.origin - this.timeOrigin;
| for (const category in timings.marks) { |
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?.map((ns) => ns.map((n) => n + offset)) || []),
);
}
this.resources.push(
...timings.resources.map((rt) => applyOffset(rt, offset)),
);
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(tile.width).toBe(4);\n expect(tile.height).toBe(4);\n const tile2 = await source.getDemTile(1, 2, 3);\n expect(tile2.data).toEqual(expectedElevations);\n const timings: Timing[] = [];\n source.onTiming((timing) => timings.push(timing));\n const fetched = await new Promise((resolve, reject) => {\n source.sharedDemProtocol(\n {\n url: source.sharedDemProtocolUrl",
"score": 34.825878371904395
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " ): CancelablePromise<R> {\n const thisId = ++id;\n const value: Promise<R> = new Promise((resolve, reject) => {\n this.postMessage(\n { id: thisId, type: \"request\", name, args },\n transferrables,\n );\n this.callbacks[thisId] = (error, result, timings) => {\n timer?.addAll(timings);\n if (error) reject(error);",
"score": 31.25738699955719
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " },\n transferrables,\n );\n } catch (e: any) {\n this.postMessage({\n id: message.id,\n type: \"response\",\n error: e?.toString() || \"error\",\n timings: timer.finish(url),\n });",
"score": 29.68514293361188
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " try {\n const response = await request.value;\n const transferrables = (response as IsTransferrable)\n ?.transferrables;\n this.postMessage(\n {\n id: message.id,\n type: \"response\",\n response,\n timings: timer.finish(url),",
"score": 28.064717656964298
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " source.onTiming((timing) => timings.push(timing));\n const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {\n source.contourProtocol(\n {\n url: source\n .contourProtocolUrl({\n thresholds: {\n 10: 10,\n },\n buffer: 0,",
"score": 26.42793391033812
}
] | typescript | for (const category in timings.marks) { |
/*
Adapted from d3-contour https://github.com/d3/d3-contour
Copyright 2012-2023 Mike Bostock
Permission to use, copy, modify, and/or distribute this software for any purpose
with or without fee is hereby granted, provided that the above copyright notice
and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
*/
import type { HeightTile } from "./height-tile";
class Fragment {
start: number;
end: number;
points: number[];
constructor(start: number, end: number) {
this.start = start;
this.end = end;
this.points = [];
this.append = this.append.bind(this);
this.prepend = this.prepend.bind(this);
}
append(x: number, y: number) {
this.points.push(Math.round(x), Math.round(y));
}
prepend(x: number, y: number) {
this.points.splice(0, 0, Math.round(x), Math.round(y));
}
lineString() {
return this.toArray();
}
isEmpty() {
return this.points.length < 2;
}
appendFragment(other: Fragment) {
this.points.push(...other.points);
this.end = other.end;
}
toArray() {
return this.points;
}
}
const CASES: [number, number][][][] = [
[],
[
[
[1, 2],
[0, 1],
],
],
[
[
[2, 1],
[1, 2],
],
],
[
[
[2, 1],
[0, 1],
],
],
[
[
[1, 0],
[2, 1],
],
],
[
[
[1, 2],
[0, 1],
],
[
[1, 0],
[2, 1],
],
],
[
[
[1, 0],
[1, 2],
],
],
[
[
[1, 0],
[0, 1],
],
],
[
[
[0, 1],
[1, 0],
],
],
[
[
[1, 2],
[1, 0],
],
],
[
[
[0, 1],
[1, 0],
],
[
[2, 1],
[1, 2],
],
],
[
[
[2, 1],
[1, 0],
],
],
[
[
[0, 1],
[2, 1],
],
],
[
[
[1, 2],
[2, 1],
],
],
[
[
[0, 1],
[1, 2],
],
],
[],
];
function index(width: number, x: number, y: number, point: [number, number]) {
x = x * 2 + point[0];
y = y * 2 + point[1];
return x + y * (width + 1) * 2;
}
function ratio(a: number, b: number, c: number) {
return (b - a) / (c - a);
}
/**
* Generates contour lines from a HeightTile
*
* @param interval Vertical distance between contours
* @param tile The input height tile, where values represent the height at the top-left of each pixel
* @param extent Vector tile extent (default 4096)
* @param buffer How many pixels into each neighboring tile to include in a tile
* @returns an object where keys are the elevation, and values are a list of `[x1, y1, x2, y2, ...]`
* contour lines in tile coordinates
*/
export default function generateIsolines(
interval: number,
tile: HeightTile,
extent: number = 4096,
buffer: number = 1,
): { [ele: number]: number[][] } {
if (!interval) {
return {};
}
const multiplier = extent / (tile.width - 1);
let tld: number, trd: number, bld: number, brd: number;
let r: number, c: number;
const segments: { [ele: string]: number[][] } = {};
const fragmentByStartByLevel: Map<number, Map<number, Fragment>> = new Map();
const fragmentByEndByLevel: Map<number, Map<number, Fragment>> = new Map();
function interpolate(
point: [number, number],
threshold: number,
accept: (x: number, y: number) => void,
) {
if (point[0] === 0) {
// left
accept(
multiplier * (c - 1),
multiplier * (r - ratio(bld, threshold, tld)),
);
} else if (point[0] === 2) {
// right
accept(multiplier * c, multiplier * (r - ratio(brd, threshold, trd)));
} else if (point[1] === 0) {
// top
accept(
multiplier * (c - ratio(trd, threshold, tld)),
multiplier * (r - 1),
);
} else {
// bottom
accept(multiplier * (c - ratio(brd, threshold, bld)), multiplier * r);
}
}
// Most marching-squares implementations (d3-contour, gdal-contour) make one pass through the matrix per threshold.
// This implementation makes a single pass through the matrix, building up all of the contour lines at the
// same time to improve performance.
| for (r = 1 - buffer; r < tile.height + buffer; r++) { |
trd = tile.get(0, r - 1);
brd = tile.get(0, r);
let minR = Math.min(trd, brd);
let maxR = Math.max(trd, brd);
for (c = 1 - buffer; c < tile.width + buffer; c++) {
tld = trd;
bld = brd;
trd = tile.get(c, r - 1);
brd = tile.get(c, r);
const minL = minR;
const maxL = maxR;
minR = Math.min(trd, brd);
maxR = Math.max(trd, brd);
if (isNaN(tld) || isNaN(trd) || isNaN(brd) || isNaN(bld)) {
continue;
}
const min = Math.min(minL, minR);
const max = Math.max(maxL, maxR);
const start = Math.ceil(min / interval) * interval;
const end = Math.floor(max / interval) * interval;
for (let threshold = start; threshold <= end; threshold += interval) {
const tl = tld > threshold;
const tr = trd > threshold;
const bl = bld > threshold;
const br = brd > threshold;
for (const segment of CASES[
(tl ? 8 : 0) | (tr ? 4 : 0) | (br ? 2 : 0) | (bl ? 1 : 0)
]) {
let fragmentByStart = fragmentByStartByLevel.get(threshold);
if (!fragmentByStart)
fragmentByStartByLevel.set(
threshold,
(fragmentByStart = new Map()),
);
let fragmentByEnd = fragmentByEndByLevel.get(threshold);
if (!fragmentByEnd)
fragmentByEndByLevel.set(threshold, (fragmentByEnd = new Map()));
const start = segment[0];
const end = segment[1];
const startIndex = index(tile.width, c, r, start);
const endIndex = index(tile.width, c, r, end);
let f, g;
if ((f = fragmentByEnd.get(startIndex))) {
fragmentByEnd.delete(startIndex);
if ((g = fragmentByStart.get(endIndex))) {
fragmentByStart.delete(endIndex);
if (f === g) {
// closing a ring
interpolate(end, threshold, f.append);
if (!f.isEmpty()) {
let list = segments[threshold];
if (!list) {
segments[threshold] = list = [];
}
list.push(f.lineString());
}
} else {
// connecting 2 segments
f.appendFragment(g);
fragmentByEnd.set((f.end = g.end), f);
}
} else {
// adding to the end of f
interpolate(end, threshold, f.append);
fragmentByEnd.set((f.end = endIndex), f);
}
} else if ((f = fragmentByStart.get(endIndex))) {
fragmentByStart.delete(endIndex);
// extending the start of f
interpolate(start, threshold, f.prepend);
fragmentByStart.set((f.start = startIndex), f);
} else {
// starting a new fragment
const newFrag = new Fragment(startIndex, endIndex);
interpolate(start, threshold, newFrag.append);
interpolate(end, threshold, newFrag.append);
fragmentByStart.set(startIndex, newFrag);
fragmentByEnd.set(endIndex, newFrag);
}
}
}
}
}
for (const [level, fragmentByStart] of fragmentByStartByLevel.entries()) {
let list: number[][] | null = null;
for (const value of fragmentByStart.values()) {
if (!value.isEmpty()) {
if (list == null) {
list = segments[level] || (segments[level] = []);
}
list.push(value.lineString());
}
}
}
return segments;
}
| src/isolines.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " levelKey?: string;\n /** Name of the vector tile layer to put contour lines in */\n contourLayer?: string;\n /** Grid size of the vector tile (default 4096) */\n extent?: number;\n /** How many pixels to generate on each tile into the neighboring tile to reduce rendering artifacts */\n buffer?: number;\n /** When overzooming tiles, subsample to scale up to at least this size to make the contour lines smoother at higher zooms. */\n subsampleBelow?: number;\n}",
"score": 49.262690132466915
},
{
"filename": "src/types.ts",
"retrieved_chunk": "export interface GlobalContourTileOptions extends ContourTileOptions {\n /**\n * Map from zoom level to the `[minor, major]` elevation distance between contour lines.\n *\n * Contour lines without an entry will use the threshold for the next lower zoom.\n *\n * The `level` tag on each contour line will have an integer that corresponds to the largest index in\n * this array that the elevation is a multiple of.\n */\n thresholds: { [n: number]: number | number[] };",
"score": 39.936826671904875
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " ? this\n : new HeightTile(\n this.width,\n this.height,\n (x, y) => this.get(x, y) * multiplier,\n );\n /**\n * Precompute every value from `-bufer, -buffer` to `width + buffer, height + buffer` and serve them\n * out of a `Float32Array`. Until this method is called, all `get` requests are lazy and call all previous\n * methods in the chain up to the root DEM tile.",
"score": 38.96197533816444
},
{
"filename": "src/types.ts",
"retrieved_chunk": " * the z10 `raster-dem` tile plus its 8 neighbors\n *\n * Setting to 1 requests a z9 tile and uses one quadrant of it so that it only needs up to 3\n * neighboring tiles to get the neighboring elevation data. It also improves performance with\n * 512x512 or larger `raster-dem` tiles.\n */\n overzoom?: number;\n /** Key for the elevation property to set on each contour line. */\n elevationKey?: string;\n /** Key for the \"level\" property to set on each contour line. Minor lines have level=0, major have level=1 */",
"score": 38.80249044583797
},
{
"filename": "src/types.ts",
"retrieved_chunk": " cacheControl?: string;\n}\n/** Parameters to use when creating a contour vector tile from raw elevation data */\nexport interface ContourTileOptions {\n /** Factor to scale the elevation meters by to support different units (default 1 for meters) */\n multiplier?: number;\n /**\n * Request `raster-dem` tiles from lower zoom levels to generate the contour vector tile.\n *\n * The default value is 0, which means to generate a contour vector tile at z10, it gets",
"score": 37.46636400563322
}
] | typescript | for (r = 1 - buffer; r < tile.height + buffer; r++) { |
/*
Adapted from d3-contour https://github.com/d3/d3-contour
Copyright 2012-2023 Mike Bostock
Permission to use, copy, modify, and/or distribute this software for any purpose
with or without fee is hereby granted, provided that the above copyright notice
and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
THIS SOFTWARE.
*/
import type { HeightTile } from "./height-tile";
class Fragment {
start: number;
end: number;
points: number[];
constructor(start: number, end: number) {
this.start = start;
this.end = end;
this.points = [];
this.append = this.append.bind(this);
this.prepend = this.prepend.bind(this);
}
append(x: number, y: number) {
this.points.push(Math.round(x), Math.round(y));
}
prepend(x: number, y: number) {
this.points.splice(0, 0, Math.round(x), Math.round(y));
}
lineString() {
return this.toArray();
}
isEmpty() {
return this.points.length < 2;
}
appendFragment(other: Fragment) {
this.points.push(...other.points);
this.end = other.end;
}
toArray() {
return this.points;
}
}
const CASES: [number, number][][][] = [
[],
[
[
[1, 2],
[0, 1],
],
],
[
[
[2, 1],
[1, 2],
],
],
[
[
[2, 1],
[0, 1],
],
],
[
[
[1, 0],
[2, 1],
],
],
[
[
[1, 2],
[0, 1],
],
[
[1, 0],
[2, 1],
],
],
[
[
[1, 0],
[1, 2],
],
],
[
[
[1, 0],
[0, 1],
],
],
[
[
[0, 1],
[1, 0],
],
],
[
[
[1, 2],
[1, 0],
],
],
[
[
[0, 1],
[1, 0],
],
[
[2, 1],
[1, 2],
],
],
[
[
[2, 1],
[1, 0],
],
],
[
[
[0, 1],
[2, 1],
],
],
[
[
[1, 2],
[2, 1],
],
],
[
[
[0, 1],
[1, 2],
],
],
[],
];
function index(width: number, x: number, y: number, point: [number, number]) {
x = x * 2 + point[0];
y = y * 2 + point[1];
return x + y * (width + 1) * 2;
}
function ratio(a: number, b: number, c: number) {
return (b - a) / (c - a);
}
/**
* Generates contour lines from a HeightTile
*
* @param interval Vertical distance between contours
* @param tile The input height tile, where values represent the height at the top-left of each pixel
* @param extent Vector tile extent (default 4096)
* @param buffer How many pixels into each neighboring tile to include in a tile
* @returns an object where keys are the elevation, and values are a list of `[x1, y1, x2, y2, ...]`
* contour lines in tile coordinates
*/
export default function generateIsolines(
interval: number,
tile: HeightTile,
extent: number = 4096,
buffer: number = 1,
): { [ele: number]: number[][] } {
if (!interval) {
return {};
}
| const multiplier = extent / (tile.width - 1); |
let tld: number, trd: number, bld: number, brd: number;
let r: number, c: number;
const segments: { [ele: string]: number[][] } = {};
const fragmentByStartByLevel: Map<number, Map<number, Fragment>> = new Map();
const fragmentByEndByLevel: Map<number, Map<number, Fragment>> = new Map();
function interpolate(
point: [number, number],
threshold: number,
accept: (x: number, y: number) => void,
) {
if (point[0] === 0) {
// left
accept(
multiplier * (c - 1),
multiplier * (r - ratio(bld, threshold, tld)),
);
} else if (point[0] === 2) {
// right
accept(multiplier * c, multiplier * (r - ratio(brd, threshold, trd)));
} else if (point[1] === 0) {
// top
accept(
multiplier * (c - ratio(trd, threshold, tld)),
multiplier * (r - 1),
);
} else {
// bottom
accept(multiplier * (c - ratio(brd, threshold, bld)), multiplier * r);
}
}
// Most marching-squares implementations (d3-contour, gdal-contour) make one pass through the matrix per threshold.
// This implementation makes a single pass through the matrix, building up all of the contour lines at the
// same time to improve performance.
for (r = 1 - buffer; r < tile.height + buffer; r++) {
trd = tile.get(0, r - 1);
brd = tile.get(0, r);
let minR = Math.min(trd, brd);
let maxR = Math.max(trd, brd);
for (c = 1 - buffer; c < tile.width + buffer; c++) {
tld = trd;
bld = brd;
trd = tile.get(c, r - 1);
brd = tile.get(c, r);
const minL = minR;
const maxL = maxR;
minR = Math.min(trd, brd);
maxR = Math.max(trd, brd);
if (isNaN(tld) || isNaN(trd) || isNaN(brd) || isNaN(bld)) {
continue;
}
const min = Math.min(minL, minR);
const max = Math.max(maxL, maxR);
const start = Math.ceil(min / interval) * interval;
const end = Math.floor(max / interval) * interval;
for (let threshold = start; threshold <= end; threshold += interval) {
const tl = tld > threshold;
const tr = trd > threshold;
const bl = bld > threshold;
const br = brd > threshold;
for (const segment of CASES[
(tl ? 8 : 0) | (tr ? 4 : 0) | (br ? 2 : 0) | (bl ? 1 : 0)
]) {
let fragmentByStart = fragmentByStartByLevel.get(threshold);
if (!fragmentByStart)
fragmentByStartByLevel.set(
threshold,
(fragmentByStart = new Map()),
);
let fragmentByEnd = fragmentByEndByLevel.get(threshold);
if (!fragmentByEnd)
fragmentByEndByLevel.set(threshold, (fragmentByEnd = new Map()));
const start = segment[0];
const end = segment[1];
const startIndex = index(tile.width, c, r, start);
const endIndex = index(tile.width, c, r, end);
let f, g;
if ((f = fragmentByEnd.get(startIndex))) {
fragmentByEnd.delete(startIndex);
if ((g = fragmentByStart.get(endIndex))) {
fragmentByStart.delete(endIndex);
if (f === g) {
// closing a ring
interpolate(end, threshold, f.append);
if (!f.isEmpty()) {
let list = segments[threshold];
if (!list) {
segments[threshold] = list = [];
}
list.push(f.lineString());
}
} else {
// connecting 2 segments
f.appendFragment(g);
fragmentByEnd.set((f.end = g.end), f);
}
} else {
// adding to the end of f
interpolate(end, threshold, f.append);
fragmentByEnd.set((f.end = endIndex), f);
}
} else if ((f = fragmentByStart.get(endIndex))) {
fragmentByStart.delete(endIndex);
// extending the start of f
interpolate(start, threshold, f.prepend);
fragmentByStart.set((f.start = startIndex), f);
} else {
// starting a new fragment
const newFrag = new Fragment(startIndex, endIndex);
interpolate(start, threshold, newFrag.append);
interpolate(end, threshold, newFrag.append);
fragmentByStart.set(startIndex, newFrag);
fragmentByEnd.set(endIndex, newFrag);
}
}
}
}
}
for (const [level, fragmentByStart] of fragmentByStartByLevel.entries()) {
let list: number[][] | null = null;
for (const value of fragmentByStart.values()) {
if (!value.isEmpty()) {
if (list == null) {
list = segments[level] || (segments[level] = []);
}
list.push(value.lineString());
}
}
}
return segments;
}
| src/isolines.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/isolines.test.ts",
"retrieved_chunk": " rotation: number,\n interval: number,\n heightTile: HeightTile,\n expected: { [ele: number]: number[][] },\n) {\n test(name, () => {\n const size = heightTile.width;\n const center = (size - 1) / 2;\n const rotatedHeightTile = new HeightTile(\n heightTile.width,",
"score": 30.53632942776266
},
{
"filename": "src/isolines.test.ts",
"retrieved_chunk": " return heightTile.get(nx, ny);\n },\n );\n const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);\n const rotatedResult: { [ele: number]: number[][] } = {};\n for (const ele in isolines) {\n rotatedResult[ele] = isolines[ele].map((eles) => {\n const rotatedLine: number[] = [...eles];\n for (let i = 0; i < rotatedLine.length; i += 2) {\n const [x, y] = rotate(",
"score": 28.24837414077957
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " timer?: Timer,\n ): CancelablePromise<ContourTile> {\n const {\n levels,\n multiplier = 1,\n buffer = 1,\n extent = 4096,\n contourLayer = \"contours\",\n elevationKey = \"ele\",\n levelKey = \"level\",",
"score": 26.79772215574354
},
{
"filename": "src/isolines.test.ts",
"retrieved_chunk": " heightTile: HeightTile,\n expected: { [ele: number]: number[][] },\n) {\n for (const rotation of [0, 90, 180, 270]) {\n runTest(\n `${name} (rotation=${rotation})`,\n rotation,\n interval,\n heightTile,\n expected,",
"score": 24.613242990824524
},
{
"filename": "src/vtpbf.ts",
"retrieved_chunk": " */\nexport default function encodeVectorTile(tile: Tile): Uint8Array {\n const pbf = new Pbf();\n for (const id in tile.layers) {\n const layer = tile.layers[id];\n if (!layer.extent) {\n layer.extent = tile.extent;\n }\n pbf.writeMessage(3, writeLayer, { ...layer, id });\n }",
"score": 24.489442179850055
}
] | typescript | const multiplier = extent / (tile.width - 1); |
import { flattenDeep } from "lodash";
import { HeightTile } from "./height-tile";
import generateIsolines from "./isolines";
runTestWithRotations("corner halfway", 2, heightTile(1, 1, 1, 3), {
2: [[1, 0.5, 0.5, 1]],
});
runTestWithRotations(
"corner above most of the way",
2,
heightTile(1, 1, 1, 2.33333),
{
2: [[1, 0.75, 0.75, 1]],
},
);
runTestWithRotations("two contours", 2, heightTile(1, 1, 1, 5), {
2: [[1, 0.25, 0.25, 1]],
4: [[1, 0.75, 0.75, 1]],
});
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations(
"edge above threshold",
2,
heightTile(1, 1, 2.33333, 2.33333),
{
2: [[1, 0.75, 0, 0.75]],
},
);
runTestWithRotations("corner up to threshold", 2, heightTile(1, 1, 1, 2), {});
runTestWithRotations("omit empty point??", 2, heightTile(2, 3, 3, 3), {
2: [[0, 0, 0, 0]],
});
runTestWithRotations("side up to threshold", 2, heightTile(1, 2, 1, 2), {});
runTestWithRotations("side down to threshold", 2, heightTile(2, 3, 2, 3), {
2: [[0, 0, 0, 1]],
});
runTestWithRotations(
"threshold middle",
2,
heightTile([
[1, 1, 1, 1],
[1, 2, 1, 1],
[1, 2, 1, 1],
[1, 1, 1, 1],
]),
{},
);
runTestWithRotations(
"corner below threshold",
2,
heightTile([
[1, 2.3333333],
[2.3333333, 2.3333333],
]),
{
2: [[0.75, 0, 0, 0.75]],
},
);
runTest(
"saddle",
0,
2,
heightTile([
[1, 2.3333333],
[2.3333333, 1],
]),
{
2: [
[0.25, 1, 0, 0.75],
[0.75, 0, 1, 0.25],
],
},
);
runTestWithRotations("no contours", 2, heightTile(1, 1, 1, 1), {});
runTestWithRotations(
"connect segments",
2,
heightTile([
[1, 3, 3],
[1, 1, 3],
[1, 1, 1],
]),
{
2: [[0.5, 0, 1, 0.5, 1.5, 1, 2, 1.5]],
},
);
runTest(
"center point above",
0,
2,
heightTile([
[1, 1, 1],
[1, 3, 1],
[1, 1, 1],
]),
{
2: [[1.5, 1, 1, 0.5, 0.5, 1, 1, 1.5, 1.5, 1]],
},
);
runTest(
"center point below",
0,
2,
heightTile([
[3, 3, 3],
[3, 1, 3],
[3, 3, 3],
]),
{
2: [[1, 1.5, 0.5, 1, 1, 0.5, 1.5, 1, 1, 1.5]],
},
);
function heightTile(...values: number[] | number[][][]): HeightTile {
const flattened = flattenDeep(values);
const size = Math.sqrt(flattened.length);
return HeightTile.fromRawDem({
width: size,
height: size,
data: Float32Array.from(flattened),
});
}
function runTestWithRotations(
name: string,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
for (const rotation of [0, 90, 180, 270]) {
runTest(
`${name} (rotation=${rotation})`,
rotation,
interval,
heightTile,
expected,
);
}
}
function rotate(
[x, y]: [number, number],
[ax, ay]: [number, number],
angle: number,
): [number, number] {
const theta = (angle * Math.PI) / 180;
const sin = Math.sin(theta);
const cos = Math.cos(theta);
const rx = x - ax;
const ry = y - ay;
return [round(ax + rx * cos - ry * sin), round(ay + ry * cos + rx * sin)];
}
function round(n: number): number {
return Math.round(n * 1000 + 0.001) / 1000;
}
function runTest(
name: string,
rotation: number,
interval: number,
heightTile: HeightTile,
expected: { [ele: number]: number[][] },
) {
test(name, () => {
const size = heightTile.width;
const center = (size - 1) / 2;
const rotatedHeightTile = new HeightTile(
heightTile.width,
heightTile. | height,
(x, y) => { |
if (x < 0 || x >= size) {
throw new Error(`x=${x}`);
} else if (y < 0 || y >= size) {
throw new Error(`y=${y}`);
}
const [nx, ny] = rotate([x, y], [center, center], rotation).map(
round,
) as [number, number];
return heightTile.get(nx, ny);
},
);
const isolines = generateIsolines(interval, rotatedHeightTile, 4096, 0);
const rotatedResult: { [ele: number]: number[][] } = {};
for (const ele in isolines) {
rotatedResult[ele] = isolines[ele].map((eles) => {
const rotatedLine: number[] = [...eles];
for (let i = 0; i < rotatedLine.length; i += 2) {
const [x, y] = rotate(
[
(rotatedLine[i] * (size - 1)) / 4096,
(rotatedLine[i + 1] * (size - 1)) / 4096,
],
[center, center],
rotation,
);
rotatedLine[i] = x;
rotatedLine[i + 1] = y;
}
return rotatedLine;
});
}
expect(rotatedResult).toEqual(expected);
});
}
| src/isolines.test.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " split = (subz: number, subx: number, suby: number): HeightTile => {\n if (subz === 0) return this;\n const by = 1 << subz;\n const dx = (subx * this.width) / by;\n const dy = (suby * this.height) / by;\n return new HeightTile(this.width / by, this.height / by, (x, y) =>\n this.get(x + dx, y + dy),\n );\n };\n /**",
"score": 19.402662963847586
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " */\n materialize = (buffer: number = 2): HeightTile => {\n const stride = this.width + 2 * buffer;\n const data = new Float32Array(stride * (this.height + 2 * buffer));\n let idx = 0;\n for (let y = -buffer; y < this.height + buffer; y++) {\n for (let x = -buffer; x < this.width + buffer; x++) {\n data[idx++] = this.get(x, y);\n }\n }",
"score": 19.331255901514407
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " height: number;\n constructor(\n width: number,\n height: number,\n get: (x: number, y: number) => number,\n ) {\n this.get = get;\n this.width = width;\n this.height = height;\n }",
"score": 19.233399403124803
},
{
"filename": "src/height-tile.ts",
"retrieved_chunk": " if (!mainTile) {\n return undefined;\n }\n const width = mainTile.width;\n const height = mainTile.height;\n return new HeightTile(width, height, (x, y) => {\n let gridIdx = 0;\n if (y < 0) {\n y += height;\n } else if (y < height) {",
"score": 18.775741378961598
},
{
"filename": "src/isolines.ts",
"retrieved_chunk": " [],\n];\nfunction index(width: number, x: number, y: number, point: [number, number]) {\n x = x * 2 + point[0];\n y = y * 2 + point[1];\n return x + y * (width + 1) * 2;\n}\nfunction ratio(a: number, b: number, c: number) {\n return (b - a) / (c - a);\n}",
"score": 17.848222202623983
}
] | typescript | height,
(x, y) => { |
import { LocalDemManager } from "./dem-manager";
import { Timer } from "./performance";
import {
CancelablePromise,
ContourTile,
FetchResponse,
IndividualContourTileOptions,
InitMessage,
TransferrableDemTile,
} from "./types";
import { prepareContourTile, prepareDemTile } from "./utils";
const noManager = (managerId: number): CancelablePromise<any> => ({
cancel() {},
value: Promise.reject(new Error(`No manager registered for ${managerId}`)),
});
/**
* Receives messages from an actor in the web worker.
*/
export default class WorkerDispatch {
/** There is one worker shared between all managers in the main thread using the plugin, so need to store each of their configurations. */
managers: { [id: number]: LocalDemManager } = {};
init = (message: InitMessage): CancelablePromise<void> => {
this.managers[message.managerId] = new LocalDemManager(
message.demUrlPattern,
message.cacheSize,
message.encoding,
message.maxzoom,
message.timeoutMs,
);
return { cancel() {}, value: Promise.resolve() };
};
fetchTile = (
managerId: number,
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> =>
this.managers[managerId]?.fetchTile(z, x, y, timer) || noManager(managerId);
fetchAndParseTile = (
managerId: number,
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<TransferrableDemTile> =>
prepareDemTile(
| this.managers[managerId]?.fetchAndParseTile(z, x, y, timer) ||
noManager(managerId),
true,
); |
fetchContourTile = (
managerId: number,
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> =>
prepareContourTile(
this.managers[managerId]?.fetchContourTile(z, x, y, options, timer) ||
noManager(managerId),
);
}
| src/worker-dispatch.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " ): CancelablePromise<FetchResponse> =>\n this.actor.send(\"fetchTile\", [], timer, this.managerId, z, x, y);\n fetchAndParseTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> =>\n this.actor.send(\"fetchAndParseTile\", [], timer, this.managerId, z, x, y);\n fetchContourTile = (",
"score": 52.8942359438673
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " maxzoom,\n managerId,\n timeoutMs,\n }).value;\n }\n fetchTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,",
"score": 40.120550570803815
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " loaded: Promise<any>;\n fetchTile(\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse>;\n fetchAndParseTile(\n z: number,\n x: number,",
"score": 38.16024174294293
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile>;\n fetchContourTile(\n z: number,\n x: number,\n y: number,\n options: IndividualContourTileOptions,\n timer?: Timer,\n ): CancelablePromise<ContourTile>;",
"score": 34.92676276876227
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " fetchTile(\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse> {\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 34.35877001348292
}
] | typescript | this.managers[managerId]?.fetchAndParseTile(z, x, y, timer) ||
noManager(managerId),
true,
); |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
finish = (url: string): Timing => {
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this. | tilesFetched += timings.tilesUsed; |
const offset = timings.origin - this.timeOrigin;
for (const category in timings.marks) {
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?.map((ns) => ns.map((n) => n + offset)) || []),
);
}
this.resources.push(
...timings.resources.map((rt) => applyOffset(rt, offset)),
);
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " expect(tile.width).toBe(4);\n expect(tile.height).toBe(4);\n const tile2 = await source.getDemTile(1, 2, 3);\n expect(tile2.data).toEqual(expectedElevations);\n const timings: Timing[] = [];\n source.onTiming((timing) => timings.push(timing));\n const fetched = await new Promise((resolve, reject) => {\n source.sharedDemProtocol(\n {\n url: source.sharedDemProtocolUrl",
"score": 26.18847336722653
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " },\n transferrables,\n );\n } catch (e: any) {\n this.postMessage({\n id: message.id,\n type: \"response\",\n error: e?.toString() || \"error\",\n timings: timer.finish(url),\n });",
"score": 20.554003487612324
},
{
"filename": "src/actor.ts",
"retrieved_chunk": " ): CancelablePromise<R> {\n const thisId = ++id;\n const value: Promise<R> = new Promise((resolve, reject) => {\n this.postMessage(\n { id: thisId, type: \"request\", name, args },\n transferrables,\n );\n this.callbacks[thisId] = (error, result, timings) => {\n timer?.addAll(timings);\n if (error) reject(error);",
"score": 20.215274260464348
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " }\n timer?.fetchTile(url);\n const mark = timer?.marker(\"fetch\");\n return withTimeout(this.timeoutMs, {\n value: fetch(url, options).then(async (response) => {\n mark?.();\n if (!response.ok) {\n throw new Error(`Bad response: ${response.status} for ${url}`);\n }\n return {",
"score": 19.817513831826524
},
{
"filename": "src/e2e.test.ts",
"retrieved_chunk": " source.onTiming((timing) => timings.push(timing));\n const contourTile: ArrayBuffer = await new Promise((resolve, reject) => {\n source.contourProtocol(\n {\n url: source\n .contourProtocolUrl({\n thresholds: {\n 10: 10,\n },\n buffer: 0,",
"score": 18.902998849689602
}
] | typescript | tilesFetched += timings.tilesUsed; |
import { Timing, TimingCategory } from "./types";
export const perf =
typeof performance !== "undefined" ? performance : undefined;
export const timeOrigin = perf
? perf.timeOrigin || new Date().getTime() - perf.now()
: new Date().getTime();
export function getResourceTiming(url: string): PerformanceResourceTiming[] {
return JSON.parse(
JSON.stringify(
(perf?.getEntriesByName?.(url) as
| PerformanceResourceTiming[]
| undefined) || [],
),
);
}
export function now(): number {
return perf ? perf.now() : new Date().getTime();
}
function flatten<T>(input: T[][]): T[] {
const result: T[] = [];
for (const list of input) {
result.push(...list);
}
return result;
}
/** Utility for tracking how long tiles take to generate, and where the time is going. */
export class Timer {
marks: { [key in TimingCategory]?: number[][] } = {};
urls: string[] = [];
fetched: string[] = [];
resources: PerformanceResourceTiming[] = [];
markFinish: () => void;
tilesFetched: number = 0;
timeOrigin: number = timeOrigin;
constructor(name: TimingCategory) {
this.markFinish = this.marker(name);
}
finish = (url: string): Timing => {
this.markFinish();
const get = (type: TimingCategory): number | undefined => {
const all = this.marks[type] || [];
const max = Math.max(...all.map((ns) => Math.max(...ns)));
const min = Math.min(...all.map((ns) => Math.min(...ns)));
return Number.isFinite(max) ? max - min : undefined;
};
const duration = get("main") || 0;
const fetch = get("fetch");
const decode = get("decode");
const process = get("isoline");
return {
url,
tilesUsed: this.tilesFetched,
origin: this.timeOrigin,
marks: this.marks,
resources: [
...this.resources,
...flatten(this.fetched.map(getResourceTiming)),
],
duration,
fetch,
decode,
process,
wait: duration - (fetch || 0) - (decode || 0) - (process || 0),
};
};
error = (url: string): Timing => ({ ...this.finish(url), error: true });
marker = (category: TimingCategory): (() => void) => {
if (!this.marks[category]) {
this.marks[category] = [];
}
const marks = [now()];
this.marks[category]?.push(marks);
return () => marks.push(now());
};
useTile = (url: string): void => {
if (this.urls.indexOf(url) < 0) {
this.urls.push(url);
this.tilesFetched++;
}
};
fetchTile = (url: string): void => {
if (this.fetched.indexOf(url) < 0) {
this.fetched.push(url);
}
};
addAll = (timings: Timing) => {
this.tilesFetched += timings.tilesUsed;
const offset = timings.origin - this.timeOrigin;
for (const category in timings.marks) {
const key = category as TimingCategory;
const ourList = this.marks[key] || (this.marks[key] = []);
ourList.push(
...(timings.marks[key]?.map((ns) => ns.map((n) => n + offset)) || []),
);
}
this.resources.push(
| ...timings.resources.map((rt) => applyOffset(rt, offset)),
); |
};
}
const startOrEnd = /(Start$|End$|^start|^end)/;
function applyOffset(obj: any, offset: number): PerformanceResourceTiming {
const result: { [_: string]: number } = {};
for (const key in obj) {
if (obj[key] !== 0 && startOrEnd.test(key)) {
result[key] = Number(obj[key]) + offset;
} else {
result[key] = obj[key];
}
}
return result as any as PerformanceResourceTiming;
}
| src/performance.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/types.ts",
"retrieved_chunk": " /** Time spent generating isolines and rendering the vector tile, or `undefined` if it was cached */\n process?: number;\n wait: number;\n /** Number of tiles used for generation, even if they were cached */\n tilesUsed: number;\n /** Map from category (fetch, main, isoline) to list of start/end timestamps */\n marks: {\n [key in TimingCategory]?: number[][];\n };\n /** Detailed timing for all resources actually fetched (not cached) to generate this tile */",
"score": 39.746747827621135
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " .map(([key, ...values]) => [key, values]),\n );\n}\nexport function encodeOptions({\n thresholds,\n ...rest\n}: GlobalContourTileOptions): string {\n return sortedEntries({ thresholds: encodeThresholds(thresholds), ...rest })\n .map(\n ([key, value]) =>",
"score": 31.70921949528206
},
{
"filename": "src/utils.ts",
"retrieved_chunk": " const entries = Object.entries(object);\n entries.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));\n return entries;\n}\nfunction encodeThresholds(thresholds: {\n [n: number]: number | number[];\n}): string {\n return sortedEntries(thresholds)\n .map(([key, value]) =>\n [key, ...(typeof value === \"number\" ? [value] : value)].join(\"*\"),",
"score": 27.54108567089862
},
{
"filename": "src/vtpbf.ts",
"retrieved_chunk": " let keyIndex = keycache[key];\n if (value === null) continue; // don't encode null value properties\n if (typeof keyIndex === \"undefined\") {\n keys.push(key);\n keyIndex = keys.length - 1;\n keycache[key] = keyIndex;\n }\n pbf.writeVarint(keyIndex);\n const type = typeof value;\n if (type !== \"string\" && type !== \"boolean\" && type !== \"number\") {",
"score": 26.571421994246457
},
{
"filename": "src/cache.ts",
"retrieved_chunk": " get = (key: K, supplier: (key: K) => Promise<V>): Promise<V> =>\n this.getCancelable(key, (key) => ({\n value: supplier(key),\n cancel: () => {},\n })).value;\n getCancelable = (\n key: K,\n supplier: (key: K) => CancelablePromise<V>,\n ): { value: Promise<V>; cancel: () => void } => {\n let result: CacheItem<V> | undefined = this.items.get(key);",
"score": 24.950744513582652
}
] | typescript | ...timings.resources.map((rt) => applyOffset(rt, offset)),
); |
import { LocalDemManager } from "./dem-manager";
import { Timer } from "./performance";
import {
CancelablePromise,
ContourTile,
FetchResponse,
IndividualContourTileOptions,
InitMessage,
TransferrableDemTile,
} from "./types";
import { prepareContourTile, prepareDemTile } from "./utils";
const noManager = (managerId: number): CancelablePromise<any> => ({
cancel() {},
value: Promise.reject(new Error(`No manager registered for ${managerId}`)),
});
/**
* Receives messages from an actor in the web worker.
*/
export default class WorkerDispatch {
/** There is one worker shared between all managers in the main thread using the plugin, so need to store each of their configurations. */
managers: { [id: number]: LocalDemManager } = {};
init = (message: InitMessage): CancelablePromise<void> => {
this.managers[message.managerId] = new LocalDemManager(
message.demUrlPattern,
message.cacheSize,
message.encoding,
message.maxzoom,
message.timeoutMs,
);
return { cancel() {}, value: Promise.resolve() };
};
fetchTile = (
managerId: number,
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<FetchResponse> =>
this.managers[ | managerId]?.fetchTile(z, x, y, timer) || noManager(managerId); |
fetchAndParseTile = (
managerId: number,
z: number,
x: number,
y: number,
timer?: Timer,
): CancelablePromise<TransferrableDemTile> =>
prepareDemTile(
this.managers[managerId]?.fetchAndParseTile(z, x, y, timer) ||
noManager(managerId),
true,
);
fetchContourTile = (
managerId: number,
z: number,
x: number,
y: number,
options: IndividualContourTileOptions,
timer?: Timer,
): CancelablePromise<ContourTile> =>
prepareContourTile(
this.managers[managerId]?.fetchContourTile(z, x, y, options, timer) ||
noManager(managerId),
);
}
| src/worker-dispatch.ts | onthegomap-maplibre-contour-0f2b64d | [
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " ): CancelablePromise<FetchResponse> =>\n this.actor.send(\"fetchTile\", [], timer, this.managerId, z, x, y);\n fetchAndParseTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile> =>\n this.actor.send(\"fetchAndParseTile\", [], timer, this.managerId, z, x, y);\n fetchContourTile = (",
"score": 64.80584487818162
},
{
"filename": "src/remote-dem-manager.ts",
"retrieved_chunk": " maxzoom,\n managerId,\n timeoutMs,\n }).value;\n }\n fetchTile = (\n z: number,\n x: number,\n y: number,\n timer?: Timer,",
"score": 57.09175196620954
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " loaded: Promise<any>;\n fetchTile(\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse>;\n fetchAndParseTile(\n z: number,\n x: number,",
"score": 48.68534074108565
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " fetchTile(\n z: number,\n x: number,\n y: number,\n timer?: Timer,\n ): CancelablePromise<FetchResponse> {\n const url = this.demUrlPattern\n .replace(\"{z}\", z.toString())\n .replace(\"{x}\", x.toString())\n .replace(\"{y}\", y.toString());",
"score": 47.72722006075958
},
{
"filename": "src/dem-manager.ts",
"retrieved_chunk": " y: number,\n timer?: Timer,\n ): CancelablePromise<DemTile>;\n fetchContourTile(\n z: number,\n x: number,\n y: number,\n options: IndividualContourTileOptions,\n timer?: Timer,\n ): CancelablePromise<ContourTile>;",
"score": 37.147854127208774
}
] | typescript | managerId]?.fetchTile(z, x, y, timer) || noManager(managerId); |
import {
ChatCompletionRequestMessage,
Configuration,
CreateChatCompletionRequest,
OpenAIApi,
} from 'openai';
import { GitDiff, OpenAIConfig } from '../interfaces';
import { PromptService } from './prompt.service';
export class OpenAiServiceError extends Error {
constructor(message: string) {
super(message);
this.name = 'OpenAiServiceError';
}
}
export class OpenAiService {
public static async callOpenAI(
config: OpenAIConfig,
messages: ChatCompletionRequestMessage[],
): Promise<string> {
const openAIConfiguration = new Configuration({
apiKey: config.secretOpenaiApiKey,
});
const openaiClient = new OpenAIApi(openAIConfiguration);
const chatCompletionCreate: CreateChatCompletionRequest = {
model: config.openaiModel,
temperature: config.openaiTemperature,
messages: messages,
};
let result;
try {
result = await openaiClient.createChatCompletion(chatCompletionCreate);
} catch (error: any) {
throw new OpenAiServiceError(
`Failed to call OpenAI API: ${error.message}`,
);
}
const assistantMessage = result.data?.choices?.[0]?.message?.content;
if (!assistantMessage) {
throw new OpenAiServiceError('OpenAI did not return a response');
}
return assistantMessage;
}
public static async reviewDiff(
config: OpenAIConfig,
details: GitDiff,
): Promise<string> {
| const prompt = PromptService.generateReviewDiffPrompt(details); |
const messages: ChatCompletionRequestMessage[] = [
{
role: 'system',
content: prompt.system,
},
{
role: 'user',
content: prompt.user,
},
];
return await this.callOpenAI(config, messages);
}
public static async reviewFile(
config: OpenAIConfig,
fileContent: string,
filename: string,
): Promise<string> {
const prompt = PromptService.generateReviewFilePrompt(
fileContent,
filename,
);
const messages: ChatCompletionRequestMessage[] = [
{
role: 'user',
content: prompt.system,
},
{
role: 'user',
content: prompt.user,
},
];
return await this.callOpenAI(config, messages);
}
public static async generateCommitMessage(
config: OpenAIConfig,
details: GitDiff,
commitHistory: string[],
): Promise<string> {
const prompt = PromptService.generateCommitMessagePrompt(
details,
commitHistory,
);
const messages: ChatCompletionRequestMessage[] = [
{
role: 'system',
content: prompt.system,
},
{
role: 'user',
content: prompt.user,
},
];
return await this.callOpenAI(config, messages);
}
}
| src/services/openai.service.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " if (!response.files) {\n throw new FileServiceError('No files were selected from the prompt');\n }\n return response.files;\n }\n public static addLineNumbers(content: string): string {\n return content\n .split('\\n')\n .map((line, index) => `${index + 1} | ${line}`)\n .join('\\n');",
"score": 15.80141513089293
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " private static async checkIsRepo(): Promise<void> {\n if (!(await this.git.checkIsRepo())) {\n throw new GitLocalServiceError(\n 'Current directory is not inside a Git repository.',\n );\n }\n }\n}",
"score": 14.920317291999995
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " choice.title.toLowerCase().includes(inputValue),\n );\n return Promise.resolve(filteredChoices);\n },\n });\n if (!response.file) {\n throw new FileServiceError('No file was selected from the prompt');\n }\n file = response.file;\n }",
"score": 14.895439416655096
},
{
"filename": "src/services/prompt.service.ts",
"retrieved_chunk": "import { GitDiff, Prompt } from '../interfaces';\nexport class PromptService {\n public static generateReviewDiffPrompt(details: GitDiff): Prompt {\n const context =\n 'Your objective is to meticulously review a diff from a git repository and ' +\n 'meticulously identify any requisite alterations to guarantee that the code ' +\n 'is efficient, durable, and secure. Your assessment must be precise and detailed, ' +\n 'only proposing changes that will enhance or repair the code. It is imperative to ' +\n 'accurately pinpoint the exact location in the code that necessitates modification ' +\n 'and explicitly specify the necessary changes. Refrain from suggesting comments and ' +",
"score": 13.195943872067877
},
{
"filename": "src/commands/commit.command.ts",
"retrieved_chunk": " if (!response.value) {\n throw new CommitCommandError('Commit action is required');\n }\n return response.value;\n }\n private async promptReplaceCommitMessage(\n initialMessage: string,\n ): Promise<string> {\n const response = await prompts({\n type: 'text',",
"score": 12.925878517786309
}
] | typescript | const prompt = PromptService.generateReviewDiffPrompt(details); |
import prompts from 'prompts';
import { CommandConfig } from '../interfaces';
import { ConfigService } from '../services/config.service';
import { BaseCommand } from './base.command';
class ConfigCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'ConfigCommandError';
}
}
export class ConfigCommand extends BaseCommand<void> {
constructor(config: CommandConfig) {
super(config);
}
protected async _run(): Promise<void> {
const response = await prompts(
[
{
type: 'password',
name: 'githubToken',
message: 'Please enter your GitHub token:',
validate: (input: string) => {
if (input.length === 0) {
return 'GitHub token cannot be empty!';
}
return true;
},
},
{
type: 'password',
name: 'openApiKey',
message: 'Please enter your OpenAI API key:',
validate: (input: string) => {
if (input.length === 0) {
return 'OpenAI API key cannot be empty!';
}
return true;
},
},
],
{
onCancel: () => {
throw new ConfigCommandError('Setup was cancelled by the user');
},
},
);
await | ConfigService.save({ |
githubToken: response.githubToken,
openaiApiKey: response.openApiKey,
});
}
}
| src/commands/config.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " choice.title.toLowerCase().includes(inputValue),\n );\n return Promise.resolve(filteredChoices);\n },\n });\n if (!response.file) {\n throw new FileServiceError('No file was selected from the prompt');\n }\n file = response.file;\n }",
"score": 10.0355794888386
},
{
"filename": "src/services/prompt.service.ts",
"retrieved_chunk": " 'description by analyzing the diff and commit history. Your objective is ' +\n 'to produce a concise and precise commit description with a maximum length of 40 characters. ' +\n 'Please note that your response should only include the commit description. The commit history ' +\n 'provided is as follows:';\n const commitHistoryContent = `\\`\\`\\`\\n${commitHistory.join('\\n')}\\n\\`\\`\\``;\n const systemContent = `${context}\\n${commitHistoryContent}`;\n return {\n system: systemContent,\n user: `Please generate the perfect commit description for the following code changes:\\n\\`\\`\\`\\n${details.diff}\\n\\`\\`\\``,\n };",
"score": 6.517144528846325
},
{
"filename": "src/services/config.service.ts",
"retrieved_chunk": " throw new ConfigurationError(\n 'Unable to parse the configuration file. Please ensure it is valid JSON.',\n );\n }\n }\n return merge({}, DEFAULT_CONFIG, fileConfig);\n }\n private static validateTemperature(temperature: number): void {\n if (!(temperature >= 0.0 && temperature <= 2.0)) {\n throw new ConfigurationError(",
"score": 6.1363382168022245
},
{
"filename": "src/commands/commit.command.ts",
"retrieved_chunk": " name: 'value',\n message: 'Enter the new commit message:',\n initial: initialMessage,\n });\n if (!response.value) {\n throw new CommitCommandError('Commit message is required');\n }\n return response.value;\n }\n protected async _run(): Promise<void> {",
"score": 5.825898985660459
},
{
"filename": "src/services/openai.service.ts",
"retrieved_chunk": " role: 'user',\n content: prompt.system,\n },\n {\n role: 'user',\n content: prompt.user,\n },\n ];\n return await this.callOpenAI(config, messages);\n }",
"score": 5.69209584891299
}
] | typescript | ConfigService.save({ |
import prompts from 'prompts';
import {
CommandConfig,
CommitAction,
FileSelectionStatus,
GitConfig,
GitDiff,
LocalReviewArgs,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { OpenAiService } from '../services/openai.service';
import { BaseCommand } from './base.command';
class CommitCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'CommitCommandError';
}
}
export class CommitCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async filesDiff(
filenames: string[],
gitConfig: GitConfig,
): Promise<GitDiff> {
logger.info('Reviewing local changes for commit');
return GitLocalService.getFilesDiff(filenames, {
ignorePatterns: gitConfig.ignorePatterns,
});
}
private async selectChangedFiles(): Promise<FileSelectionStatus> {
const fileChanges = await GitLocalService.getFilesChanged();
const selectedFiles = await FileService.selectFiles(fileChanges);
const selectedFileNames = new Set(
selectedFiles.map((file) => file.filename),
);
const allFileNames = fileChanges.map((fileChange) => fileChange.filename);
const unselectedFileNames = allFileNames.filter(
(filename) => !selectedFileNames.has(filename),
);
return {
selectedFileNames: Array.from(selectedFileNames),
unselectedFileNames: unselectedFileNames,
};
}
private async promptShouldContinueCommit(): Promise<boolean> {
const response = await prompts({
type: 'confirm',
name: 'value',
message: 'Do you want to continue commit?',
initial: false,
});
return response.value;
}
private async getCommitAction(): Promise<CommitAction> {
const response = await prompts({
type: 'select',
name: 'value',
message: 'Do you want to commit the message, replace it, or do nothing?',
choices: [
{ title: 'Commit', value: CommitAction.COMMIT },
{ title: 'Replace', value: CommitAction.REPLACE },
{ title: 'Do Nothing', value: CommitAction.SKIP },
],
initial: 0,
});
if (!response.value) {
throw new CommitCommandError('Commit action is required');
}
return response.value;
}
private async promptReplaceCommitMessage(
initialMessage: string,
): Promise<string> {
const response = await prompts({
type: 'text',
name: 'value',
message: 'Enter the new commit message:',
initial: initialMessage,
});
if (!response.value) {
throw new CommitCommandError('Commit message is required');
}
return response.value;
}
protected async _run(): Promise<void> {
let shouldContinueCommit = true;
const config = ConfigService.load();
const gitConfig = config.git;
const openAIConfig = config.llm.openai;
while (shouldContinueCommit) {
const { selectedFileNames, unselectedFileNames } =
await this.selectChangedFiles();
const diff = await this.filesDiff(selectedFileNames, gitConfig);
logger.info('Generating commit message');
const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
);
this.spinner.text = 'Generating commit message...';
this.spinner.start();
const commitMessage = await | OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
); |
this.spinner.stop();
logger.info(commitMessage);
const commitAction = await this.getCommitAction();
shouldContinueCommit = commitAction !== CommitAction.SKIP;
if (commitAction !== CommitAction.SKIP) {
const messageToCommit =
commitAction === CommitAction.COMMIT
? commitMessage
: await this.promptReplaceCommitMessage(commitMessage);
await GitLocalService.commit(messageToCommit, selectedFileNames);
shouldContinueCommit =
unselectedFileNames.length === 0
? false
: await this.promptShouldContinueCommit();
}
}
}
}
| src/commands/commit.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/commands/pull-request-review.command.ts",
"retrieved_chunk": " );\n this.spinner.text = 'Reviewing...';\n this.spinner.start();\n const review = await OpenAiService.reviewDiff(\n openAIConfig,\n pullRequestDiff,\n );\n this.spinner.stop();\n logger.info(review);\n }",
"score": 26.653834807532988
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " }: LocalReviewArgs): Promise<void> {\n const config = ConfigService.load();\n const openAIConfig = config.llm.openai;\n const gitConfig = config.git;\n this.spinner.text = 'Reviewing...';\n const review = filename\n ? await this.reviewFile(openAIConfig, directory, filename)\n : await this.reviewDiff(openAIConfig, gitConfig);\n this.spinner.stop();\n logger.info(review);",
"score": 20.502642526521946
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " const localDiff = await GitLocalService.getLocalDiff({\n ignorePatterns: gitConfig.ignorePatterns,\n });\n logger.info('Reviewing local changes');\n this.spinner.start();\n return OpenAiService.reviewDiff(openAIConfig, localDiff);\n }\n private async reviewFile(\n openAIConfig: OpenAIConfig,\n directory: string,",
"score": 20.233187963669295
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " this.spinner.start();\n return OpenAiService.reviewFile(\n openAIConfig,\n contentWithLineNumbers,\n getFileResponse.filename,\n );\n }\n protected async _run({\n directory,\n filename,",
"score": 19.312828485553407
},
{
"filename": "src/services/git/github.service.ts",
"retrieved_chunk": " if (!diffResponse.ok) {\n throw new GithubServiceError(\n `Failed to fetch PR diff: ${diffResponse.statusText}`,\n );\n }\n const diff = await diffResponse.text();\n const parsedDiff: ParsedFile[] = parse(diff);\n const filteredDiff: ParsedFile[] = this.filterParsedDiff(\n parsedDiff,\n gitConfig.ignorePatterns,",
"score": 11.529714335827355
}
] | typescript | OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
); |
import prompts from 'prompts';
import {
CommandConfig,
CommitAction,
FileSelectionStatus,
GitConfig,
GitDiff,
LocalReviewArgs,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { OpenAiService } from '../services/openai.service';
import { BaseCommand } from './base.command';
class CommitCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'CommitCommandError';
}
}
export class CommitCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async filesDiff(
filenames: string[],
gitConfig: GitConfig,
): Promise<GitDiff> {
logger.info('Reviewing local changes for commit');
return GitLocalService.getFilesDiff(filenames, {
ignorePatterns: gitConfig.ignorePatterns,
});
}
private async selectChangedFiles(): Promise<FileSelectionStatus> {
const fileChanges = await GitLocalService.getFilesChanged();
const selectedFiles = await FileService.selectFiles(fileChanges);
const selectedFileNames = new Set(
selectedFiles.map((file) => file.filename),
);
const allFileNames = fileChanges.map((fileChange) => fileChange.filename);
const unselectedFileNames = allFileNames.filter(
(filename) => !selectedFileNames.has(filename),
);
return {
selectedFileNames: Array.from(selectedFileNames),
unselectedFileNames: unselectedFileNames,
};
}
private async promptShouldContinueCommit(): Promise<boolean> {
const response = await prompts({
type: 'confirm',
name: 'value',
message: 'Do you want to continue commit?',
initial: false,
});
return response.value;
}
private async getCommitAction(): Promise<CommitAction> {
const response = await prompts({
type: 'select',
name: 'value',
message: 'Do you want to commit the message, replace it, or do nothing?',
choices: [
{ title: 'Commit', value: CommitAction.COMMIT },
{ title: 'Replace', value: CommitAction.REPLACE },
{ title: 'Do Nothing', value: CommitAction.SKIP },
],
initial: 0,
});
if (!response.value) {
throw new CommitCommandError('Commit action is required');
}
return response.value;
}
private async promptReplaceCommitMessage(
initialMessage: string,
): Promise<string> {
const response = await prompts({
type: 'text',
name: 'value',
message: 'Enter the new commit message:',
initial: initialMessage,
});
if (!response.value) {
throw new CommitCommandError('Commit message is required');
}
return response.value;
}
protected async _run(): Promise<void> {
let shouldContinueCommit = true;
const config = ConfigService.load();
const gitConfig = config.git;
const openAIConfig = config.llm.openai;
while (shouldContinueCommit) {
const { selectedFileNames, unselectedFileNames } =
await this.selectChangedFiles();
const diff = await this.filesDiff(selectedFileNames, gitConfig);
logger.info('Generating commit message');
| const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
); |
this.spinner.text = 'Generating commit message...';
this.spinner.start();
const commitMessage = await OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
);
this.spinner.stop();
logger.info(commitMessage);
const commitAction = await this.getCommitAction();
shouldContinueCommit = commitAction !== CommitAction.SKIP;
if (commitAction !== CommitAction.SKIP) {
const messageToCommit =
commitAction === CommitAction.COMMIT
? commitMessage
: await this.promptReplaceCommitMessage(commitMessage);
await GitLocalService.commit(messageToCommit, selectedFileNames);
shouldContinueCommit =
unselectedFileNames.length === 0
? false
: await this.promptShouldContinueCommit();
}
}
}
}
| src/commands/commit.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " }: LocalReviewArgs): Promise<void> {\n const config = ConfigService.load();\n const openAIConfig = config.llm.openai;\n const gitConfig = config.git;\n this.spinner.text = 'Reviewing...';\n const review = filename\n ? await this.reviewFile(openAIConfig, directory, filename)\n : await this.reviewDiff(openAIConfig, gitConfig);\n this.spinner.stop();\n logger.info(review);",
"score": 32.93463758327856
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " const localDiff = await GitLocalService.getLocalDiff({\n ignorePatterns: gitConfig.ignorePatterns,\n });\n logger.info('Reviewing local changes');\n this.spinner.start();\n return OpenAiService.reviewDiff(openAIConfig, localDiff);\n }\n private async reviewFile(\n openAIConfig: OpenAIConfig,\n directory: string,",
"score": 24.12719163537135
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " }\n const diff = await this.git.diff(['HEAD', '--'].concat(filteredFilenames));\n return { diff };\n }\n public static async getCommitHistory(\n maxCommitHistory: number,\n ): Promise<string[]> {\n await this.checkIsRepo();\n const history = await this.git.log([\n '-n',",
"score": 19.582809553293657
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": "import { logger } from '../logger';\nimport { BaseCommand } from './base.command';\nexport class LocalReviewCommand extends BaseCommand<LocalReviewArgs> {\n constructor(config: CommandConfig) {\n super(config);\n }\n private async reviewDiff(\n openAIConfig: OpenAIConfig,\n gitConfig: GitConfig,\n ): Promise<string> {",
"score": 16.94651488834072
},
{
"filename": "src/services/git/github.service.ts",
"retrieved_chunk": " if (!diffResponse.ok) {\n throw new GithubServiceError(\n `Failed to fetch PR diff: ${diffResponse.statusText}`,\n );\n }\n const diff = await diffResponse.text();\n const parsedDiff: ParsedFile[] = parse(diff);\n const filteredDiff: ParsedFile[] = this.filterParsedDiff(\n parsedDiff,\n gitConfig.ignorePatterns,",
"score": 15.472332214650862
}
] | typescript | const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
); |
import prompts from 'prompts';
import {
CommandConfig,
CommitAction,
FileSelectionStatus,
GitConfig,
GitDiff,
LocalReviewArgs,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { OpenAiService } from '../services/openai.service';
import { BaseCommand } from './base.command';
class CommitCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'CommitCommandError';
}
}
export class CommitCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async filesDiff(
filenames: string[],
gitConfig: GitConfig,
): Promise<GitDiff> {
logger.info('Reviewing local changes for commit');
return GitLocalService.getFilesDiff(filenames, {
ignorePatterns: gitConfig.ignorePatterns,
});
}
private async selectChangedFiles(): Promise<FileSelectionStatus> {
const fileChanges = await GitLocalService.getFilesChanged();
const selectedFiles = await FileService.selectFiles(fileChanges);
const selectedFileNames = new Set(
selectedFiles.map((file) => file.filename),
);
const allFileNames = fileChanges.map((fileChange) => fileChange.filename);
const unselectedFileNames = allFileNames.filter(
( | filename) => !selectedFileNames.has(filename),
); |
return {
selectedFileNames: Array.from(selectedFileNames),
unselectedFileNames: unselectedFileNames,
};
}
private async promptShouldContinueCommit(): Promise<boolean> {
const response = await prompts({
type: 'confirm',
name: 'value',
message: 'Do you want to continue commit?',
initial: false,
});
return response.value;
}
private async getCommitAction(): Promise<CommitAction> {
const response = await prompts({
type: 'select',
name: 'value',
message: 'Do you want to commit the message, replace it, or do nothing?',
choices: [
{ title: 'Commit', value: CommitAction.COMMIT },
{ title: 'Replace', value: CommitAction.REPLACE },
{ title: 'Do Nothing', value: CommitAction.SKIP },
],
initial: 0,
});
if (!response.value) {
throw new CommitCommandError('Commit action is required');
}
return response.value;
}
private async promptReplaceCommitMessage(
initialMessage: string,
): Promise<string> {
const response = await prompts({
type: 'text',
name: 'value',
message: 'Enter the new commit message:',
initial: initialMessage,
});
if (!response.value) {
throw new CommitCommandError('Commit message is required');
}
return response.value;
}
protected async _run(): Promise<void> {
let shouldContinueCommit = true;
const config = ConfigService.load();
const gitConfig = config.git;
const openAIConfig = config.llm.openai;
while (shouldContinueCommit) {
const { selectedFileNames, unselectedFileNames } =
await this.selectChangedFiles();
const diff = await this.filesDiff(selectedFileNames, gitConfig);
logger.info('Generating commit message');
const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
);
this.spinner.text = 'Generating commit message...';
this.spinner.start();
const commitMessage = await OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
);
this.spinner.stop();
logger.info(commitMessage);
const commitAction = await this.getCommitAction();
shouldContinueCommit = commitAction !== CommitAction.SKIP;
if (commitAction !== CommitAction.SKIP) {
const messageToCommit =
commitAction === CommitAction.COMMIT
? commitMessage
: await this.promptReplaceCommitMessage(commitMessage);
await GitLocalService.commit(messageToCommit, selectedFileNames);
shouldContinueCommit =
unselectedFileNames.length === 0
? false
: await this.promptShouldContinueCommit();
}
}
}
}
| src/commands/commit.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " choices: fileChanges\n .sort((a, b) => a.filename.localeCompare(b.filename))\n .map((fileChange) => ({\n title: this.colorize(fileChange),\n value: fileChange,\n })),\n initial: 0,\n min: 1,\n max: fileChanges.length,\n });",
"score": 38.269066047690934
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " public static async getLocalDiff(options?: {\n ignorePatterns?: string[];\n }): Promise<GitDiff> {\n const fileChanges = await this.getFilesChanged();\n const filenames = fileChanges.map((fileChange) => fileChange.filename);\n return this.getFilesDiff(filenames, {\n ignorePatterns: options?.ignorePatterns,\n });\n }\n public static async getFilesChanged(): Promise<GitFileChange[]> {",
"score": 38.15643467243095
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " const content = fs.readFileSync(file, 'utf8');\n return { filename: file, content };\n }\n public static async selectFiles(\n fileChanges: GitFileChange[],\n ): Promise<GitFileChange[]> {\n const response = await prompts({\n type: 'multiselect',\n name: 'files',\n message: 'Select files to commit:',",
"score": 25.94552961770031
},
{
"filename": "src/interfaces/common.interface.ts",
"retrieved_chunk": " directory: string;\n filename: string;\n}\nexport interface Prompt {\n system: string;\n user: string;\n}\nexport interface FileSelectionStatus {\n selectedFileNames: string[];\n unselectedFileNames: string[];",
"score": 21.411275419324827
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " }\n private static colorize(fileChange: GitFileChange): string {\n switch (fileChange.status) {\n case 'added':\n return chalk.green(fileChange.filename);\n case 'deleted':\n return chalk.red(fileChange.filename);\n case 'changed':\n return chalk.cyan(fileChange.filename);\n }",
"score": 21.250585891189818
}
] | typescript | filename) => !selectedFileNames.has(filename),
); |
import prompts from 'prompts';
import {
CommandConfig,
CommitAction,
FileSelectionStatus,
GitConfig,
GitDiff,
LocalReviewArgs,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { OpenAiService } from '../services/openai.service';
import { BaseCommand } from './base.command';
class CommitCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'CommitCommandError';
}
}
export class CommitCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async filesDiff(
filenames: string[],
gitConfig: GitConfig,
): Promise<GitDiff> {
logger.info('Reviewing local changes for commit');
return GitLocalService.getFilesDiff(filenames, {
ignorePatterns: gitConfig.ignorePatterns,
});
}
private async selectChangedFiles(): Promise<FileSelectionStatus> {
const fileChanges = await GitLocalService.getFilesChanged();
const selectedFiles = await FileService.selectFiles(fileChanges);
const selectedFileNames = new Set(
selectedFiles.map( | (file) => file.filename),
); |
const allFileNames = fileChanges.map((fileChange) => fileChange.filename);
const unselectedFileNames = allFileNames.filter(
(filename) => !selectedFileNames.has(filename),
);
return {
selectedFileNames: Array.from(selectedFileNames),
unselectedFileNames: unselectedFileNames,
};
}
private async promptShouldContinueCommit(): Promise<boolean> {
const response = await prompts({
type: 'confirm',
name: 'value',
message: 'Do you want to continue commit?',
initial: false,
});
return response.value;
}
private async getCommitAction(): Promise<CommitAction> {
const response = await prompts({
type: 'select',
name: 'value',
message: 'Do you want to commit the message, replace it, or do nothing?',
choices: [
{ title: 'Commit', value: CommitAction.COMMIT },
{ title: 'Replace', value: CommitAction.REPLACE },
{ title: 'Do Nothing', value: CommitAction.SKIP },
],
initial: 0,
});
if (!response.value) {
throw new CommitCommandError('Commit action is required');
}
return response.value;
}
private async promptReplaceCommitMessage(
initialMessage: string,
): Promise<string> {
const response = await prompts({
type: 'text',
name: 'value',
message: 'Enter the new commit message:',
initial: initialMessage,
});
if (!response.value) {
throw new CommitCommandError('Commit message is required');
}
return response.value;
}
protected async _run(): Promise<void> {
let shouldContinueCommit = true;
const config = ConfigService.load();
const gitConfig = config.git;
const openAIConfig = config.llm.openai;
while (shouldContinueCommit) {
const { selectedFileNames, unselectedFileNames } =
await this.selectChangedFiles();
const diff = await this.filesDiff(selectedFileNames, gitConfig);
logger.info('Generating commit message');
const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
);
this.spinner.text = 'Generating commit message...';
this.spinner.start();
const commitMessage = await OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
);
this.spinner.stop();
logger.info(commitMessage);
const commitAction = await this.getCommitAction();
shouldContinueCommit = commitAction !== CommitAction.SKIP;
if (commitAction !== CommitAction.SKIP) {
const messageToCommit =
commitAction === CommitAction.COMMIT
? commitMessage
: await this.promptReplaceCommitMessage(commitMessage);
await GitLocalService.commit(messageToCommit, selectedFileNames);
shouldContinueCommit =
unselectedFileNames.length === 0
? false
: await this.promptShouldContinueCommit();
}
}
}
}
| src/commands/commit.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " public static async getLocalDiff(options?: {\n ignorePatterns?: string[];\n }): Promise<GitDiff> {\n const fileChanges = await this.getFilesChanged();\n const filenames = fileChanges.map((fileChange) => fileChange.filename);\n return this.getFilesDiff(filenames, {\n ignorePatterns: options?.ignorePatterns,\n });\n }\n public static async getFilesChanged(): Promise<GitFileChange[]> {",
"score": 29.671153721413127
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " const content = fs.readFileSync(file, 'utf8');\n return { filename: file, content };\n }\n public static async selectFiles(\n fileChanges: GitFileChange[],\n ): Promise<GitFileChange[]> {\n const response = await prompts({\n type: 'multiselect',\n name: 'files',\n message: 'Select files to commit:',",
"score": 21.35148576907336
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " const localDiff = await GitLocalService.getLocalDiff({\n ignorePatterns: gitConfig.ignorePatterns,\n });\n logger.info('Reviewing local changes');\n this.spinner.start();\n return OpenAiService.reviewDiff(openAIConfig, localDiff);\n }\n private async reviewFile(\n openAIConfig: OpenAIConfig,\n directory: string,",
"score": 17.490281219941767
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " options?: { ignorePatterns?: string[] },\n ): Promise<GitDiff> {\n await this.checkIsRepo();\n const ignorePatterns =\n options?.ignorePatterns?.map((pattern) => new RegExp(pattern)) || [];\n const filteredFilenames = filenames.filter((filename) => {\n return !ignorePatterns.some((pattern) => pattern.test(filename));\n });\n if (filteredFilenames.length === 0) {\n throw new GitLocalServiceError('No files to diff');",
"score": 15.200245320959649
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " choices: fileChanges\n .sort((a, b) => a.filename.localeCompare(b.filename))\n .map((fileChange) => ({\n title: this.colorize(fileChange),\n value: fileChange,\n })),\n initial: 0,\n min: 1,\n max: fileChanges.length,\n });",
"score": 13.956475274907357
}
] | typescript | (file) => file.filename),
); |
/**
* The `Deferred` type represents the state of some asynchronous operation. The
* operation can either be `NotStarted`, `InProgress`, or `Resolved`. When the
* operation is resolved, it has some data attached to it that represents the
* outcome of the asyncrhonous work.
*
* This type is frequently used with `Result` as the data of the `Resolved`
* branch, because it is a common situation to model the outcome of an asynchronous
* operation that can fail.
*
* This type is especially helpful in Redux stores (or in the React `useReducer`
* state) because it allows you to determinstically model the state of an async
* operation as one value. I.e., instead of using separate flags that are
* _implicitly_ related to each other (e.g., `notStarted`, `loading`, `result`),
* you know for a fact that the async work can only be in one of three states,
* and the data present on the resolved state is _only_ present on the resolved
* state.
*
* @example
* declare const def: Deferred<ApiResponse>
*
* pipe(
* def,
* Deferred.match({
* notStarted: "Not Started",
* inProgress: "In Progress",
* resolved: response => response.body
* })
* )
*
* @module Deferred
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-empty-interface */
import { Tagged, assertExhaustive } from "./prelude"
import { pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
/** The `NotStarted` type. */
export interface NotStarted extends Tagged<"NotStarted", object> {}
/** The `InProgress` type. */
export interface InProgress extends Tagged<"InProgress", object> {}
/** The `Resolved` type. */
export interface Resolved<A> extends Tagged<"Resolved", { resolved: A }> {}
/** A discriminated union type representing a `Deferred` value. */
export type Deferred<A> = NotStarted | InProgress | Resolved<A>
/**
* The static `NotStarted` instance.
*
* @group Constructors
*/
export const notStarted: Deferred<never> = Object.freeze({ _tag: "NotStarted" })
/**
* The static `InProgress` instance.
*
* @group Constructors
*/
export const inProgress: Deferred<never> = Object.freeze({ _tag: "InProgress" })
/**
* Construct a new `Resolved` instance with the given data attached.
*
* @param a The data that will be wrapped in the `Deferred`.
*
* @group Constructors
*/
export const resolved = <A>(a: A): Deferred<A> => ({ _tag: "Resolved", resolved: a })
/** @ignore */
interface DeferredMatcher<A, R> {
readonly notStarted: (() => R) | R
readonly inProgress: (() => R) | R
readonly resolved: ((a: A) => R) | R
}
/** @ignore */
interface PartialDeferredMatcher<A, R> extends Partial<DeferredMatcher<A, R>> {
readonly orElse: (() => R) | R
}
type Func<T> = (...args: any[]) => T
type FuncOrValue<T> = Func<T> | T
const resultOrValue = <T>(f: FuncOrValue<T>, ...args: any[]) => {
const isFunc = (f: FuncOrValue<T>): f is Func<T> => typeof f === "function"
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
return isFunc(f) ? f(...args) : f
}
/**
* Exhaustively pattern match against a `Deferred` value. Provide either
* a value or a lambda to use for each case. If you provide a lambda to the
* `resolved` case, it will be given the data associated with the `Resolved`
* instance.
*
* See docs for {@link Deferred} for example.
*
* @param matcher The matcher object to use.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<MyApiResponse>
* pipe(
* def,
* Deferred.match({
* notStarted: "",
* inProgress: "Loading...",
* resolved: resp => resp?.body ?? ""
* })
* ) // => the string produced in each case, depending on the value of `def`
* ```
*/
export const match =
<A, R>(matcher: DeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(matcher.notStarted)
case "InProgress":
return resultOrValue(matcher.inProgress)
case "Resolved":
return resultOrValue(matcher.resolved, deferred.resolved)
/* c8 ignore next 2 */
default:
| return assertExhaustive(deferred) as R
} |
}
/**
* Non-exhaustive pattern match against a `Deferred`. Provide a lambda or raw value
* to return for the various cases. (But don't specify all the cases. You should use
* {@link match} if you want exhaustive case checking.) Then also provide a raw value
* or lambda to use for the `orElse` case if the check falls through all other cases.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<number>
* pipe(
* def,
* Deferred.matchOrElse({
* resolved: statusCode => `Status: ${statusCode}`,
* orElse: 'Not Finished' // effectively captures both "in progress" and "not started" cases together
* })
* )
* ```
*/
export const matchOrElse =
<A, R>(matcher: PartialDeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(
matcher.notStarted != null ? matcher.notStarted : matcher.orElse
)
case "InProgress":
return resultOrValue(
matcher.inProgress != null ? matcher.inProgress : matcher.orElse
)
case "Resolved":
return matcher.resolved != null
? resultOrValue(matcher.resolved, deferred.resolved)
: resultOrValue(matcher.orElse)
/* c8 ignore next 2 */
default:
return resultOrValue(matcher.orElse)
}
}
/**
* Get whether the `Deferred` is either in progress or not started.
*
* @group Utils
*/
export const isUnresolved: <A>(deferred: Deferred<A>) => boolean = matchOrElse({
resolved: false,
orElse: true,
})
/**
* Gets whether the `Deferred` is in progress.
*
* @group Utils
*/
export const isInProgress = <A>(deferred: Deferred<A>): deferred is InProgress =>
pipe(
deferred,
matchOrElse({
inProgress: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved.
*
* @group Utils
*/
export const isResolved = <A>(deferred: Deferred<A>): deferred is Resolved<A> =>
pipe(
deferred,
matchOrElse({
resolved: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved with data equal to a specific value.
* Uses the `EqualityComparer` if given, otherwise defaults to reference (triple
* equals) equality.
*
* @group Pattern Matching
* @group Utils
*
* @example
* pipe(
* Deferred.resolved(101),
* Deferred.isResolvedWith(100, EqualityComparer.Number)
* // number is just a trivial example here, not required
* ) // => false
*/
export const isResolvedWith = <A>(
expected: A,
equalityComparer: EqualityComparer<A> = EqualityComparer.Default
) =>
matchOrElse<A, boolean>({
resolved: actual => equalityComparer.equals(actual, expected),
orElse: false,
})
/* c8 ignore start */
/** @ignore */
export const Deferred = {
notStarted,
inProgress,
resolved,
match,
matchOrElse,
isUnresolved,
isResolved,
isInProgress,
isResolvedWith,
}
/* c8 ignore end */
| src/Deferred.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " ? getMatcherResult(matcher.inProgress, undefined)\n : getMatcherResult(matcher.orElse, undefined)\n case \"NotStarted\":\n return objHasOptionalProp(\"notStarted\", matcher)\n ? getMatcherResult(matcher.notStarted, undefined)\n : getMatcherResult(matcher.orElse, undefined)\n case \"Resolved\":\n return pipe(\n deferredResult.resolved,\n Result.match({",
"score": 70.50923805850333
},
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " return getMatcherResult(matcher.inProgress, undefined)\n case \"NotStarted\":\n return getMatcherResult(matcher.notStarted, undefined)\n case \"Resolved\":\n return pipe(\n deferredResult.resolved,\n Result.match({\n ok: a => getMatcherResult(matcher.resolvedOk, a),\n err: e => getMatcherResult(matcher.resolvedErr, e),\n })",
"score": 67.63656661968474
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " case \"Ok\":\n return getMatcherResult(matcher.ok, result.ok)\n case \"Err\":\n return getMatcherResult(matcher.err, result.err)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(result)\n }\n }\n/**",
"score": 57.506883270163875
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " case \"None\":\n return getMatcherResult(matcher.none, void 0)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(option)\n }\n }\n/**\n * Maps the wrapped `Some` value using the given function.\n * Passes through `None` as-is.",
"score": 47.44809754742204
},
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " * })\n * )\n * ```\n */\nexport const matchOrElse =\n <A, E, R>(matcher: PartialDeferredResultMatcher<A, E, R>) =>\n (deferredResult: DeferredResult<A, E>) => {\n switch (deferredResult._tag) {\n case \"InProgress\":\n return objHasOptionalProp(\"inProgress\", matcher)",
"score": 45.90924403710891
}
] | typescript | return assertExhaustive(deferred) as R
} |
import {
CommandConfig,
GitConfig,
LocalReviewArgs,
OpenAIConfig,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { OpenAiService } from '../services/openai.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { BaseCommand } from './base.command';
export class LocalReviewCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async reviewDiff(
openAIConfig: OpenAIConfig,
gitConfig: GitConfig,
): Promise<string> {
const localDiff = await GitLocalService.getLocalDiff({
ignorePatterns: gitConfig.ignorePatterns,
});
logger.info('Reviewing local changes');
this.spinner.start();
return OpenAiService.reviewDiff(openAIConfig, localDiff);
}
private async reviewFile(
openAIConfig: OpenAIConfig,
directory: string,
filename: string,
): Promise<string> {
const getFileResponse = await FileService.getFileContentAndName(
directory,
filename,
);
const contentWithLineNumbers = FileService.addLineNumbers(
getFileResponse.content,
);
logger.info(`Reviewing ${getFileResponse.filename}`);
this.spinner.start();
| return OpenAiService.reviewFile(
openAIConfig,
contentWithLineNumbers,
getFileResponse.filename,
); |
}
protected async _run({
directory,
filename,
}: LocalReviewArgs): Promise<void> {
const config = ConfigService.load();
const openAIConfig = config.llm.openai;
const gitConfig = config.git;
this.spinner.text = 'Reviewing...';
const review = filename
? await this.reviewFile(openAIConfig, directory, filename)
: await this.reviewDiff(openAIConfig, gitConfig);
this.spinner.stop();
logger.info(review);
}
}
| src/commands/local-review.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/commands/pull-request-review.command.ts",
"retrieved_chunk": " );\n this.spinner.text = 'Reviewing...';\n this.spinner.start();\n const review = await OpenAiService.reviewDiff(\n openAIConfig,\n pullRequestDiff,\n );\n this.spinner.stop();\n logger.info(review);\n }",
"score": 28.186380559194994
},
{
"filename": "src/commands/commit.command.ts",
"retrieved_chunk": " gitConfig.maxCommitHistory,\n );\n this.spinner.text = 'Generating commit message...';\n this.spinner.start();\n const commitMessage = await OpenAiService.generateCommitMessage(\n openAIConfig,\n diff,\n commitHistory,\n );\n this.spinner.stop();",
"score": 18.54767579209436
},
{
"filename": "src/services/openai.service.ts",
"retrieved_chunk": " content: prompt.system,\n },\n {\n role: 'user',\n content: prompt.user,\n },\n ];\n return await this.callOpenAI(config, messages);\n }\n public static async reviewFile(",
"score": 10.514246529508451
},
{
"filename": "src/commands/pull-request-review.command.ts",
"retrieved_chunk": " const pullRequestUrl = GithubService.getPullRequestUrl(\n fullRepository,\n pullRequest,\n );\n logger.info(`Reviewing ${pullRequestUrl}`);\n const pullRequestDiff = await GithubService.getPRDiff(\n config.github,\n config.git,\n fullRepository,\n pullRequest,",
"score": 10.343113198608433
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " }\n}\nexport class FileService {\n public static async getFileContentAndName(\n directory: string,\n filename: string,\n ): Promise<GetFileResponse> {\n const escapedFilename = escapeStringRegexp(filename);\n const pattern = `${directory}/**/*${escapedFilename}*`;\n const matches = await fg(pattern, { onlyFiles: true });",
"score": 9.21305410096142
}
] | typescript | return OpenAiService.reviewFile(
openAIConfig,
contentWithLineNumbers,
getFileResponse.filename,
); |
/**
* The `Deferred` type represents the state of some asynchronous operation. The
* operation can either be `NotStarted`, `InProgress`, or `Resolved`. When the
* operation is resolved, it has some data attached to it that represents the
* outcome of the asyncrhonous work.
*
* This type is frequently used with `Result` as the data of the `Resolved`
* branch, because it is a common situation to model the outcome of an asynchronous
* operation that can fail.
*
* This type is especially helpful in Redux stores (or in the React `useReducer`
* state) because it allows you to determinstically model the state of an async
* operation as one value. I.e., instead of using separate flags that are
* _implicitly_ related to each other (e.g., `notStarted`, `loading`, `result`),
* you know for a fact that the async work can only be in one of three states,
* and the data present on the resolved state is _only_ present on the resolved
* state.
*
* @example
* declare const def: Deferred<ApiResponse>
*
* pipe(
* def,
* Deferred.match({
* notStarted: "Not Started",
* inProgress: "In Progress",
* resolved: response => response.body
* })
* )
*
* @module Deferred
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-empty-interface */
import { Tagged, assertExhaustive } from "./prelude"
import { pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
/** The `NotStarted` type. */
export interface NotStarted extends Tagged<"NotStarted", object> {}
/** The `InProgress` type. */
export interface InProgress extends Tagged<"InProgress", object> {}
/** The `Resolved` type. */
export interface Resolved<A> extends Tagged<"Resolved", { resolved: A }> {}
/** A discriminated union type representing a `Deferred` value. */
export type Deferred<A> = NotStarted | InProgress | Resolved<A>
/**
* The static `NotStarted` instance.
*
* @group Constructors
*/
export const notStarted: Deferred<never> = Object.freeze({ _tag: "NotStarted" })
/**
* The static `InProgress` instance.
*
* @group Constructors
*/
export const inProgress: Deferred<never> = Object.freeze({ _tag: "InProgress" })
/**
* Construct a new `Resolved` instance with the given data attached.
*
* @param a The data that will be wrapped in the `Deferred`.
*
* @group Constructors
*/
export const resolved = <A>(a: A): Deferred<A> => ({ _tag: "Resolved", resolved: a })
/** @ignore */
interface DeferredMatcher<A, R> {
readonly notStarted: (() => R) | R
readonly inProgress: (() => R) | R
readonly resolved: ((a: A) => R) | R
}
/** @ignore */
interface PartialDeferredMatcher<A, R> extends Partial<DeferredMatcher<A, R>> {
readonly orElse: (() => R) | R
}
type Func<T> = (...args: any[]) => T
type FuncOrValue<T> = Func<T> | T
const resultOrValue = <T>(f: FuncOrValue<T>, ...args: any[]) => {
const isFunc = (f: FuncOrValue<T>): f is Func<T> => typeof f === "function"
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
return isFunc(f) ? f(...args) : f
}
/**
* Exhaustively pattern match against a `Deferred` value. Provide either
* a value or a lambda to use for each case. If you provide a lambda to the
* `resolved` case, it will be given the data associated with the `Resolved`
* instance.
*
* See docs for {@link Deferred} for example.
*
* @param matcher The matcher object to use.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<MyApiResponse>
* pipe(
* def,
* Deferred.match({
* notStarted: "",
* inProgress: "Loading...",
* resolved: resp => resp?.body ?? ""
* })
* ) // => the string produced in each case, depending on the value of `def`
* ```
*/
export const match =
<A, R>(matcher: DeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(matcher.notStarted)
case "InProgress":
return resultOrValue(matcher.inProgress)
case "Resolved":
return resultOrValue(matcher.resolved, deferred. | resolved)
/* c8 ignore next 2 */
default:
return assertExhaustive(deferred) as R
} |
}
/**
* Non-exhaustive pattern match against a `Deferred`. Provide a lambda or raw value
* to return for the various cases. (But don't specify all the cases. You should use
* {@link match} if you want exhaustive case checking.) Then also provide a raw value
* or lambda to use for the `orElse` case if the check falls through all other cases.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<number>
* pipe(
* def,
* Deferred.matchOrElse({
* resolved: statusCode => `Status: ${statusCode}`,
* orElse: 'Not Finished' // effectively captures both "in progress" and "not started" cases together
* })
* )
* ```
*/
export const matchOrElse =
<A, R>(matcher: PartialDeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(
matcher.notStarted != null ? matcher.notStarted : matcher.orElse
)
case "InProgress":
return resultOrValue(
matcher.inProgress != null ? matcher.inProgress : matcher.orElse
)
case "Resolved":
return matcher.resolved != null
? resultOrValue(matcher.resolved, deferred.resolved)
: resultOrValue(matcher.orElse)
/* c8 ignore next 2 */
default:
return resultOrValue(matcher.orElse)
}
}
/**
* Get whether the `Deferred` is either in progress or not started.
*
* @group Utils
*/
export const isUnresolved: <A>(deferred: Deferred<A>) => boolean = matchOrElse({
resolved: false,
orElse: true,
})
/**
* Gets whether the `Deferred` is in progress.
*
* @group Utils
*/
export const isInProgress = <A>(deferred: Deferred<A>): deferred is InProgress =>
pipe(
deferred,
matchOrElse({
inProgress: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved.
*
* @group Utils
*/
export const isResolved = <A>(deferred: Deferred<A>): deferred is Resolved<A> =>
pipe(
deferred,
matchOrElse({
resolved: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved with data equal to a specific value.
* Uses the `EqualityComparer` if given, otherwise defaults to reference (triple
* equals) equality.
*
* @group Pattern Matching
* @group Utils
*
* @example
* pipe(
* Deferred.resolved(101),
* Deferred.isResolvedWith(100, EqualityComparer.Number)
* // number is just a trivial example here, not required
* ) // => false
*/
export const isResolvedWith = <A>(
expected: A,
equalityComparer: EqualityComparer<A> = EqualityComparer.Default
) =>
matchOrElse<A, boolean>({
resolved: actual => equalityComparer.equals(actual, expected),
orElse: false,
})
/* c8 ignore start */
/** @ignore */
export const Deferred = {
notStarted,
inProgress,
resolved,
match,
matchOrElse,
isUnresolved,
isResolved,
isInProgress,
isResolvedWith,
}
/* c8 ignore end */
| src/Deferred.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " ? getMatcherResult(matcher.inProgress, undefined)\n : getMatcherResult(matcher.orElse, undefined)\n case \"NotStarted\":\n return objHasOptionalProp(\"notStarted\", matcher)\n ? getMatcherResult(matcher.notStarted, undefined)\n : getMatcherResult(matcher.orElse, undefined)\n case \"Resolved\":\n return pipe(\n deferredResult.resolved,\n Result.match({",
"score": 60.69204831505743
},
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " return getMatcherResult(matcher.inProgress, undefined)\n case \"NotStarted\":\n return getMatcherResult(matcher.notStarted, undefined)\n case \"Resolved\":\n return pipe(\n deferredResult.resolved,\n Result.match({\n ok: a => getMatcherResult(matcher.resolvedOk, a),\n err: e => getMatcherResult(matcher.resolvedErr, e),\n })",
"score": 58.03714368616369
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " case \"Ok\":\n return getMatcherResult(matcher.ok, result.ok)\n case \"Err\":\n return getMatcherResult(matcher.err, result.err)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(result)\n }\n }\n/**",
"score": 53.457800696079836
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " case \"None\":\n return getMatcherResult(matcher.none, void 0)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(option)\n }\n }\n/**\n * Maps the wrapped `Some` value using the given function.\n * Passes through `None` as-is.",
"score": 44.67784948370016
},
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " * })\n * )\n * ```\n */\nexport const matchOrElse =\n <A, E, R>(matcher: PartialDeferredResultMatcher<A, E, R>) =>\n (deferredResult: DeferredResult<A, E>) => {\n switch (deferredResult._tag) {\n case \"InProgress\":\n return objHasOptionalProp(\"inProgress\", matcher)",
"score": 42.906531290632756
}
] | typescript | resolved)
/* c8 ignore next 2 */
default:
return assertExhaustive(deferred) as R
} |
/**
* An `AsyncResult` represents an asynchronous computation that may either
* succeed or fail (but should never throw). It is identical to `Async<Result<A, E>`.
* This module simply provides convenience functions for working with that
* type because they are so frequently used in real-world programming.
*
* Like `Async`, `AsyncResult` represents a "cold" computation that must be
* explicitly invoked/started, in contrast to `Promise`s, which are "hot."
*
* **Note:** You can use `Async.start` to start `AsyncResult`s because they are
* just `Async`s with a constrained inner value type.
*
* @module AsyncResult
*/
import { Result } from "./Result"
import { Async } from "./Async"
import { pipe } from "./Composition"
/**
* @typeParam A The type of the `Ok` branch.
* @typeParam E The type of the `Err` branch.
*/
export interface AsyncResult<A, E> {
(): Promise<Result<A, E>>
}
/**
* Construct a new `Ok` instance.
*
* @group Constructors
*
* @returns A new `AsyncResult` containing the given ok value.
*/
export const ok =
<A, E = never>(ok: A): AsyncResult<A, E> =>
() =>
Promise.resolve(Result.ok(ok))
/**
* Construct a new `Err` instance.
*
* @group Constructors
*
* @returns A new `AsyncResult` using the given err value.
*/
export const err =
<E, A = never>(err: E): AsyncResult<A, E> =>
() =>
Promise.resolve(Result.err(err))
/**
* Maps the wrapped `Ok` value using the given function and
* returns a new `AsyncResult`. Passes `Err` values through as-is.
*
* @group Mapping
*
* @example
* await pipe(
* AsyncResult.ok(10),
* AsyncResult.map(n => n * 2),
* Async.start
* ) // => Result.ok(20)
*/
export const map =
<A, B>(f: (a: A) => B) =>
<E>(async: AsyncResult<A, E>): AsyncResult<B, E> =>
() =>
async().then(Result.map(f))
/**
* Maps the wrapped `Err` value using the given function and
* returns a new `AsyncResult`. Passes `Ok` values through as-is.
*
* @group Mapping
*
* @example
* await pipe(
* AsyncResult.err("err"),
* AsyncResult.mapErr(s => s.length),
* Async.start
* ) // => Result.err(3)
*/
export const mapErr =
<Ea, Eb>(f: (a: Ea) => Eb) =>
<A>(async: AsyncResult<A, Ea>): AsyncResult<A, Eb> =>
() =>
async().then(Result.mapErr(f))
/**
* Takes two functions: one to map an `Ok`, one to map an `Err`.
* Returns a new AsyncResult with the projected value based
* on which function was used. Equivalent to calling {@link map} =
* followed by {@link mapErr}.
*
* @group Mapping
*/
export const mapBoth =
<A1, A2, E1, E2>(mapOk: (a: A1) => A2, mapErr: (e: E1) => E2) =>
(async: AsyncResult<A1, E1>) =>
() =>
async().then(Result.mapBoth(mapOk, mapErr))
/**
* Maps the wrapped `Ok` value using a given function that
* also returns an AsyncResult, and flattens the result.
* Also commonly known as `flatpMap`.
*
* @group Mapping
*
* @example
* declare const getNumberOfLines: (fileName: string) => AsyncResult<number, Error>
* declare const sendToServer: (numLines: number) => AsyncResult<{}, Error>
*
* await pipe(
* "log.txt", // string
* getNumberOfLines, // AsyncResult<number, Error>
* AsyncResult.bind(sendToServer), // AsyncResult<{}, Error>
* Async.start // Promise<Result<{}, Error>>
* )
* // returns Result.ok({}) if everything succeeds
* // otherwise returns Result.err(Error) if something
* // fell down along the way
*/
export const bind =
<A, B, E>(f: (a: A) => AsyncResult<B, E>) =>
(async: AsyncResult<A, E>): AsyncResult<B, E> =>
async () => {
const result = await async()
return await pipe(
result,
Result.match({
ok: f,
| err: e => err(e),
}),
Async.start
)
} |
/**
* Alias for {@link bind}.
*
* @group Mapping
*/
export const flatMap = bind
/**
* Projects the wrapped `Ok` value using a given _synchronous_ function
* that returns a `Result` and flattens that result into a new `AsyncResult`.
* Primarily useful for composing together asynchronous workflows with
* synchronous functions that may also fail. (e.g., parsing a JSON string)
*
* @group Mapping
*
* @example
* declare const networkRequest: (url: string) => AsyncResult<JsonValue, Error>;
* declare const parseJson: (j: JsonValue) => Result<MyType, string>;
*
* await pipe(
* url, // string
* networkRequest, // AsyncResult<JsonValue, Error>
* AsyncResult.bindResult(flow(
* parseJson, // Result<MyType, string>
* Result.mapErr(s => new Error(s)) // Result<MyType, Error>
* )), // AsyncResult<MyType, Error>
* Async.start // Promise<Result<MyType, Error>>
* )
* // returns Result.ok(MyType) instance if everything succeeds,
* // otherwise returns Result.err(Error)F if something fell over
*/
export const bindResult =
<A, B, E>(f: (a: A) => Result<B, E>) =>
(async: AsyncResult<A, E>): AsyncResult<B, E> =>
() =>
async().then(Result.bind(f))
/**
* Alias for {@link bindResult}.
*
* @group Mapping
*/
export const flatMapResult = bindResult
/**
* Use this function to "lift" a `Result` value into the `AsyncResult` type.
* Essentially, this just wraps a `Result` into a lambda that returns an
* immediately-resolved `Promise` containing the `Result`.
*
* @group Utils
* @group Constructors
*/
export const ofResult =
<A, E>(result: Result<A, E>): AsyncResult<A, E> =>
() =>
Promise.resolve(result)
/**
* Use this function to "lift" an `Async` computation into an `AsyncResult`.
* Essentially, this just wraps the `Async`'s inner value into a `Result.ok`.
*
* @group Utils
* @group Constructors
*/
export const ofAsync =
<A, E = unknown>(async: Async<A>): AsyncResult<A, E> =>
() =>
async().then(a => Result.ok(a))
/* eslint-disable func-style */
/**
* Converts an `Async` computation that might reject into an
* Async computation that never rejects and returns a `Result`.
* (Remember that an `Async` is just a lambda returning a `Promise`.)
*
* If the `onThrow` callback function is given, it will be used to
* convert the thrown object into the Err branch. By default, the thrown
* object will be `string`-ed and wrapped in an Error if it is not an Error already.
*
* @group Utils
*
* @example
* ```
* declare const doHttpThing: (url: string) => Promise<number>;
*
* await pipe(
* AsyncResult.tryCatch(() => doHttpThing("/cats")), // AsyncResult<number, Error>
* AsyncResult.mapErr(e => e.message), // AsyncResult<number, string>
* Async.start // Promise<Result<number, string>>
* )
* // yields `Result.ok(number)` if the call succeeded
* // otherwise yields `Result.err(string)`
* ```
*/
export function tryCatch<A>(mightThrow: Async<A>): AsyncResult<A, Error>
export function tryCatch<A, E = unknown>(
mightThrow: Async<A>,
onThrow: (thrown: unknown) => E
): AsyncResult<A, E>
export function tryCatch<A, E = unknown>(
mightThrow: Async<A>,
onThrow?: (err: unknown) => E
): AsyncResult<A, unknown> {
return async () => {
const toError = (err: unknown) =>
err instanceof Error ? err : Error(String(err))
try {
return Result.ok(await mightThrow())
} catch (err) {
if (onThrow != null) {
return Result.err(onThrow(err))
}
return Result.err(toError(err))
}
}
}
/* eslint-enable func-style */
/**
* @ignore
*/
interface AsyncResultMatcher<A, E, R> {
readonly ok: R | ((ok: A) => R)
readonly err: R | ((err: E) => R)
}
/**
* Exhaustive pattern match against an `AsyncResult`. Pass a matcher
* object with cases for `ok` and `err` using either raw values or
* lambdas accepting the data associated with each case.
*
* This pattern match unwraps the inner `Result` and returns an `Async`
* computation containing the result of the match. Use {@link start} to
* convert the `Async` into a `Promise` which can be `await`-ed.
*
* @group Pattern Matching
*
* @example
* await pipe(
* AsyncResult.ok("alright!"),
* AsyncResult.match({
* ok: String.capitalize,
* err: "bah, humbug!",
* }),
* Async.start
* ) // => "Alright!"
*/
export const match =
<A, E, R>(matcher: AsyncResultMatcher<A, E, R>) =>
(async: AsyncResult<A, E>): Async<R> =>
() =>
async().then(Result.match(matcher))
/**
* Equivalent to both Async.start or simply invoking
* the AsyncResult as a function. Aliased here for convenience.
*
* @group Utils
*/
export const start = <A, E>(async: AsyncResult<A, E>) => async()
/**
* Execute an arbitrary side-effect on the inner `Ok` value of an `AsyncResult`
* within a pipeline of functions. Useful for logging and debugging. Passes
* the inner value through unchanged. Sometimes referred to as `do` or `tap`.
*
* The side-effect will be invoked once the underlying `Promise` has resolved.
*
* @param f The side-effect to execute. Should not mutate its arguments.
* @returns The `AsyncResult`, unchanged.
*
* @group Utils
*/
export const tee =
<A>(f: (a: A) => void) =>
<E>(async: AsyncResult<A, E>): AsyncResult<A, E> =>
Async.tee<Result<A, E>>(Result.tee(f))(async)
/**
* Execute an arbitrary side-effect on the inner `Err` value of an `AsyncResult`
* within a pipeline of functions. Useful for logging and debugging. Passes
* the inner value through unchanged. Sometimes referred to as `do` or `tap`.
*
* The side-effect will be invoked once the underlying `Promise` has resolved.
*
* @param f The side-effect to execute. Should not mutate its arguments.
* @returns The `AsyncResult`, unchanged.
*
* @group Utils
*/
export const teeErr =
<E>(f: (a: E) => void) =>
<A>(async: AsyncResult<A, E>): AsyncResult<A, E> =>
Async.tee<Result<A, E>>(Result.teeErr(f))(async)
/* c8 ignore start */
/** @ignore */
export const AsyncResult = {
ok,
err,
map,
mapErr,
mapBoth,
bind,
flatMap,
bindResult,
flatMapResult,
ofResult,
ofAsync,
tryCatch,
match,
start,
tee,
teeErr,
}
/* c8 ignore end */
| src/AsyncResult.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Result.ts",
"retrieved_chunk": "export const mapErr =\n <E1, E2>(f: (e: E1) => E2) =>\n <A>(result: Result<A, E1>) =>\n pipe(\n result,\n match({\n ok: a => ok(a),\n err: e => err(f(e)),\n })\n )",
"score": 39.453541612429376
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " result,\n match({\n ok: a => ok(a),\n err: e => {\n f(e)\n return err(e)\n },\n })\n )\n/**",
"score": 37.919302821757135
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " <E>(result: Result<A, E>): Result<B, E> =>\n pipe(\n result,\n match({\n ok: a => ok(f(a)),\n err: e => err(e),\n })\n )\n/**\n * Map the inner `Err` value using the given function and",
"score": 35.69789477030502
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " result,\n match({\n ok: a => (refinement(a) ? ok(a) : err(onFail(a))),\n err: e => err(e),\n })\n )\n/**\n * Map the inner `Ok` value using the given function and\n * return a new `Result`. Passes `Err` values through as-is.\n *",
"score": 30.68129345602033
},
{
"filename": "src/Async.ts",
"retrieved_chunk": " * const a = await Async.of(1)(); // => 1\n * // use a named function, useful for pipelining\n * const b = await pipe(\n * Async.of(1),\n * Async.start\n * ) // => 1\n */\nexport const start = <A>(async: Async<A>): Promise<A> => async()\n/**\n * Converts an array of `Async` computations into one `Async` computation",
"score": 28.760827141964874
}
] | typescript | err: e => err(e),
}),
Async.start
)
} |
/**
* The `Deferred` type represents the state of some asynchronous operation. The
* operation can either be `NotStarted`, `InProgress`, or `Resolved`. When the
* operation is resolved, it has some data attached to it that represents the
* outcome of the asyncrhonous work.
*
* This type is frequently used with `Result` as the data of the `Resolved`
* branch, because it is a common situation to model the outcome of an asynchronous
* operation that can fail.
*
* This type is especially helpful in Redux stores (or in the React `useReducer`
* state) because it allows you to determinstically model the state of an async
* operation as one value. I.e., instead of using separate flags that are
* _implicitly_ related to each other (e.g., `notStarted`, `loading`, `result`),
* you know for a fact that the async work can only be in one of three states,
* and the data present on the resolved state is _only_ present on the resolved
* state.
*
* @example
* declare const def: Deferred<ApiResponse>
*
* pipe(
* def,
* Deferred.match({
* notStarted: "Not Started",
* inProgress: "In Progress",
* resolved: response => response.body
* })
* )
*
* @module Deferred
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-empty-interface */
import { Tagged, assertExhaustive } from "./prelude"
import { pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
/** The `NotStarted` type. */
export interface NotStarted extends Tagged<"NotStarted", object> {}
/** The `InProgress` type. */
export interface InProgress extends Tagged<"InProgress", object> {}
/** The `Resolved` type. */
export interface Resolved<A> extends Tagged<"Resolved", { resolved: A }> {}
/** A discriminated union type representing a `Deferred` value. */
export type Deferred<A> = NotStarted | InProgress | Resolved<A>
/**
* The static `NotStarted` instance.
*
* @group Constructors
*/
export const notStarted: Deferred<never> = Object.freeze({ _tag: "NotStarted" })
/**
* The static `InProgress` instance.
*
* @group Constructors
*/
export const inProgress: Deferred<never> = Object.freeze({ _tag: "InProgress" })
/**
* Construct a new `Resolved` instance with the given data attached.
*
* @param a The data that will be wrapped in the `Deferred`.
*
* @group Constructors
*/
export const resolved = <A>(a: A): Deferred<A> => ({ _tag: "Resolved", resolved: a })
/** @ignore */
interface DeferredMatcher<A, R> {
readonly notStarted: (() => R) | R
readonly inProgress: (() => R) | R
readonly resolved: ((a: A) => R) | R
}
/** @ignore */
interface PartialDeferredMatcher<A, R> extends Partial<DeferredMatcher<A, R>> {
readonly orElse: (() => R) | R
}
type Func<T> = (...args: any[]) => T
type FuncOrValue<T> = Func<T> | T
const resultOrValue = <T>(f: FuncOrValue<T>, ...args: any[]) => {
const isFunc = (f: FuncOrValue<T>): f is Func<T> => typeof f === "function"
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
return isFunc(f) ? f(...args) : f
}
/**
* Exhaustively pattern match against a `Deferred` value. Provide either
* a value or a lambda to use for each case. If you provide a lambda to the
* `resolved` case, it will be given the data associated with the `Resolved`
* instance.
*
* See docs for {@link Deferred} for example.
*
* @param matcher The matcher object to use.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<MyApiResponse>
* pipe(
* def,
* Deferred.match({
* notStarted: "",
* inProgress: "Loading...",
* resolved: resp => resp?.body ?? ""
* })
* ) // => the string produced in each case, depending on the value of `def`
* ```
*/
export const match =
<A, R>(matcher: DeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(matcher.notStarted)
case "InProgress":
return resultOrValue(matcher.inProgress)
case "Resolved":
return resultOrValue(matcher.resolved, deferred.resolved)
/* c8 ignore next 2 */
default:
return assertExhaustive(deferred) as R
}
}
/**
* Non-exhaustive pattern match against a `Deferred`. Provide a lambda or raw value
* to return for the various cases. (But don't specify all the cases. You should use
* {@link match} if you want exhaustive case checking.) Then also provide a raw value
* or lambda to use for the `orElse` case if the check falls through all other cases.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<number>
* pipe(
* def,
* Deferred.matchOrElse({
* resolved: statusCode => `Status: ${statusCode}`,
* orElse: 'Not Finished' // effectively captures both "in progress" and "not started" cases together
* })
* )
* ```
*/
export const matchOrElse =
<A, R>(matcher: PartialDeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(
matcher.notStarted != null ? matcher.notStarted : matcher.orElse
)
case "InProgress":
return resultOrValue(
matcher.inProgress != null ? matcher.inProgress : matcher.orElse
)
case "Resolved":
return matcher.resolved != null
? resultOrValue(matcher.resolved, deferred.resolved)
: resultOrValue(matcher.orElse)
/* c8 ignore next 2 */
default:
return resultOrValue(matcher.orElse)
}
}
/**
* Get whether the `Deferred` is either in progress or not started.
*
* @group Utils
*/
export const isUnresolved: <A>(deferred: Deferred<A>) => boolean = matchOrElse({
resolved: false,
orElse: true,
})
/**
* Gets whether the `Deferred` is in progress.
*
* @group Utils
*/
export const isInProgress = <A>(deferred: Deferred<A>): deferred is InProgress =>
pipe(
deferred,
matchOrElse({
inProgress: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved.
*
* @group Utils
*/
export const isResolved = <A>(deferred: Deferred<A>): deferred is Resolved<A> =>
pipe(
deferred,
matchOrElse({
resolved: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved with data equal to a specific value.
* Uses the `EqualityComparer` if given, otherwise defaults to reference (triple
* equals) equality.
*
* @group Pattern Matching
* @group Utils
*
* @example
* pipe(
* Deferred.resolved(101),
* Deferred.isResolvedWith(100, EqualityComparer.Number)
* // number is just a trivial example here, not required
* ) // => false
*/
export const isResolvedWith = <A>(
expected: A,
equalityComparer: | EqualityComparer<A> = EqualityComparer.Default
) =>
matchOrElse<A, boolean>({ |
resolved: actual => equalityComparer.equals(actual, expected),
orElse: false,
})
/* c8 ignore start */
/** @ignore */
export const Deferred = {
notStarted,
inProgress,
resolved,
match,
matchOrElse,
isUnresolved,
isResolved,
isInProgress,
isResolvedWith,
}
/* c8 ignore end */
| src/Deferred.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Array.ts",
"retrieved_chunk": " <A>(a: A, equalityComparer: EqualityComparer<A> = EqualityComparer.Default) =>\n (as: readonly A[]): boolean => {\n if (isEmpty(as)) {\n return false\n }\n const predicate = (test: A) => equalityComparer.equals(a, test)\n return as.some(predicate)\n }\n/**\n * Return a new array containing only unique values. If",
"score": 29.454632928964806
},
{
"filename": "src/EqualityComparer.ts",
"retrieved_chunk": "export const Number: EqualityComparer<number> = Default\n/* c8 ignore start */\n/** @ignore */\nexport const EqualityComparer = {\n ofEquals,\n ofStruct,\n deriveFrom,\n Default,\n Date,\n String,",
"score": 27.237609533201372
},
{
"filename": "src/Map.ts",
"retrieved_chunk": " * @returns `true` if the key is in the `Map`, `false` otherwise.\n */\nexport const containsKey =\n <K>(key: K, equalityComparer: EqualityComparer<K> = EqualityComparer.Default) =>\n <V>(map: ReadonlyMap<K, V>): boolean =>\n pipe(map, findWithKey(key, equalityComparer), Option.isSome)\n/**\n * Get a value associated with the given key from the `Map`. Returns a `Some`\n * containing the value, or `None` if the key is not in the `Map`.\n *",
"score": 25.100747739553203
},
{
"filename": "src/Map.ts",
"retrieved_chunk": " * returned unchanged if the key is not found in the map.\n *\n * @group Transformations\n */\nexport const remove =\n <K>(key: K, equalityComparer: EqualityComparer<K> = EqualityComparer.Default) =>\n <V>(map: ReadonlyMap<K, V>) =>\n pipe(\n map,\n findWithKey(key, equalityComparer),",
"score": 22.996165145958685
},
{
"filename": "src/Nullable.ts",
"retrieved_chunk": " * compares non-nullish values based on the given `EqualityComparer`.\n *\n * @group Utils\n *\n * @example\n * ```\n * const { equals } = Nullable.getEqualityComparer(EqualityComparer.Number)\n * equals(null, undefined) // => true\n * equals(3, undefined) // => false\n * equals(null, 4) // => false",
"score": 22.84116801738519
}
] | typescript | EqualityComparer<A> = EqualityComparer.Default
) =>
matchOrElse<A, boolean>({ |
import prompts from 'prompts';
import {
CommandConfig,
CommitAction,
FileSelectionStatus,
GitConfig,
GitDiff,
LocalReviewArgs,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { OpenAiService } from '../services/openai.service';
import { BaseCommand } from './base.command';
class CommitCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'CommitCommandError';
}
}
export class CommitCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async filesDiff(
filenames: string[],
gitConfig: GitConfig,
): Promise<GitDiff> {
logger.info('Reviewing local changes for commit');
return GitLocalService.getFilesDiff(filenames, {
ignorePatterns: gitConfig.ignorePatterns,
});
}
private async selectChangedFiles(): Promise<FileSelectionStatus> {
const fileChanges = await GitLocalService.getFilesChanged();
const selectedFiles = await FileService.selectFiles(fileChanges);
const selectedFileNames = new Set(
selectedFiles.map((file) => file.filename),
);
const allFileNames = fileChanges.map((fileChange) => fileChange.filename);
const unselectedFileNames = allFileNames.filter(
(filename) => !selectedFileNames.has(filename),
);
return {
selectedFileNames: Array.from(selectedFileNames),
unselectedFileNames: unselectedFileNames,
};
}
private async promptShouldContinueCommit(): Promise<boolean> {
const response = await prompts({
type: 'confirm',
name: 'value',
message: 'Do you want to continue commit?',
initial: false,
});
return response.value;
}
private async getCommitAction(): Promise<CommitAction> {
const response = await prompts({
type: 'select',
name: 'value',
message: 'Do you want to commit the message, replace it, or do nothing?',
choices: [
{ title: 'Commit', value: CommitAction.COMMIT },
{ title: 'Replace', value: CommitAction.REPLACE },
{ title: 'Do Nothing', value: CommitAction.SKIP },
],
initial: 0,
});
if (!response.value) {
throw new CommitCommandError('Commit action is required');
}
return response.value;
}
private async promptReplaceCommitMessage(
initialMessage: string,
): Promise<string> {
const response = await prompts({
type: 'text',
name: 'value',
message: 'Enter the new commit message:',
initial: initialMessage,
});
if (!response.value) {
throw new CommitCommandError('Commit message is required');
}
return response.value;
}
protected async _run(): Promise<void> {
let shouldContinueCommit = true;
const config = ConfigService.load();
const gitConfig = config.git;
const openAIConfig = config.llm.openai;
while (shouldContinueCommit) {
const { selectedFileNames, unselectedFileNames } =
await this.selectChangedFiles();
const diff = await this.filesDiff(selectedFileNames, gitConfig);
logger.info('Generating commit message');
const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
);
this.spinner.text = 'Generating commit message...';
this.spinner.start();
const commitMessage | = await OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
); |
this.spinner.stop();
logger.info(commitMessage);
const commitAction = await this.getCommitAction();
shouldContinueCommit = commitAction !== CommitAction.SKIP;
if (commitAction !== CommitAction.SKIP) {
const messageToCommit =
commitAction === CommitAction.COMMIT
? commitMessage
: await this.promptReplaceCommitMessage(commitMessage);
await GitLocalService.commit(messageToCommit, selectedFileNames);
shouldContinueCommit =
unselectedFileNames.length === 0
? false
: await this.promptShouldContinueCommit();
}
}
}
}
| src/commands/commit.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/commands/pull-request-review.command.ts",
"retrieved_chunk": " );\n this.spinner.text = 'Reviewing...';\n this.spinner.start();\n const review = await OpenAiService.reviewDiff(\n openAIConfig,\n pullRequestDiff,\n );\n this.spinner.stop();\n logger.info(review);\n }",
"score": 26.653834807532988
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " }: LocalReviewArgs): Promise<void> {\n const config = ConfigService.load();\n const openAIConfig = config.llm.openai;\n const gitConfig = config.git;\n this.spinner.text = 'Reviewing...';\n const review = filename\n ? await this.reviewFile(openAIConfig, directory, filename)\n : await this.reviewDiff(openAIConfig, gitConfig);\n this.spinner.stop();\n logger.info(review);",
"score": 20.502642526521946
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " const localDiff = await GitLocalService.getLocalDiff({\n ignorePatterns: gitConfig.ignorePatterns,\n });\n logger.info('Reviewing local changes');\n this.spinner.start();\n return OpenAiService.reviewDiff(openAIConfig, localDiff);\n }\n private async reviewFile(\n openAIConfig: OpenAIConfig,\n directory: string,",
"score": 20.233187963669295
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " this.spinner.start();\n return OpenAiService.reviewFile(\n openAIConfig,\n contentWithLineNumbers,\n getFileResponse.filename,\n );\n }\n protected async _run({\n directory,\n filename,",
"score": 19.312828485553407
},
{
"filename": "src/services/git/github.service.ts",
"retrieved_chunk": " if (!diffResponse.ok) {\n throw new GithubServiceError(\n `Failed to fetch PR diff: ${diffResponse.statusText}`,\n );\n }\n const diff = await diffResponse.text();\n const parsedDiff: ParsedFile[] = parse(diff);\n const filteredDiff: ParsedFile[] = this.filterParsedDiff(\n parsedDiff,\n gitConfig.ignorePatterns,",
"score": 11.529714335827355
}
] | typescript | = await OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
); |
/**
* A suite of useful functions for working with readonly arrays. These functions
* provide a curried API that works seamlessly with right-to-left function
* composition and preserve the `readonly` type.
*
* @module Array
*/
import { Predicate, Refinement, NonNullish } from "./prelude"
import { Option } from "./Option"
import { Result } from "./Result"
import { pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
import { OrderingComparer } from "./OrderingComparer"
import { NonEmptyArray } from "./NonEmptyArray"
/* eslint-disable func-style */
/**
* Curried and readonly version of the built-in `filter`.
* Accepts a plain predicate function or a refinement
* function (a.k.a. type guard).
*
* @group Filtering
*/
export function filter<A, B extends A>(
refinement: Refinement<A, B>
): (as: readonly A[]) => readonly B[]
export function filter<A>(
predicate: Predicate<A>
): <B extends A>(bs: readonly B[]) => readonly B[]
export function filter<A>(predicate: Predicate<A>): (as: readonly A[]) => readonly A[]
export function filter<A>(f: Predicate<A>) {
return <B extends A>(as: readonly B[]) => as.filter(f)
}
/* eslint-enable func-style */
/**
* Like {@link filter}, but the predicate function also accepts the
* index of the element as an argument.
*
* @group Filtering
*/
export const filteri =
<A>(f: (a: A, i: number) => boolean) =>
(as: readonly A[]): readonly A[] =>
as.filter(f)
/**
* Curried and readonly version of the built-in `map`.
*
* @group Mapping
*/
export const map =
<A, B>(f: (a: A) => B) =>
(as: readonly A[]): readonly B[] =>
as.map(f)
/**
* Like {@link map} but the map function also accepts the
* index of the element as an argument.
*
* @group Mapping
*/
export const mapi =
<A, B>(f: (a: A, i: number) => B) =>
(as: readonly A[]): readonly B[] =>
as.map(f)
/**
* Maps each value of the array into an `Option`, and keeps only the inner
* values of those `Option`s that are`Some`. Essentially, this is a combined map +
* filter operation where each element of the array is mapped into an `Option`
* and an `isSome` check is used as the filter function.
*
* @group Mapping
*
* @example
* pipe(
* [32, null, 55, undefined, 89], // (number | null | undefined)[]
* Array.choose(x => pipe(
* x, // number | null | undefined
* Option.ofNullish, // Option<number>
* Option.map(String) // Option<string>
* )) // string[]
* ) // => ["32", "55", "89"]
*/
export const choose =
<A, B extends NonNullish>(f: (a: A) => Option<B>) =>
(as: readonly A[]): readonly B[] => {
const bs: B[] = []
for (let i = 0; i < as.length; i++) {
const maybeB = f(as[i])
if (Option.isSome(maybeB)) {
bs.push(maybeB.some)
}
}
return bs
}
/**
* Like {@link choose}, but maps each value of the array into a `Result`,
* and keeps only the values where the projection returns `Ok`. Essentially,
* this is a combined map + filter operation where each element of the array
* is mapped into an `Result` and an `isOk` check is used as the filter function.
*
* @group Mapping
*
* @example
* pipe(
* [32, null, 55, undefined, 89], // (number | null | undefined)[]
* Array.chooseR(x => pipe(
* x, // number | null | undefined
* Option.ofNullish, // Option<number>
* Option.map(String), // Option<string>
* Result.ofOption(() => "err") // Result<string, string>
* )) // string[]
* ) // => ["32", "55", "89"]
*/
export const chooseR =
<A, E, B>(f: (a: A) => Result<B, E>) =>
(as: readonly A[]): readonly B[] => {
const bs: B[] = []
for (let i = 0; i < as.length; i++) {
const result = f(as[i])
if (Result.isOk(result)) {
bs.push(result.ok)
}
}
return bs
}
/**
* Get the first element of the array (wrapped in `Some`) if
* non-empty, otherwise `None`.
*
* @group Utils
* @group Pattern Matching
*
* @example
* ```ts
* Array.head([]) // => `Option.none`
* Array.head([1, 2, 3]) // => `Option.some(1)`
* ```
*/
export const head = <A extends NonNullish>(as: readonly A[]): Option<A> =>
as.length > 0 ? Option.some(as[0]) : Option.none
/**
* Alias of {@link head}.
*
* @group Utils
* @group Pattern Matching
*/
export const first = head
/**
* Get a new array containing all values except the first
* one (wrapped in `Some`) if non-empty, otherwise `None`.
*
* @group Utils
* @group Pattern Matching
*
* @example
* pipe(
* [1, 2, 3, 4],
* Array.tail
* ) // => Option.some([2, 3, 4])
*/
export const tail = <A>(as: readonly A[]): Option<readonly A[]> => {
if (as.length === 0) {
return Option.none
}
// eslint-disable-next-line @typescript-eslint/no-unused-vars
const [_, ...tail] = as
return Option.some(tail)
}
/**
* Get the first `n` elements of the array. Will return the entire
* array if `n` is greater than the length of the array.
*
* @param count is normalized to a non-negative integer
*
* @group Utils
*
* @example
* pipe(
* [1, 2, 3, 4, 5, 6],
* Array.take(3)
* ) // => [1, 2, 3]
*/
export const take =
(count: number) =>
<A>(as: readonly A[]): readonly A[] => {
const c = count <= 0 ? 0 : Math.floor(count)
if (c > as.length) {
return as
}
const out: A[] = []
for (let i = 0; i < as.length && i < c; i++) {
out.push(as[i])
}
return out
}
/**
* Get the remaining elements of the array
* after skipping `n` elements. Returns empty if the
* skip count goes past the end of the array.
*
* @group Utils
*
* @param count is normalized to a non-negative integer
*
* @example
* pipe(
* [1, 2, 3, 4, 5, 6],
* Array.skip(3)
* ) // => [4, 5, 6]
*/
export const skip =
(count: number) =>
<A>(as: readonly A[]): readonly A[] => {
const c = count <= 0 ? 0 : Math.floor(count)
if (c >= as.length) {
return []
}
const out: A[] = []
for (let i = c; i < as.length; i++) {
out.push(as[i])
}
return out
}
/**
* Curried and readonly version of the built-in `Array.prototype.reduce`. Takes
* the initial value first instead of last.
*
* @group Utils
* @group Folding
*/
export const reduce =
<A, B>(initialValue: B, reducer: (acc: B, next: A) => B) =>
(as: readonly A[]): B =>
as.reduce(reducer, initialValue)
/**
* Curried and readonly version of the built-in `Array.prototype.reduceRight`.
* Takes the initial value first instead of last.
*
* @group Utils
* @group Folding
*/
export const reduceRight =
<A, B>(initialValue: B, reducer: (acc: B, next: A) => B) =>
(as: readonly A[]): B =>
as.reduceRight(reducer, initialValue)
const isRawValue = <A, R>(caseFn: R | ((ok: A) => R)): caseFn is R =>
typeof caseFn !== "function"
const getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>
isRawValue(match) ? match : match(arg)
/**
* @ignore
*/
interface ArrayMatcher<A, R> {
empty: (() => R) | R
nonEmpty: | ((as: NonEmptyArray<A>) => R) | R
} |
/**
* Exhaustive pattern match against an array to "unwrap" its values. Provide
* a matcher object to handle both the `empty` and `nonEmpty` cases.
* The matcher can use lambdas or raw values. In the `nonEmpty` case,
* the lambda will be given a `NonEmptyArray`.
*
* @group Pattern Matching
*
* @example
* ```ts
* pipe(
* ["a", "b"],
* Array.match({
* empty: () => "default",
* nonEmpty: Array.reduceRight("", (a, b) => `${a}${b}`)
* })
* ) // => "ba"
* ```
*/
export const match =
<A, R>(matcher: ArrayMatcher<A, R>) =>
(as: readonly A[]): R =>
as.length > 0
? getMatcherResult(matcher.nonEmpty, as as NonEmptyArray<A>)
: getMatcherResult(matcher.empty, undefined)
/**
* Type guard that tests whether the given array is equivalent
* to the empty tuple type.
*
* @group Type Guards
* @group Utils
*/
export const isEmpty = <A>(as: readonly A[]): as is readonly [] => as.length === 0
/**
* Type guard that tests whether the given array is a `NonEmptyArray`
*
* @group Type Guards
* @group Utils
*/
export const isNonEmpty = <A>(as: readonly A[]): as is NonEmptyArray<A> => as.length > 0
/**
* Also commonly known as `flatMap`. Maps each element of the array
* given a function that itself returns an array, then flattens the result.
*
* @group Mapping
*
* @example
* pipe(
* [1, 2, 3],
* Array.bind(n => [n, n])
* ) // => [1, 1, 2, 2, 3, 3]
*/
export const bind =
<A, B>(f: (a: A) => readonly B[]) =>
(as: readonly A[]): readonly B[] =>
as.flatMap(f)
/**
* Alias of {@link bind}.
*
* @group Mapping
*/
export const flatMap = bind
/**
* Add an element to the _end_ of an array. Always returns
* a `NonEmptyArray`.
*
* @group Utils
*/
export const append =
<A>(a: A) =>
(as: readonly A[]): NonEmptyArray<A> =>
[...as, a] as unknown as NonEmptyArray<A>
/**
* Also known as `cons`. Insert an element at the beginning
* of an array. Always returns a `NonEmptyArray`.
*
* @group Utils
*
* @example
* pipe(
* [2, 3],
* Array.prepend(1)
* ) // => [1, 2, 3]
*/
export const prepend =
<A>(a: A) =>
(as: readonly A[]): NonEmptyArray<A> =>
[a, ...as]
/**
* Return a Map of keys to groups, where the selector function
* is used to generate a string key that determines in which group
* each array element is placed.
*
* @group Grouping
* @group Utils
*
* @example
* pipe(
* [1, 2, 1, 2, 3, 3, 5],
* Array.groupBy(String)
* )
* // structurally equivalent to
* new Map([
* ['1', [1, 1]],
* ['2', [2, 2]],
* ['3', [3, 3]],
* ['5', [5]]
* ])
*/
export const groupBy =
<A>(selector: (a: A) => string) =>
(as: readonly A[]): ReadonlyMap<string, NonEmptyArray<A>> => {
const groups: Map<string, NonEmptyArray<A>> = new Map()
as.forEach(a => {
const key = selector(a)
return groups.has(key)
? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
groups.set(key, pipe(groups.get(key)!, append(a)))
: groups.set(key, [a])
})
return groups
}
/**
* Add an array of values to the _end_ of the subsequently
* passed (partially applied) array, in a way that makes sense
* when reading top-to-bottom/left-to-right using `pipe`.
*
* @group Utils
*
* @example
* pipe(
* [1, 2],
* Array.concat([3, 4])
* ) // => [1, 2, 3, 4]
*/
export const concat =
<A>(addToEnd: readonly A[]) =>
(as: readonly A[]): readonly A[] =>
[...as, ...addToEnd]
/**
* Like {@link concat}, except this adds an array of values to the
* _beginning_ of the subsequently (partially applied) array,
* in a way that makes more sense when _not_ using `pipe`.
*
* @group Utils
*
* @example
* ```ts
* // Reads "backwards" when used with `pipe`
* pipe(
* ["a", "b"],
* Array.concatFirst(["c", "d"])
* ) // => ["c", "d", "a", "b"]
* // Reads better when *not* used with `pipe`
* Array.concatFirst(["a", "b"])(["c", "d"]) // => ["a", "b", "c", "d"]
* ```
*/
export const concatFirst =
<A>(addToFront: readonly A[]) =>
(as: readonly A[]): readonly A[] =>
[...addToFront, ...as]
/**
* Returns true if at least one element of the array
* satisfies the given predicate. Curried version of
* `Array.prototype.some`.
*
* @group Utils
*/
export const exists =
<A>(predicate: (a: A) => boolean) =>
(as: readonly A[]): boolean =>
as.some(predicate)
/**
* Alias of {@link exists}.
*
* @group Utils
*/
export const some = exists
/**
* Equivalent to calling `Array.prototype.flat()` with a depth of 1.
*
* @group Utils
*/
export const flatten = <A>(as: readonly (readonly A[])[]): readonly A[] => as.flat()
/**
* Split an array into chunks of a specified size. The final
* chunk will contain fewer elements than the specified size if
* the array is not evenly divisible by the specified size.
*
* @remarks
* **Note:** Will return `[]`, _not_ `[[]]` if given an empty array.
*
* @param maxChunkSize Normalized to a positive integer.
*
* @example
* pipe(
* ["a", "b", "c", "d", "e"],
* Array.chunk(2)
* ) // => [["a", "b"], ["c", "d"], ["e"]]
*
* @group Utils
* @group Grouping
*/
export const chunk =
(maxChunkSize: number) =>
<A>(as: readonly A[]): readonly NonEmptyArray<A>[] => {
if (isEmpty(as)) {
return []
}
const chunkSize = maxChunkSize <= 1 ? 1 : Math.floor(maxChunkSize)
const numChunks = Math.ceil(as.length / chunkSize)
// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
const chunks: A[][] = [...globalThis.Array(numChunks)].map(() => [])
let chunkIndex = 0
for (let i = 0; i < as.length; i++) {
if (i !== 0 && i % chunkSize === 0) {
chunkIndex++
}
chunks[chunkIndex].push(as[i])
}
return chunks as unknown as readonly NonEmptyArray<A>[]
}
/**
* Get the length of an array.
*
* @group Utils
*/
export const length = <A>(as: readonly A[]) => as.length
/**
* Returns true if the given element is in the array.
* Optionally, pass an `EqualityComparer` to use. Uses
* reference (triple equals) equality by default.
*
* @group Utils
*/
export const contains =
<A>(a: A, equalityComparer: EqualityComparer<A> = EqualityComparer.Default) =>
(as: readonly A[]): boolean => {
if (isEmpty(as)) {
return false
}
const predicate = (test: A) => equalityComparer.equals(a, test)
return as.some(predicate)
}
/**
* Return a new array containing only unique values. If
* passed, uses the `EqualityComparer` to test uniqueness.
* Defaults to using reference equality (triple equals).
*
* @group Utils
*
* @example
* pipe(
* [3, 2, 1, 2, 1, 4, 9],
* Array.uniq()
* ) // => [3, 2, 1, 4, 9]
*/
export const uniq =
<A>(equalityComparer?: EqualityComparer<A>) =>
(as: readonly A[]): readonly A[] => {
if (isEmpty(as)) {
return []
}
const out: A[] = []
as.forEach(a => {
if (!contains(a, equalityComparer)(out)) {
out.push(a)
}
})
return out
}
/**
* Returns a new array containing only unique values as determined
* by mapping each element with the given function and optionally
* passing an equality comparer to use on the mapped elements.
* Defaults to using reference equality (triple equals).
*
* @group Utils
*
* @example
* pipe(
* [{ name: "Rufus" }, { name: "Rex" }, { name: "Rufus" }],
* Array.uniqBy(p => p.name)
* ) // => [{ name: "Rufus" }, { name: "Rex" }]
*/
export const uniqBy =
<A, B>(f: (a: A) => B, equalityComparer?: EqualityComparer<B>) =>
(as: readonly A[]): readonly A[] => {
if (isEmpty(as)) {
return []
}
const out: A[] = []
const projections: B[] = []
as.forEach(a => {
const projected = f(a)
if (!contains(projected, equalityComparer)(projections)) {
projections.push(projected)
out.push(a)
}
})
return out
}
/**
* Get a new array with elements sorted. If given, will use the
* `OrderingComparer`. Otherwise, uses the default JavaScript ASCII-based sort.
*
* @group Utils
*
* @example
* declare const petByNameComparer: OrderingComparer<Pet>
*
* const pets: readonly Pet[] = [
* { name: "Fido" },
* { name: "Albus" },
* { name: "Rex" },
* { name: "Gerald" }
* ]
*
* pipe(
* pets,
* Array.sort(petByNameComparer),
* Array.map(p => p.name)
* ) // => [ "Albus", "Fido", "Gerald", "Rex" ]
*/
export const sort =
<A>(orderingComparer?: OrderingComparer<A>) =>
(as: readonly A[]): readonly A[] => {
if (isEmpty(as)) {
return []
}
return as.slice(0).sort(orderingComparer?.compare)
}
/**
* Get a new array with elements sorted based on the sort-order
* of each mapped element produced by the given mapping function.
* If given, will use the `OrderingComparer`. Otherwise, defaults to an
* OrderingComparer that `String`s the mapped element and uses the
* default ASCII-based sort.
*
* @group Utils
*/
export const sortBy =
<A, B>(
f: (a: A) => B,
orderingComparer: OrderingComparer<B> = OrderingComparer.Default
) =>
(as: readonly A[]): readonly A[] =>
isEmpty(as)
? []
: as.slice(0).sort((o1: A, o2: A) => orderingComparer.compare(f(o1), f(o2)))
/**
* Get a new array with the elements in reverse order.
*
* @group Utils
*/
export const reverse = <A>(as: readonly A[]): readonly A[] => as.slice(0).reverse()
/**
* Get the _first_ element in the array (wrapped in a `Some`) that
* returns `true` for the given predicate, or `None` if no such
* element exists.
*
* @group Utils
*/
export const find =
<A extends NonNullish>(predicate: Predicate<A>) =>
(as: readonly A[]): Option<A> =>
Option.ofNullish(as.find(predicate))
/**
* Get the _first_ index of the array (wrapped in a `Some`) for
* which the element at that index returns true for the given predicate,
* or `None` if no such index/element exists.
*
* @group Utils
*/
export const findIndex =
<A>(predicate: Predicate<A>) =>
(as: readonly A[]): Option<number> => {
const result = as.findIndex(predicate)
return result < 0 ? Option.none : Option.some(result)
}
/**
* Get a new array containing only those elements that are not
* in the given `excludeThese` array. If given, will use the
* EqualityComparer. Otherwise, defaults to reference equality
* (triple equals).
*
* @group Utils
*
* @example
* pipe(
* [1, 2, 3, 4, 5],
* Array.except([2, 5])
* ) // => [1, 3, 4]
*/
export const except =
<A>(excludeThese: readonly A[], equalityComparer?: EqualityComparer<A>) =>
(as: readonly A[]): readonly A[] => {
if (isEmpty(as)) {
return []
}
if (isEmpty(excludeThese)) {
return as
}
const out: A[] = []
for (let i = 0; i < as.length; i++) {
if (!pipe(excludeThese, contains(as[i], equalityComparer))) {
out.push(as[i])
}
}
return out
}
/**
* Get a new array containing the set union of two arrays, defined as the
* set of elements contained in both arrays. **Remember:** sets only contain
* unique elements. If you just need to join two arrays together, use {@link concat}.
*
* @group Utils
*/
export const union =
<A>(unionWith: readonly A[], equalityComparer?: EqualityComparer<A>) =>
(as: readonly A[]): readonly A[] =>
isEmpty(unionWith) && isEmpty(as)
? []
: pipe(as, concat(unionWith), uniq(equalityComparer))
/**
* Get an {@link EqualityComparer} that represents structural equality for an array
* of type `A` by giving this function an `EqualityComparer` for each `A` element.
*
* @group Equality
* @group Utils
*
* @param equalityComparer The `EqualityComparer` to use for element-by-element comparison.
*
* @returns A new `EqualityComparer` instance
*
* @example
* const eq = Array.getEqualityComparer(EqualityComparer.Number)
* eq.equals([1, 2, 3], [1, 2, 3]) // => true
* eq.equals([1, 3], [3, 1]) // => false
*/
export const getEqualityComparer = <A>({
equals,
}: EqualityComparer<A>): EqualityComparer<readonly A[]> =>
EqualityComparer.ofEquals((arr1, arr2) => {
if (isEmpty(arr1) && isEmpty(arr2)) {
return true
}
if (arr1.length !== arr2.length) {
return false
}
for (let i = 0; i < arr1.length; i++) {
if (!equals(arr1[i], arr2[i])) {
return false
}
}
return true
})
/**
* Does not affect the passed array at runtime. (Effectively executes an identity
* function) Removes the `readonly` part of the **type** only.
*
* @group Utils
*/
export const asMutable = <A>(as: readonly A[]) => as as A[]
/**
* Execute an arbitrary side effect for each element of the array. Essentially a
* curried version of the built-in `forEach` method.
*
* @group Utils
*/
export const iter =
<A>(f: (a: A) => void) =>
(as: readonly A[]): void =>
as.forEach(a => f(a))
/** @ignore */
export const Array = {
filter,
filteri,
map,
mapi,
bind,
flatMap,
choose,
chooseR,
head,
first,
tail,
take,
skip,
reduce,
reduceRight,
match,
isEmpty,
isNonEmpty,
append,
prepend,
groupBy,
concat,
concatFirst,
exists,
some,
flatten,
chunk,
length,
contains,
uniq,
uniqBy,
sort,
sortBy,
reverse,
find,
findIndex,
except,
union,
getEqualityComparer,
asMutable,
iter,
}
/* c8 ignore end */
| src/Array.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Result.ts",
"retrieved_chunk": "interface ResultMatcher<A, E, R> {\n readonly ok: R | ((ok: A) => R)\n readonly err: R | ((err: E) => R)\n}\nconst isRawValue = <A, E, R>(caseFn: R | ((ok: A) => R) | ((err: E) => E)): caseFn is R =>\n typeof caseFn !== \"function\"\nconst getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>\n isRawValue(match) ? match : match(arg)\n/**\n * Exhaustive pattern match against a `Result` to \"unwrap\" its inner",
"score": 97.09289608065782
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " readonly some: R | ((some: A) => R)\n readonly none: R | (() => R)\n}\nconst isRawValue = <A, R>(caseFn: R | ((ok: A) => R)): caseFn is R =>\n typeof caseFn !== \"function\"\nconst getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>\n isRawValue(match) ? match : match(arg)\n/**\n * Exhaustively pattern match against an `Option` in order\n * to \"unwrap\" the inner value. Provide either a raw value",
"score": 95.0667823826044
},
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": "}\nconst isRawValue = <A, E, R>(caseFn: R | ((ok: A) => R) | ((err: E) => E)): caseFn is R =>\n typeof caseFn !== \"function\"\nconst getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>\n isRawValue(match) ? match : match(arg)\nconst objHasOptionalProp = <T extends object, P extends keyof T>(\n prop: P,\n obj: T\n): obj is Identity<T & Required<{ [key in P]: T[P] }>> => Object.hasOwn(obj, prop)\n/**",
"score": 93.51253170949865
},
{
"filename": "src/Deferred.ts",
"retrieved_chunk": "}\n/** @ignore */\ninterface PartialDeferredMatcher<A, R> extends Partial<DeferredMatcher<A, R>> {\n readonly orElse: (() => R) | R\n}\ntype Func<T> = (...args: any[]) => T\ntype FuncOrValue<T> = Func<T> | T\nconst resultOrValue = <T>(f: FuncOrValue<T>, ...args: any[]) => {\n const isFunc = (f: FuncOrValue<T>): f is Func<T> => typeof f === \"function\"\n // eslint-disable-next-line @typescript-eslint/no-unsafe-argument",
"score": 59.020822281536404
},
{
"filename": "src/Enums.ts",
"retrieved_chunk": "type RawEnum = Record<string, string | number>\n/** @ignore */\ntype StringKeyValues<T extends RawEnum> = Identity<T[StringKeys<T>]>\n/** @ignore */\ntype EnumMatcher<A, R extends RawEnum> = {\n readonly [Label in StringKeys<R>]: (() => A) | A\n}\n/** @ignore */\ntype PartialEnumMatcher<A, R extends RawEnum> = Partial<EnumMatcher<A, R>> & {\n readonly orElse: (() => A) | A",
"score": 55.37908137153609
}
] | typescript | ((as: NonEmptyArray<A>) => R) | R
} |
/**
* The `Deferred` type represents the state of some asynchronous operation. The
* operation can either be `NotStarted`, `InProgress`, or `Resolved`. When the
* operation is resolved, it has some data attached to it that represents the
* outcome of the asyncrhonous work.
*
* This type is frequently used with `Result` as the data of the `Resolved`
* branch, because it is a common situation to model the outcome of an asynchronous
* operation that can fail.
*
* This type is especially helpful in Redux stores (or in the React `useReducer`
* state) because it allows you to determinstically model the state of an async
* operation as one value. I.e., instead of using separate flags that are
* _implicitly_ related to each other (e.g., `notStarted`, `loading`, `result`),
* you know for a fact that the async work can only be in one of three states,
* and the data present on the resolved state is _only_ present on the resolved
* state.
*
* @example
* declare const def: Deferred<ApiResponse>
*
* pipe(
* def,
* Deferred.match({
* notStarted: "Not Started",
* inProgress: "In Progress",
* resolved: response => response.body
* })
* )
*
* @module Deferred
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
/* eslint-disable @typescript-eslint/no-empty-interface */
import { Tagged, assertExhaustive } from "./prelude"
import { pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
/** The `NotStarted` type. */
export interface NotStarted extends | Tagged<"NotStarted", object> {} |
/** The `InProgress` type. */
export interface InProgress extends Tagged<"InProgress", object> {}
/** The `Resolved` type. */
export interface Resolved<A> extends Tagged<"Resolved", { resolved: A }> {}
/** A discriminated union type representing a `Deferred` value. */
export type Deferred<A> = NotStarted | InProgress | Resolved<A>
/**
* The static `NotStarted` instance.
*
* @group Constructors
*/
export const notStarted: Deferred<never> = Object.freeze({ _tag: "NotStarted" })
/**
* The static `InProgress` instance.
*
* @group Constructors
*/
export const inProgress: Deferred<never> = Object.freeze({ _tag: "InProgress" })
/**
* Construct a new `Resolved` instance with the given data attached.
*
* @param a The data that will be wrapped in the `Deferred`.
*
* @group Constructors
*/
export const resolved = <A>(a: A): Deferred<A> => ({ _tag: "Resolved", resolved: a })
/** @ignore */
interface DeferredMatcher<A, R> {
readonly notStarted: (() => R) | R
readonly inProgress: (() => R) | R
readonly resolved: ((a: A) => R) | R
}
/** @ignore */
interface PartialDeferredMatcher<A, R> extends Partial<DeferredMatcher<A, R>> {
readonly orElse: (() => R) | R
}
type Func<T> = (...args: any[]) => T
type FuncOrValue<T> = Func<T> | T
const resultOrValue = <T>(f: FuncOrValue<T>, ...args: any[]) => {
const isFunc = (f: FuncOrValue<T>): f is Func<T> => typeof f === "function"
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
return isFunc(f) ? f(...args) : f
}
/**
* Exhaustively pattern match against a `Deferred` value. Provide either
* a value or a lambda to use for each case. If you provide a lambda to the
* `resolved` case, it will be given the data associated with the `Resolved`
* instance.
*
* See docs for {@link Deferred} for example.
*
* @param matcher The matcher object to use.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<MyApiResponse>
* pipe(
* def,
* Deferred.match({
* notStarted: "",
* inProgress: "Loading...",
* resolved: resp => resp?.body ?? ""
* })
* ) // => the string produced in each case, depending on the value of `def`
* ```
*/
export const match =
<A, R>(matcher: DeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(matcher.notStarted)
case "InProgress":
return resultOrValue(matcher.inProgress)
case "Resolved":
return resultOrValue(matcher.resolved, deferred.resolved)
/* c8 ignore next 2 */
default:
return assertExhaustive(deferred) as R
}
}
/**
* Non-exhaustive pattern match against a `Deferred`. Provide a lambda or raw value
* to return for the various cases. (But don't specify all the cases. You should use
* {@link match} if you want exhaustive case checking.) Then also provide a raw value
* or lambda to use for the `orElse` case if the check falls through all other cases.
*
* @group Pattern Matching
*
* @example
* ```
* declare const def: Deferred<number>
* pipe(
* def,
* Deferred.matchOrElse({
* resolved: statusCode => `Status: ${statusCode}`,
* orElse: 'Not Finished' // effectively captures both "in progress" and "not started" cases together
* })
* )
* ```
*/
export const matchOrElse =
<A, R>(matcher: PartialDeferredMatcher<A, R>) =>
(deferred: Deferred<A>) => {
switch (deferred._tag) {
case "NotStarted":
return resultOrValue(
matcher.notStarted != null ? matcher.notStarted : matcher.orElse
)
case "InProgress":
return resultOrValue(
matcher.inProgress != null ? matcher.inProgress : matcher.orElse
)
case "Resolved":
return matcher.resolved != null
? resultOrValue(matcher.resolved, deferred.resolved)
: resultOrValue(matcher.orElse)
/* c8 ignore next 2 */
default:
return resultOrValue(matcher.orElse)
}
}
/**
* Get whether the `Deferred` is either in progress or not started.
*
* @group Utils
*/
export const isUnresolved: <A>(deferred: Deferred<A>) => boolean = matchOrElse({
resolved: false,
orElse: true,
})
/**
* Gets whether the `Deferred` is in progress.
*
* @group Utils
*/
export const isInProgress = <A>(deferred: Deferred<A>): deferred is InProgress =>
pipe(
deferred,
matchOrElse({
inProgress: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved.
*
* @group Utils
*/
export const isResolved = <A>(deferred: Deferred<A>): deferred is Resolved<A> =>
pipe(
deferred,
matchOrElse({
resolved: true,
orElse: false,
})
)
/**
* Gets whether the `Deferred` is resolved with data equal to a specific value.
* Uses the `EqualityComparer` if given, otherwise defaults to reference (triple
* equals) equality.
*
* @group Pattern Matching
* @group Utils
*
* @example
* pipe(
* Deferred.resolved(101),
* Deferred.isResolvedWith(100, EqualityComparer.Number)
* // number is just a trivial example here, not required
* ) // => false
*/
export const isResolvedWith = <A>(
expected: A,
equalityComparer: EqualityComparer<A> = EqualityComparer.Default
) =>
matchOrElse<A, boolean>({
resolved: actual => equalityComparer.equals(actual, expected),
orElse: false,
})
/* c8 ignore start */
/** @ignore */
export const Deferred = {
notStarted,
inProgress,
resolved,
match,
matchOrElse,
isUnresolved,
isResolved,
isInProgress,
isResolvedWith,
}
/* c8 ignore end */
| src/Deferred.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Option.ts",
"retrieved_chunk": " * console.info\n * ) // logs \"56!\"\n * ```\n *\n * @module Option\n */\n/* eslint-disable @typescript-eslint/no-empty-interface */\nimport { Tagged, assertExhaustive, Refinement, NonNullish } from \"./prelude\"\nimport { pipe } from \"./Composition\"\nimport { EqualityComparer } from \"./EqualityComparer\"",
"score": 119.81566744641403
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * @module Result\n */\n/* eslint-disable @typescript-eslint/no-empty-interface */\nimport { Tagged, assertExhaustive, Refinement, NonNullish } from \"./prelude\"\nimport { Option } from \"./Option\"\nimport { flow, pipe } from \"./Composition\"\nimport { EqualityComparer } from \"./EqualityComparer\"\nexport interface Ok<A> extends Tagged<\"Ok\", { ok: A }> {}\nexport interface Err<E> extends Tagged<\"Err\", { err: E }> {}\nexport type Result<A, E> = Ok<A> | Err<E>",
"score": 110.3700790925833
},
{
"filename": "src/Variants.ts",
"retrieved_chunk": "/* eslint-disable @typescript-eslint/no-unsafe-call */\n/* eslint-disable @typescript-eslint/no-unsafe-argument */\nimport { Identity } from \"./prelude\"\nimport { String } from \"./string\"\n/**************\n * Helper Types\n ***************/\ntype DefaultDiscriminant = \"_tag\"\ntype DefaultScope = \"\"\ntype Func = (...args: any[]) => any",
"score": 88.2164701953241
},
{
"filename": "src/Enums.ts",
"retrieved_chunk": " orELse: \"I cannot speak.\",\n})\nspeak(myEnum)\n```\n@module Enums\n*/\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Result } from \"./Result\"\nimport { String } from \"./string\"\nimport { Option } from \"./Option\"",
"score": 84.35098582091452
},
{
"filename": "src/Variants.ts",
"retrieved_chunk": " },\n discriminantProperty,\n scope\n)\ntype CustomPet = VariantOf<typeof CustomPet>\n```\n@module Variants\n*/\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-unsafe-return */",
"score": 68.9888140604009
}
] | typescript | Tagged<"NotStarted", object> {} |
import fs from 'fs';
import fg from 'fast-glob';
import prompts from 'prompts';
import escapeStringRegexp from 'escape-string-regexp';
import chalk from 'chalk';
import { GetFileResponse, GitFileChange } from '../interfaces';
class FileServiceError extends Error {
constructor(message: string) {
super(message);
this.name = 'FileServiceError';
}
}
export class FileService {
public static async getFileContentAndName(
directory: string,
filename: string,
): Promise<GetFileResponse> {
const escapedFilename = escapeStringRegexp(filename);
const pattern = `${directory}/**/*${escapedFilename}*`;
const matches = await fg(pattern, { onlyFiles: true });
if (matches.length === 0) {
throw new FileServiceError(
`File ${filename} not found in directory ${directory}`,
);
}
let file: string;
if (matches.length === 1) {
file = matches[0];
} else {
const response = await prompts({
type: 'autocomplete',
name: 'file',
message: 'Multiple files match. Please select a file to review:',
choices: matches
.sort()
.map((match) => ({ title: match, value: match })),
initial: 0,
suggest: (input, choices) => {
const inputValue = input.toLowerCase();
const filteredChoices = choices.filter((choice) =>
choice.title.toLowerCase().includes(inputValue),
);
return Promise.resolve(filteredChoices);
},
});
if (!response.file) {
throw new FileServiceError('No file was selected from the prompt');
}
file = response.file;
}
const content = fs.readFileSync(file, 'utf8');
return { filename: file, content };
}
public static async selectFiles(
fileChanges: | GitFileChange[],
): Promise<GitFileChange[]> { |
const response = await prompts({
type: 'multiselect',
name: 'files',
message: 'Select files to commit:',
choices: fileChanges
.sort((a, b) => a.filename.localeCompare(b.filename))
.map((fileChange) => ({
title: this.colorize(fileChange),
value: fileChange,
})),
initial: 0,
min: 1,
max: fileChanges.length,
});
if (!response.files) {
throw new FileServiceError('No files were selected from the prompt');
}
return response.files;
}
public static addLineNumbers(content: string): string {
return content
.split('\n')
.map((line, index) => `${index + 1} | ${line}`)
.join('\n');
}
private static colorize(fileChange: GitFileChange): string {
switch (fileChange.status) {
case 'added':
return chalk.green(fileChange.filename);
case 'deleted':
return chalk.red(fileChange.filename);
case 'changed':
return chalk.cyan(fileChange.filename);
}
}
}
| src/services/file.service.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/commands/commit.command.ts",
"retrieved_chunk": " return GitLocalService.getFilesDiff(filenames, {\n ignorePatterns: gitConfig.ignorePatterns,\n });\n }\n private async selectChangedFiles(): Promise<FileSelectionStatus> {\n const fileChanges = await GitLocalService.getFilesChanged();\n const selectedFiles = await FileService.selectFiles(fileChanges);\n const selectedFileNames = new Set(\n selectedFiles.map((file) => file.filename),\n );",
"score": 26.530898118421106
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " public static async getLocalDiff(options?: {\n ignorePatterns?: string[];\n }): Promise<GitDiff> {\n const fileChanges = await this.getFilesChanged();\n const filenames = fileChanges.map((fileChange) => fileChange.filename);\n return this.getFilesDiff(filenames, {\n ignorePatterns: options?.ignorePatterns,\n });\n }\n public static async getFilesChanged(): Promise<GitFileChange[]> {",
"score": 20.499556940461986
},
{
"filename": "src/services/git/github.service.ts",
"retrieved_chunk": " }\n private static convertParsedDiffToText(parsedDiff: ParsedFile[]): string {\n return parsedDiff\n .map((file) => {\n const chunks = file.chunks\n .map((chunk) => {\n const changes = chunk.changes\n .map((change) => {\n return `${change.type === 'normal' ? ' ' : change.type[0]}${\n change.content",
"score": 20.464761827627633
},
{
"filename": "src/interfaces/common.interface.ts",
"retrieved_chunk": "}\nexport interface GitFileChange {\n filename: string;\n status: 'deleted' | 'changed' | 'added';\n}\nexport interface GetFileResponse {\n content: string;\n filename: string;\n}",
"score": 16.47432600686711
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " await this.checkIsRepo();\n const status = await this.git.status();\n const added: GitFileChange[] = [...status.created, ...status.not_added].map(\n (filename) => ({ filename, status: 'added' }),\n );\n const deleted: GitFileChange[] = status.deleted.map((filename) => ({\n filename,\n status: 'deleted',\n }));\n const changed: GitFileChange[] = [",
"score": 14.033383830830847
}
] | typescript | GitFileChange[],
): Promise<GitFileChange[]> { |
/**
* An `AsyncResult` represents an asynchronous computation that may either
* succeed or fail (but should never throw). It is identical to `Async<Result<A, E>`.
* This module simply provides convenience functions for working with that
* type because they are so frequently used in real-world programming.
*
* Like `Async`, `AsyncResult` represents a "cold" computation that must be
* explicitly invoked/started, in contrast to `Promise`s, which are "hot."
*
* **Note:** You can use `Async.start` to start `AsyncResult`s because they are
* just `Async`s with a constrained inner value type.
*
* @module AsyncResult
*/
import { Result } from "./Result"
import { Async } from "./Async"
import { pipe } from "./Composition"
/**
* @typeParam A The type of the `Ok` branch.
* @typeParam E The type of the `Err` branch.
*/
export interface AsyncResult<A, E> {
(): Promise<Result<A, E>>
}
/**
* Construct a new `Ok` instance.
*
* @group Constructors
*
* @returns A new `AsyncResult` containing the given ok value.
*/
export const ok =
<A, E = never>(ok: A): AsyncResult<A, E> =>
() =>
Promise.resolve(Result.ok(ok))
/**
* Construct a new `Err` instance.
*
* @group Constructors
*
* @returns A new `AsyncResult` using the given err value.
*/
export const err =
<E, A = never>(err: E): AsyncResult<A, E> =>
() =>
Promise.resolve(Result.err(err))
/**
* Maps the wrapped `Ok` value using the given function and
* returns a new `AsyncResult`. Passes `Err` values through as-is.
*
* @group Mapping
*
* @example
* await pipe(
* AsyncResult.ok(10),
* AsyncResult.map(n => n * 2),
* Async.start
* ) // => Result.ok(20)
*/
export const map =
<A, B>(f: (a: A) => B) =>
<E>(async: AsyncResult<A, E>): AsyncResult<B, E> =>
() =>
async().then(Result.map(f))
/**
* Maps the wrapped `Err` value using the given function and
* returns a new `AsyncResult`. Passes `Ok` values through as-is.
*
* @group Mapping
*
* @example
* await pipe(
* AsyncResult.err("err"),
* AsyncResult.mapErr(s => s.length),
* Async.start
* ) // => Result.err(3)
*/
export const mapErr =
<Ea, Eb>(f: (a: Ea) => Eb) =>
<A>(async: AsyncResult<A, Ea>): AsyncResult<A, Eb> =>
() =>
async().then(Result.mapErr(f))
/**
* Takes two functions: one to map an `Ok`, one to map an `Err`.
* Returns a new AsyncResult with the projected value based
* on which function was used. Equivalent to calling {@link map} =
* followed by {@link mapErr}.
*
* @group Mapping
*/
export const mapBoth =
<A1, A2, E1, E2>(mapOk: (a: A1) => A2, mapErr: (e: E1) => E2) =>
(async: AsyncResult<A1, E1>) =>
() =>
async().then(Result.mapBoth(mapOk, mapErr))
/**
* Maps the wrapped `Ok` value using a given function that
* also returns an AsyncResult, and flattens the result.
* Also commonly known as `flatpMap`.
*
* @group Mapping
*
* @example
* declare const getNumberOfLines: (fileName: string) => AsyncResult<number, Error>
* declare const sendToServer: (numLines: number) => AsyncResult<{}, Error>
*
* await pipe(
* "log.txt", // string
* getNumberOfLines, // AsyncResult<number, Error>
* AsyncResult.bind(sendToServer), // AsyncResult<{}, Error>
* Async.start // Promise<Result<{}, Error>>
* )
* // returns Result.ok({}) if everything succeeds
* // otherwise returns Result.err(Error) if something
* // fell down along the way
*/
export const bind =
<A, B, E>(f: (a: A) => AsyncResult<B, E>) =>
(async: AsyncResult<A, E>): AsyncResult<B, E> =>
async () => {
const result = await async()
| return await pipe(
result,
Result.match({ |
ok: f,
err: e => err(e),
}),
Async.start
)
}
/**
* Alias for {@link bind}.
*
* @group Mapping
*/
export const flatMap = bind
/**
* Projects the wrapped `Ok` value using a given _synchronous_ function
* that returns a `Result` and flattens that result into a new `AsyncResult`.
* Primarily useful for composing together asynchronous workflows with
* synchronous functions that may also fail. (e.g., parsing a JSON string)
*
* @group Mapping
*
* @example
* declare const networkRequest: (url: string) => AsyncResult<JsonValue, Error>;
* declare const parseJson: (j: JsonValue) => Result<MyType, string>;
*
* await pipe(
* url, // string
* networkRequest, // AsyncResult<JsonValue, Error>
* AsyncResult.bindResult(flow(
* parseJson, // Result<MyType, string>
* Result.mapErr(s => new Error(s)) // Result<MyType, Error>
* )), // AsyncResult<MyType, Error>
* Async.start // Promise<Result<MyType, Error>>
* )
* // returns Result.ok(MyType) instance if everything succeeds,
* // otherwise returns Result.err(Error)F if something fell over
*/
export const bindResult =
<A, B, E>(f: (a: A) => Result<B, E>) =>
(async: AsyncResult<A, E>): AsyncResult<B, E> =>
() =>
async().then(Result.bind(f))
/**
* Alias for {@link bindResult}.
*
* @group Mapping
*/
export const flatMapResult = bindResult
/**
* Use this function to "lift" a `Result` value into the `AsyncResult` type.
* Essentially, this just wraps a `Result` into a lambda that returns an
* immediately-resolved `Promise` containing the `Result`.
*
* @group Utils
* @group Constructors
*/
export const ofResult =
<A, E>(result: Result<A, E>): AsyncResult<A, E> =>
() =>
Promise.resolve(result)
/**
* Use this function to "lift" an `Async` computation into an `AsyncResult`.
* Essentially, this just wraps the `Async`'s inner value into a `Result.ok`.
*
* @group Utils
* @group Constructors
*/
export const ofAsync =
<A, E = unknown>(async: Async<A>): AsyncResult<A, E> =>
() =>
async().then(a => Result.ok(a))
/* eslint-disable func-style */
/**
* Converts an `Async` computation that might reject into an
* Async computation that never rejects and returns a `Result`.
* (Remember that an `Async` is just a lambda returning a `Promise`.)
*
* If the `onThrow` callback function is given, it will be used to
* convert the thrown object into the Err branch. By default, the thrown
* object will be `string`-ed and wrapped in an Error if it is not an Error already.
*
* @group Utils
*
* @example
* ```
* declare const doHttpThing: (url: string) => Promise<number>;
*
* await pipe(
* AsyncResult.tryCatch(() => doHttpThing("/cats")), // AsyncResult<number, Error>
* AsyncResult.mapErr(e => e.message), // AsyncResult<number, string>
* Async.start // Promise<Result<number, string>>
* )
* // yields `Result.ok(number)` if the call succeeded
* // otherwise yields `Result.err(string)`
* ```
*/
export function tryCatch<A>(mightThrow: Async<A>): AsyncResult<A, Error>
export function tryCatch<A, E = unknown>(
mightThrow: Async<A>,
onThrow: (thrown: unknown) => E
): AsyncResult<A, E>
export function tryCatch<A, E = unknown>(
mightThrow: Async<A>,
onThrow?: (err: unknown) => E
): AsyncResult<A, unknown> {
return async () => {
const toError = (err: unknown) =>
err instanceof Error ? err : Error(String(err))
try {
return Result.ok(await mightThrow())
} catch (err) {
if (onThrow != null) {
return Result.err(onThrow(err))
}
return Result.err(toError(err))
}
}
}
/* eslint-enable func-style */
/**
* @ignore
*/
interface AsyncResultMatcher<A, E, R> {
readonly ok: R | ((ok: A) => R)
readonly err: R | ((err: E) => R)
}
/**
* Exhaustive pattern match against an `AsyncResult`. Pass a matcher
* object with cases for `ok` and `err` using either raw values or
* lambdas accepting the data associated with each case.
*
* This pattern match unwraps the inner `Result` and returns an `Async`
* computation containing the result of the match. Use {@link start} to
* convert the `Async` into a `Promise` which can be `await`-ed.
*
* @group Pattern Matching
*
* @example
* await pipe(
* AsyncResult.ok("alright!"),
* AsyncResult.match({
* ok: String.capitalize,
* err: "bah, humbug!",
* }),
* Async.start
* ) // => "Alright!"
*/
export const match =
<A, E, R>(matcher: AsyncResultMatcher<A, E, R>) =>
(async: AsyncResult<A, E>): Async<R> =>
() =>
async().then(Result.match(matcher))
/**
* Equivalent to both Async.start or simply invoking
* the AsyncResult as a function. Aliased here for convenience.
*
* @group Utils
*/
export const start = <A, E>(async: AsyncResult<A, E>) => async()
/**
* Execute an arbitrary side-effect on the inner `Ok` value of an `AsyncResult`
* within a pipeline of functions. Useful for logging and debugging. Passes
* the inner value through unchanged. Sometimes referred to as `do` or `tap`.
*
* The side-effect will be invoked once the underlying `Promise` has resolved.
*
* @param f The side-effect to execute. Should not mutate its arguments.
* @returns The `AsyncResult`, unchanged.
*
* @group Utils
*/
export const tee =
<A>(f: (a: A) => void) =>
<E>(async: AsyncResult<A, E>): AsyncResult<A, E> =>
Async.tee<Result<A, E>>(Result.tee(f))(async)
/**
* Execute an arbitrary side-effect on the inner `Err` value of an `AsyncResult`
* within a pipeline of functions. Useful for logging and debugging. Passes
* the inner value through unchanged. Sometimes referred to as `do` or `tap`.
*
* The side-effect will be invoked once the underlying `Promise` has resolved.
*
* @param f The side-effect to execute. Should not mutate its arguments.
* @returns The `AsyncResult`, unchanged.
*
* @group Utils
*/
export const teeErr =
<E>(f: (a: E) => void) =>
<A>(async: AsyncResult<A, E>): AsyncResult<A, E> =>
Async.tee<Result<A, E>>(Result.teeErr(f))(async)
/* c8 ignore start */
/** @ignore */
export const AsyncResult = {
ok,
err,
map,
mapErr,
mapBoth,
bind,
flatMap,
bindResult,
flatMapResult,
ofResult,
ofAsync,
tryCatch,
match,
start,
tee,
teeErr,
}
/* c8 ignore end */
| src/AsyncResult.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Async.ts",
"retrieved_chunk": " * ```\n */\nexport const tee =\n <A>(f: (a: A) => void) =>\n (async: Async<A>): Async<A> =>\n async () => {\n const a = await async()\n f(a)\n return a\n }",
"score": 46.16234705176997
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " */\nexport const bind = <A, E, B>(f: (a: A) => Result<B, E>) =>\n match<A, E, Result<B, E>>({\n ok: f,\n err: e => err(e),\n })\n/**\n * Alias for {@link bind}.\n *\n * @group Mapping",
"score": 45.13204004511851
},
{
"filename": "src/Async.ts",
"retrieved_chunk": " */\nexport const bind =\n <A, B>(f: (a: A) => Async<B>) =>\n (async: Async<A>): Async<B> =>\n () =>\n async().then(a => f(a)())\n/**\n * Alias of {@link bind}.\n *\n * @group Mapping",
"score": 45.00279528007329
},
{
"filename": "src/Array.ts",
"retrieved_chunk": " */\nexport const chooseR =\n <A, E, B>(f: (a: A) => Result<B, E>) =>\n (as: readonly A[]): readonly B[] => {\n const bs: B[] = []\n for (let i = 0; i < as.length; i++) {\n const result = f(as[i])\n if (Result.isOk(result)) {\n bs.push(result.ok)\n }",
"score": 42.80487270697468
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * pipe(\n * Result.ok(\"dog\"),\n * Result.refine(isCat, a => `\"${a}\" is not \"cat\"!`)\n * ) // => Result.err('\"dog\" is not \"cat\"!')\n * ```\n */\nexport const refine =\n <A, B extends A, E>(refinement: Refinement<A, B>, onFail: (a: A) => E) =>\n (result: Result<A, E>): Result<B, E> =>\n pipe(",
"score": 41.592653100052296
}
] | typescript | return await pipe(
result,
Result.match({ |
import {
CommandConfig,
GitConfig,
LocalReviewArgs,
OpenAIConfig,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { OpenAiService } from '../services/openai.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { BaseCommand } from './base.command';
export class LocalReviewCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async reviewDiff(
openAIConfig: OpenAIConfig,
gitConfig: GitConfig,
): Promise<string> {
const localDiff = await GitLocalService.getLocalDiff({
ignorePatterns: gitConfig.ignorePatterns,
});
logger.info('Reviewing local changes');
this.spinner.start();
return OpenAiService.reviewDiff(openAIConfig, localDiff);
}
private async reviewFile(
openAIConfig: OpenAIConfig,
directory: string,
filename: string,
): Promise<string> {
const getFileResponse = await FileService.getFileContentAndName(
directory,
filename,
);
const contentWithLineNumbers = FileService. | addLineNumbers(
getFileResponse.content,
); |
logger.info(`Reviewing ${getFileResponse.filename}`);
this.spinner.start();
return OpenAiService.reviewFile(
openAIConfig,
contentWithLineNumbers,
getFileResponse.filename,
);
}
protected async _run({
directory,
filename,
}: LocalReviewArgs): Promise<void> {
const config = ConfigService.load();
const openAIConfig = config.llm.openai;
const gitConfig = config.git;
this.spinner.text = 'Reviewing...';
const review = filename
? await this.reviewFile(openAIConfig, directory, filename)
: await this.reviewDiff(openAIConfig, gitConfig);
this.spinner.stop();
logger.info(review);
}
}
| src/commands/local-review.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " }\n}\nexport class FileService {\n public static async getFileContentAndName(\n directory: string,\n filename: string,\n ): Promise<GetFileResponse> {\n const escapedFilename = escapeStringRegexp(filename);\n const pattern = `${directory}/**/*${escapedFilename}*`;\n const matches = await fg(pattern, { onlyFiles: true });",
"score": 25.352546637639524
},
{
"filename": "src/commands/commit.command.ts",
"retrieved_chunk": " return GitLocalService.getFilesDiff(filenames, {\n ignorePatterns: gitConfig.ignorePatterns,\n });\n }\n private async selectChangedFiles(): Promise<FileSelectionStatus> {\n const fileChanges = await GitLocalService.getFilesChanged();\n const selectedFiles = await FileService.selectFiles(fileChanges);\n const selectedFileNames = new Set(\n selectedFiles.map((file) => file.filename),\n );",
"score": 14.441006957356102
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " const content = fs.readFileSync(file, 'utf8');\n return { filename: file, content };\n }\n public static async selectFiles(\n fileChanges: GitFileChange[],\n ): Promise<GitFileChange[]> {\n const response = await prompts({\n type: 'multiselect',\n name: 'files',\n message: 'Select files to commit:',",
"score": 10.72493059175481
},
{
"filename": "src/services/openai.service.ts",
"retrieved_chunk": " config: OpenAIConfig,\n fileContent: string,\n filename: string,\n ): Promise<string> {\n const prompt = PromptService.generateReviewFilePrompt(\n fileContent,\n filename,\n );\n const messages: ChatCompletionRequestMessage[] = [\n {",
"score": 10.368677971247712
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " if (matches.length === 0) {\n throw new FileServiceError(\n `File ${filename} not found in directory ${directory}`,\n );\n }\n let file: string;\n if (matches.length === 1) {\n file = matches[0];\n } else {\n const response = await prompts({",
"score": 10.187752951568605
}
] | typescript | addLineNumbers(
getFileResponse.content,
); |
import prompts from 'prompts';
import {
CommandConfig,
CommitAction,
FileSelectionStatus,
GitConfig,
GitDiff,
LocalReviewArgs,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { OpenAiService } from '../services/openai.service';
import { BaseCommand } from './base.command';
class CommitCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'CommitCommandError';
}
}
export class CommitCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async filesDiff(
filenames: string[],
gitConfig: GitConfig,
): Promise<GitDiff> {
logger.info('Reviewing local changes for commit');
return GitLocalService.getFilesDiff(filenames, {
ignorePatterns: gitConfig.ignorePatterns,
});
}
private async selectChangedFiles(): Promise<FileSelectionStatus> {
const fileChanges = await GitLocalService.getFilesChanged();
const selectedFiles = await FileService.selectFiles(fileChanges);
const selectedFileNames = new Set(
selectedFiles.map((file) => file.filename),
);
| const allFileNames = fileChanges.map((fileChange) => fileChange.filename); |
const unselectedFileNames = allFileNames.filter(
(filename) => !selectedFileNames.has(filename),
);
return {
selectedFileNames: Array.from(selectedFileNames),
unselectedFileNames: unselectedFileNames,
};
}
private async promptShouldContinueCommit(): Promise<boolean> {
const response = await prompts({
type: 'confirm',
name: 'value',
message: 'Do you want to continue commit?',
initial: false,
});
return response.value;
}
private async getCommitAction(): Promise<CommitAction> {
const response = await prompts({
type: 'select',
name: 'value',
message: 'Do you want to commit the message, replace it, or do nothing?',
choices: [
{ title: 'Commit', value: CommitAction.COMMIT },
{ title: 'Replace', value: CommitAction.REPLACE },
{ title: 'Do Nothing', value: CommitAction.SKIP },
],
initial: 0,
});
if (!response.value) {
throw new CommitCommandError('Commit action is required');
}
return response.value;
}
private async promptReplaceCommitMessage(
initialMessage: string,
): Promise<string> {
const response = await prompts({
type: 'text',
name: 'value',
message: 'Enter the new commit message:',
initial: initialMessage,
});
if (!response.value) {
throw new CommitCommandError('Commit message is required');
}
return response.value;
}
protected async _run(): Promise<void> {
let shouldContinueCommit = true;
const config = ConfigService.load();
const gitConfig = config.git;
const openAIConfig = config.llm.openai;
while (shouldContinueCommit) {
const { selectedFileNames, unselectedFileNames } =
await this.selectChangedFiles();
const diff = await this.filesDiff(selectedFileNames, gitConfig);
logger.info('Generating commit message');
const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
);
this.spinner.text = 'Generating commit message...';
this.spinner.start();
const commitMessage = await OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
);
this.spinner.stop();
logger.info(commitMessage);
const commitAction = await this.getCommitAction();
shouldContinueCommit = commitAction !== CommitAction.SKIP;
if (commitAction !== CommitAction.SKIP) {
const messageToCommit =
commitAction === CommitAction.COMMIT
? commitMessage
: await this.promptReplaceCommitMessage(commitMessage);
await GitLocalService.commit(messageToCommit, selectedFileNames);
shouldContinueCommit =
unselectedFileNames.length === 0
? false
: await this.promptShouldContinueCommit();
}
}
}
}
| src/commands/commit.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " public static async getLocalDiff(options?: {\n ignorePatterns?: string[];\n }): Promise<GitDiff> {\n const fileChanges = await this.getFilesChanged();\n const filenames = fileChanges.map((fileChange) => fileChange.filename);\n return this.getFilesDiff(filenames, {\n ignorePatterns: options?.ignorePatterns,\n });\n }\n public static async getFilesChanged(): Promise<GitFileChange[]> {",
"score": 46.1005350970873
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " choices: fileChanges\n .sort((a, b) => a.filename.localeCompare(b.filename))\n .map((fileChange) => ({\n title: this.colorize(fileChange),\n value: fileChange,\n })),\n initial: 0,\n min: 1,\n max: fileChanges.length,\n });",
"score": 34.279601188224724
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " const content = fs.readFileSync(file, 'utf8');\n return { filename: file, content };\n }\n public static async selectFiles(\n fileChanges: GitFileChange[],\n ): Promise<GitFileChange[]> {\n const response = await prompts({\n type: 'multiselect',\n name: 'files',\n message: 'Select files to commit:',",
"score": 25.82295867024761
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " }\n private static colorize(fileChange: GitFileChange): string {\n switch (fileChange.status) {\n case 'added':\n return chalk.green(fileChange.filename);\n case 'deleted':\n return chalk.red(fileChange.filename);\n case 'changed':\n return chalk.cyan(fileChange.filename);\n }",
"score": 18.78918099966434
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " options?: { ignorePatterns?: string[] },\n ): Promise<GitDiff> {\n await this.checkIsRepo();\n const ignorePatterns =\n options?.ignorePatterns?.map((pattern) => new RegExp(pattern)) || [];\n const filteredFilenames = filenames.filter((filename) => {\n return !ignorePatterns.some((pattern) => pattern.test(filename));\n });\n if (filteredFilenames.length === 0) {\n throw new GitLocalServiceError('No files to diff');",
"score": 18.682126683737724
}
] | typescript | const allFileNames = fileChanges.map((fileChange) => fileChange.filename); |
import fs from 'fs';
import path from 'path';
import os from 'os';
import merge from 'lodash.merge';
import { Config } from '../interfaces';
const CONFIG_FILENAME = 'revu.json';
const DEFAULT_CONFIG: Config = {
git: {
ignorePatterns: [],
maxCommitHistory: 10,
},
github: {
githubApiUrl: 'https://api.github.com',
secretGithubToken: '',
},
llm: {
openai: {
openaiApiUrl: 'https://api.openai.com',
openaiModel: 'gpt-3.5-turbo',
openaiTemperature: 0,
secretOpenaiApiKey: '',
},
},
};
class ConfigurationError extends Error {
constructor(message: string) {
super(message);
this.name = 'ConfigurationError';
}
}
export class ConfigService {
private static getConfigPath(): string {
const configDir =
process.env.NODE_ENV === 'development'
? process.cwd()
: path.join(os.homedir(), '.revu');
return path.join(configDir, CONFIG_FILENAME);
}
private static fromEnvOrDefault(): Config {
const envConfig = {
git: {
ignorePatterns: process.env.GIT_IGNORE_PATTERNS?.split(','),
maxCommitHistory: process.env.GIT_MAX_COMMIT_HISTORY
? Number(process.env.GIT_MAX_COMMIT_HISTORY)
: undefined,
},
github: {
githubApiUrl: process.env.GITHUB_API_URL,
secretGithubToken: process.env.GITHUB_TOKEN,
},
llm: {
openai: {
openaiApiUrl: process.env.OPENAI_API_URL,
openaiModel: process.env.OPENAI_MODEL,
openaiTemperature: process.env.OPENAI_TEMPERATURE
? Number(process.env.OPENAI_TEMPERATURE)
: undefined,
secretOpenaiApiKey: process.env.OPENAI_API_KEY,
},
},
} as Config;
const cleanedEnvConfig = JSON.parse(JSON.stringify(envConfig));
return merge({}, DEFAULT_CONFIG, cleanedEnvConfig);
}
static fromFileOrDefault(): Config {
let fileConfig = {} as Config;
if (this.configFileExists()) {
try {
fileConfig = JSON.parse(fs.readFileSync(this.getConfigPath(), 'utf-8'));
} catch (err) {
throw new ConfigurationError(
'Unable to parse the configuration file. Please ensure it is valid JSON.',
);
}
}
return merge({}, DEFAULT_CONFIG, fileConfig);
}
private static validateTemperature(temperature: number): void {
if (!(temperature >= 0.0 && temperature <= 2.0)) {
throw new ConfigurationError(
'Invalid temperature value. It must be a value between 0 and 2 (inclusive).',
);
}
}
private static configFileExists(): boolean {
const configPath = this.getConfigPath();
return fs.existsSync(configPath);
}
static save({
githubToken,
openaiApiKey,
}: {
githubToken: string;
openaiApiKey: string;
}): void {
const configPath = this.getConfigPath();
const dir = path.dirname(configPath);
if (!fs.existsSync(dir)) {
fs.mkdirSync(dir, { recursive: true });
}
const config = this.fromFileOrDefault();
| config.github.secretGithubToken = githubToken; |
config.llm.openai.secretOpenaiApiKey = openaiApiKey;
fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
}
static load(): Config {
const config = this.configFileExists()
? this.fromFileOrDefault()
: this.fromEnvOrDefault();
this.validateTemperature(config.llm.openai.openaiTemperature);
return config;
}
}
| src/services/config.service.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/commands/config.command.ts",
"retrieved_chunk": "export class ConfigCommand extends BaseCommand<void> {\n constructor(config: CommandConfig) {\n super(config);\n }\n protected async _run(): Promise<void> {\n const response = await prompts(\n [\n {\n type: 'password',\n name: 'githubToken',",
"score": 17.86825169869494
},
{
"filename": "src/commands/config.command.ts",
"retrieved_chunk": " {\n onCancel: () => {\n throw new ConfigCommandError('Setup was cancelled by the user');\n },\n },\n );\n await ConfigService.save({\n githubToken: response.githubToken,\n openaiApiKey: response.openApiKey,\n });",
"score": 16.58372234432513
},
{
"filename": "src/commands/commit.command.ts",
"retrieved_chunk": " let shouldContinueCommit = true;\n const config = ConfigService.load();\n const gitConfig = config.git;\n const openAIConfig = config.llm.openai;\n while (shouldContinueCommit) {\n const { selectedFileNames, unselectedFileNames } =\n await this.selectChangedFiles();\n const diff = await this.filesDiff(selectedFileNames, gitConfig);\n logger.info('Generating commit message');\n const commitHistory = await GitLocalService.getCommitHistory(",
"score": 12.762703967542887
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " }: LocalReviewArgs): Promise<void> {\n const config = ConfigService.load();\n const openAIConfig = config.llm.openai;\n const gitConfig = config.git;\n this.spinner.text = 'Reviewing...';\n const review = filename\n ? await this.reviewFile(openAIConfig, directory, filename)\n : await this.reviewDiff(openAIConfig, gitConfig);\n this.spinner.stop();\n logger.info(review);",
"score": 12.462267638054374
},
{
"filename": "src/services/git/github.service.ts",
"retrieved_chunk": " ): Promise<GitDiff> {\n const { owner, repo } = this.getOwnerAndRepo(fullRepositoryPath);\n const apiPrUrl = `${githubConfig.githubApiUrl}/repos/${owner}/${repo}/pulls/${prNumber}`;\n const diffResponse = await fetch(apiPrUrl, {\n headers: {\n Authorization: `Bearer ${githubConfig.secretGithubToken}`,\n 'User-Agent': 'Revu-CLI',\n Accept: 'application/vnd.github.diff',\n },\n });",
"score": 11.189010210627222
}
] | typescript | config.github.secretGithubToken = githubToken; |
/**
* The `DeferredResult` type is simply a convenient alias for a {@link Deferred} with an
* inner value of a result {@link Result}. The `DeferredResult` type is frequently useful
* for modeling the state of an asynchronous operation in something like a Redux store or
* the `State` type of a React `useReducer` hook.
*
* The most common use case for this module is to make a decision about what text/UI
* components to display to a user based on the state of some asynchronous operation that
* is potentially ongoing.
*
* See docs for {@link match} and {@link matchOrElse} for code examples.
*
* @module
*/
import { pipe } from "./Composition"
import { Deferred } from "./Deferred"
import { assertExhaustive, Identity } from "./prelude"
import { Result } from "./Result"
export type DeferredResult<A, E> = Deferred<Result<A, E>>
/** @ignore */
interface DeferredResultMatcher<A, E, R> {
readonly notStarted: (() => R) | R
readonly inProgress: (() => R) | R
readonly resolvedOk: ((ok: A) => R) | R
readonly resolvedErr: ((ok: E) => R) | R
}
/** @ignore */
interface PartialDeferredResultMatcher<A, E, R>
extends Partial<DeferredResultMatcher<A, E, R>> {
readonly orElse: (() => R) | R
}
const isRawValue = <A, E, R>(caseFn: R | ((ok: A) => R) | ((err: E) => E)): caseFn is R =>
typeof caseFn !== "function"
const getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>
isRawValue(match) ? match : match(arg)
const objHasOptionalProp = <T extends object, P extends keyof T>(
prop: P,
obj: T
): obj is Identity<T & Required<{ [key in P]: T[P] }>> => Object.hasOwn(obj, prop)
/**
* Exhaustive pattern match against a `DeferredResult`. Provide a raw value or
* lambda function to use in each case: `notStarted`, `inProgress`, `resolvedOk`,
* and `resolvedErr`. For `resolvedOk` and `resolvedErr`, the lambda function
* will be given the attached "ok" or "err" data attached to the `Result`.
*
* @param matcher The matcher object containing the value or function to use in each case.
*
* @returns The result of evaluating the matcher case appropriate to the value.
*
* @group Pattern Matching
*
* @example
* ```ts
* declare const apiCallResponse: DeferredResult<Fruit, ApiError>
* pipe(
* apiCallResponse,
* DeferredResult.match({
* notStarted: "Not Started",
* inProgress: "In Progress",
* resolvedOk: fruit => `Fruit is: ${fruit.name}`,
* resolvedErr: apiError => `Error was: ${ApiError.toString(apiError)}`
* })
* )
* ```
*/
export const match =
<A, E, R>(matcher: DeferredResultMatcher<A, E, R>) =>
(deferredResult: DeferredResult<A, E>) => {
switch (deferredResult._tag) {
case "InProgress":
return getMatcherResult(matcher.inProgress, undefined)
case "NotStarted":
return getMatcherResult(matcher.notStarted, undefined)
case "Resolved":
return | pipe(
deferredResult.resolved,
Result.match({ |
ok: a => getMatcherResult(matcher.resolvedOk, a),
err: e => getMatcherResult(matcher.resolvedErr, e),
})
)
/* c8 ignore next 2 */
default:
return assertExhaustive(deferredResult)
}
}
/**
* Non-exhaustive pattern match against a `DeferredResult` value. Provide a raw
* value or a lambda function to use in the cases you care about. (But don't provide
* all the cases; if you want an exhaustive pattern match, use {@link match} instead.)
* Must provide an `orElse` matcher case to use if no other match case is hit.
*
* This function is especially useful for when you really only care about the "resolved"
* cases, for instance.
*
* @param matcher The matcher object containing the value or function to use in each case.
*
* @returns The result of evaluating the matcher case appropriate to the value.
*
* @group Pattern Matching
*
* @example
* ```ts
* declare const apiResponse: DeferredResult<Fruit, ApiError>
* pipe(
* apiResponse,
* DeferredResult.matchOrElse({
* resolvedOk: fruit => `Got fruit! ${fruit.name}`,
* resolvedErr: apiError => `Oh noes! ${apiError.message}`,
* orElse: "Still loading..."
* })
* )
* ```
*/
export const matchOrElse =
<A, E, R>(matcher: PartialDeferredResultMatcher<A, E, R>) =>
(deferredResult: DeferredResult<A, E>) => {
switch (deferredResult._tag) {
case "InProgress":
return objHasOptionalProp("inProgress", matcher)
? getMatcherResult(matcher.inProgress, undefined)
: getMatcherResult(matcher.orElse, undefined)
case "NotStarted":
return objHasOptionalProp("notStarted", matcher)
? getMatcherResult(matcher.notStarted, undefined)
: getMatcherResult(matcher.orElse, undefined)
case "Resolved":
return pipe(
deferredResult.resolved,
Result.match({
ok: a =>
objHasOptionalProp("resolvedOk", matcher)
? getMatcherResult(matcher.resolvedOk, a)
: getMatcherResult(matcher.orElse, undefined),
err: e =>
objHasOptionalProp("resolvedErr", matcher)
? getMatcherResult(matcher.resolvedErr, e)
: getMatcherResult(matcher.orElse, undefined),
})
)
/* c8 ignore next 2 */
default:
return assertExhaustive(deferredResult)
}
}
/* c8 ignore start */
/** @ignore */
export const DeferredResult = {
match,
matchOrElse,
}
/* c8 ignore start */
| src/DeferredResult.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Deferred.ts",
"retrieved_chunk": " switch (deferred._tag) {\n case \"NotStarted\":\n return resultOrValue(matcher.notStarted)\n case \"InProgress\":\n return resultOrValue(matcher.inProgress)\n case \"Resolved\":\n return resultOrValue(matcher.resolved, deferred.resolved)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(deferred) as R",
"score": 65.72201693751646
},
{
"filename": "src/Deferred.ts",
"retrieved_chunk": " case \"InProgress\":\n return resultOrValue(\n matcher.inProgress != null ? matcher.inProgress : matcher.orElse\n )\n case \"Resolved\":\n return matcher.resolved != null\n ? resultOrValue(matcher.resolved, deferred.resolved)\n : resultOrValue(matcher.orElse)\n /* c8 ignore next 2 */\n default:",
"score": 51.55515827291554
},
{
"filename": "src/Deferred.ts",
"retrieved_chunk": " * ```\n */\nexport const matchOrElse =\n <A, R>(matcher: PartialDeferredMatcher<A, R>) =>\n (deferred: Deferred<A>) => {\n switch (deferred._tag) {\n case \"NotStarted\":\n return resultOrValue(\n matcher.notStarted != null ? matcher.notStarted : matcher.orElse\n )",
"score": 44.9540764509866
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " case \"Ok\":\n return getMatcherResult(matcher.ok, result.ok)\n case \"Err\":\n return getMatcherResult(matcher.err, result.err)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(result)\n }\n }\n/**",
"score": 43.248938730685175
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " * none: 0,\n * })\n * ) // => 84\n */\nexport const match =\n <A extends NonNullish, R>(matcher: OptionMatcher<A, R>) =>\n (option: Option<A>) => {\n switch (option._tag) {\n case \"Some\":\n return getMatcherResult(matcher.some, option.some)",
"score": 42.331972674615194
}
] | typescript | pipe(
deferredResult.resolved,
Result.match({ |
#!/usr/bin/env node
import { Command } from 'commander';
// eslint-disable-next-line @typescript-eslint/ban-ts-comment
// @ts-ignore
import { version } from '../package.json';
import { ConfigCommand } from './commands/config.command';
import { LocalReviewCommand } from './commands/local-review.command';
import { PullRequestReviewCommand } from './commands/pull-request-review.command';
import { LocalReviewArgs } from './interfaces';
import { CommitCommand } from './commands/commit.command';
import { checkForUpdate } from './utils/update-notifier';
const program = new Command();
program
.version(version || '0.0.0')
.description(
'revu-cli - Streamlining code reviews and commit message generation using GPT-4.',
);
program
.command('config')
.description('Configure revu-cli')
.action(async () => {
const configCommand = new ConfigCommand({ commandName: 'config' });
await configCommand.run();
});
program
.command('pr <repository> <pull_request>')
.description('Review a pull request')
.action(async (repository: string, pullRequest: string) => {
const pullRequestReviewCommand = new PullRequestReviewCommand({
commandName: 'pr-review',
});
await pullRequestReviewCommand.run({
fullRepository: repository,
pullRequest,
});
});
program
.command('local')
.description('Review local changes or a specific file')
.option('-f, --filename <filename>', 'filename to review', '')
.option('-d, --directory <directory>', 'directory of the file to review', '.')
.action( | async (localReviewArgs: LocalReviewArgs) => { |
const localReviewCommand = new LocalReviewCommand({
commandName: 'local-review',
});
await localReviewCommand.run(localReviewArgs);
});
program
.command('commit')
.description('Generate commit message and commit selected files')
.action(async () => {
const commitCommand = new CommitCommand({
commandName: 'commit',
});
await commitCommand.run();
});
program.parseAsync(process.argv).then(() => {
checkForUpdate(version);
});
if (!process.argv.slice(2).length) {
program.outputHelp();
}
| src/main.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " if (matches.length === 0) {\n throw new FileServiceError(\n `File ${filename} not found in directory ${directory}`,\n );\n }\n let file: string;\n if (matches.length === 1) {\n file = matches[0];\n } else {\n const response = await prompts({",
"score": 20.047655596052884
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " }: LocalReviewArgs): Promise<void> {\n const config = ConfigService.load();\n const openAIConfig = config.llm.openai;\n const gitConfig = config.git;\n this.spinner.text = 'Reviewing...';\n const review = filename\n ? await this.reviewFile(openAIConfig, directory, filename)\n : await this.reviewDiff(openAIConfig, gitConfig);\n this.spinner.stop();\n logger.info(review);",
"score": 19.93839257751118
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " this.spinner.start();\n return OpenAiService.reviewFile(\n openAIConfig,\n contentWithLineNumbers,\n getFileResponse.filename,\n );\n }\n protected async _run({\n directory,\n filename,",
"score": 17.351609312997812
},
{
"filename": "src/services/file.service.ts",
"retrieved_chunk": " }\n}\nexport class FileService {\n public static async getFileContentAndName(\n directory: string,\n filename: string,\n ): Promise<GetFileResponse> {\n const escapedFilename = escapeStringRegexp(filename);\n const pattern = `${directory}/**/*${escapedFilename}*`;\n const matches = await fg(pattern, { onlyFiles: true });",
"score": 17.266692409412233
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " const localDiff = await GitLocalService.getLocalDiff({\n ignorePatterns: gitConfig.ignorePatterns,\n });\n logger.info('Reviewing local changes');\n this.spinner.start();\n return OpenAiService.reviewDiff(openAIConfig, localDiff);\n }\n private async reviewFile(\n openAIConfig: OpenAIConfig,\n directory: string,",
"score": 17.016294234815177
}
] | typescript | async (localReviewArgs: LocalReviewArgs) => { |
import prompts from 'prompts';
import {
CommandConfig,
CommitAction,
FileSelectionStatus,
GitConfig,
GitDiff,
LocalReviewArgs,
} from '../interfaces';
import { ConfigService } from '../services/config.service';
import { GitLocalService } from '../services/git/git-local.service';
import { FileService } from '../services/file.service';
import { logger } from '../logger';
import { OpenAiService } from '../services/openai.service';
import { BaseCommand } from './base.command';
class CommitCommandError extends Error {
constructor(message: string) {
super(message);
this.name = 'CommitCommandError';
}
}
export class CommitCommand extends BaseCommand<LocalReviewArgs> {
constructor(config: CommandConfig) {
super(config);
}
private async filesDiff(
filenames: string[],
gitConfig: GitConfig,
): Promise<GitDiff> {
logger.info('Reviewing local changes for commit');
return GitLocalService.getFilesDiff(filenames, {
ignorePatterns: gitConfig.ignorePatterns,
});
}
private async selectChangedFiles(): Promise<FileSelectionStatus> {
const fileChanges = await GitLocalService.getFilesChanged();
const selectedFiles = await FileService.selectFiles(fileChanges);
const selectedFileNames = new Set(
selectedFiles.map((file) => file.filename),
);
const allFileNames = fileChanges.map((fileChange) => fileChange.filename);
const unselectedFileNames = allFileNames.filter(
(filename) => !selectedFileNames.has(filename),
);
return {
selectedFileNames: Array.from(selectedFileNames),
unselectedFileNames: unselectedFileNames,
};
}
private async promptShouldContinueCommit(): Promise<boolean> {
const response = await prompts({
type: 'confirm',
name: 'value',
message: 'Do you want to continue commit?',
initial: false,
});
return response.value;
}
private async getCommitAction(): Promise<CommitAction> {
const response = await prompts({
type: 'select',
name: 'value',
message: 'Do you want to commit the message, replace it, or do nothing?',
choices: [
{ title: 'Commit', value: CommitAction.COMMIT },
{ title: 'Replace', value: CommitAction.REPLACE },
{ title: 'Do Nothing', value: CommitAction.SKIP },
],
initial: 0,
});
if (!response.value) {
throw new CommitCommandError('Commit action is required');
}
return response.value;
}
private async promptReplaceCommitMessage(
initialMessage: string,
): Promise<string> {
const response = await prompts({
type: 'text',
name: 'value',
message: 'Enter the new commit message:',
initial: initialMessage,
});
if (!response.value) {
throw new CommitCommandError('Commit message is required');
}
return response.value;
}
protected async _run(): Promise<void> {
let shouldContinueCommit = true;
const config = ConfigService.load();
const gitConfig = config.git;
const openAIConfig = config.llm.openai;
while (shouldContinueCommit) {
const { selectedFileNames, unselectedFileNames } =
await this.selectChangedFiles();
const diff = await this.filesDiff(selectedFileNames, gitConfig);
logger.info('Generating commit message');
const commitHistory = await GitLocalService.getCommitHistory(
gitConfig.maxCommitHistory,
);
this.spinner.text = 'Generating commit message...';
this.spinner.start();
const commitMessage = await OpenAiService.generateCommitMessage(
openAIConfig,
diff,
commitHistory,
);
this.spinner.stop();
logger.info(commitMessage);
const commitAction = await this.getCommitAction();
shouldContinueCommit = commitAction !== CommitAction.SKIP;
if (commitAction !== CommitAction.SKIP) {
const messageToCommit =
commitAction === CommitAction.COMMIT
? commitMessage
: await this.promptReplaceCommitMessage(commitMessage);
| await GitLocalService.commit(messageToCommit, selectedFileNames); |
shouldContinueCommit =
unselectedFileNames.length === 0
? false
: await this.promptShouldContinueCommit();
}
}
}
}
| src/commands/commit.command.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/interfaces/common.interface.ts",
"retrieved_chunk": "}\nexport enum CommitAction {\n COMMIT = 'commit',\n REPLACE = 'replace',\n SKIP = 'skip',\n}\nexport interface GitDiff {\n diff: string;\n}\nexport interface LocalReviewArgs {",
"score": 33.050768644957174
},
{
"filename": "src/commands/pull-request-review.command.ts",
"retrieved_chunk": " );\n this.spinner.text = 'Reviewing...';\n this.spinner.start();\n const review = await OpenAiService.reviewDiff(\n openAIConfig,\n pullRequestDiff,\n );\n this.spinner.stop();\n logger.info(review);\n }",
"score": 20.467766102825898
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " }: LocalReviewArgs): Promise<void> {\n const config = ConfigService.load();\n const openAIConfig = config.llm.openai;\n const gitConfig = config.git;\n this.spinner.text = 'Reviewing...';\n const review = filename\n ? await this.reviewFile(openAIConfig, directory, filename)\n : await this.reviewDiff(openAIConfig, gitConfig);\n this.spinner.stop();\n logger.info(review);",
"score": 16.81827068745213
},
{
"filename": "src/commands/local-review.command.ts",
"retrieved_chunk": " const localDiff = await GitLocalService.getLocalDiff({\n ignorePatterns: gitConfig.ignorePatterns,\n });\n logger.info('Reviewing local changes');\n this.spinner.start();\n return OpenAiService.reviewDiff(openAIConfig, localDiff);\n }\n private async reviewFile(\n openAIConfig: OpenAIConfig,\n directory: string,",
"score": 15.247509452840088
},
{
"filename": "src/commands/base.command.ts",
"retrieved_chunk": " protected abstract _run(args?: T): Promise<void>;\n public async run(args?: T): Promise<void> {\n try {\n await this._run(args);\n } catch (error: any) {\n this.spinner.stop();\n logger.error(error.message);\n process.exit(1);\n }\n }",
"score": 12.925556204354315
}
] | typescript | await GitLocalService.commit(messageToCommit, selectedFileNames); |
/**
* The `DeferredResult` type is simply a convenient alias for a {@link Deferred} with an
* inner value of a result {@link Result}. The `DeferredResult` type is frequently useful
* for modeling the state of an asynchronous operation in something like a Redux store or
* the `State` type of a React `useReducer` hook.
*
* The most common use case for this module is to make a decision about what text/UI
* components to display to a user based on the state of some asynchronous operation that
* is potentially ongoing.
*
* See docs for {@link match} and {@link matchOrElse} for code examples.
*
* @module
*/
import { pipe } from "./Composition"
import { Deferred } from "./Deferred"
import { assertExhaustive, Identity } from "./prelude"
import { Result } from "./Result"
export type DeferredResult<A, E> = Deferred<Result<A, E>>
/** @ignore */
interface DeferredResultMatcher<A, E, R> {
readonly notStarted: (() => R) | R
readonly inProgress: (() => R) | R
readonly resolvedOk: ((ok: A) => R) | R
readonly resolvedErr: ((ok: E) => R) | R
}
/** @ignore */
interface PartialDeferredResultMatcher<A, E, R>
extends Partial<DeferredResultMatcher<A, E, R>> {
readonly orElse: (() => R) | R
}
const isRawValue = <A, E, R>(caseFn: R | ((ok: A) => R) | ((err: E) => E)): caseFn is R =>
typeof caseFn !== "function"
const getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>
isRawValue(match) ? match : match(arg)
const objHasOptionalProp = <T extends object, P extends keyof T>(
prop: P,
obj: T
): obj is Identity<T & Required<{ [key in P]: T[P] }>> => Object.hasOwn(obj, prop)
/**
* Exhaustive pattern match against a `DeferredResult`. Provide a raw value or
* lambda function to use in each case: `notStarted`, `inProgress`, `resolvedOk`,
* and `resolvedErr`. For `resolvedOk` and `resolvedErr`, the lambda function
* will be given the attached "ok" or "err" data attached to the `Result`.
*
* @param matcher The matcher object containing the value or function to use in each case.
*
* @returns The result of evaluating the matcher case appropriate to the value.
*
* @group Pattern Matching
*
* @example
* ```ts
* declare const apiCallResponse: DeferredResult<Fruit, ApiError>
* pipe(
* apiCallResponse,
* DeferredResult.match({
* notStarted: "Not Started",
* inProgress: "In Progress",
* resolvedOk: fruit => `Fruit is: ${fruit.name}`,
* resolvedErr: apiError => `Error was: ${ApiError.toString(apiError)}`
* })
* )
* ```
*/
export const match =
<A, E, R>(matcher: DeferredResultMatcher<A, E, R>) =>
(deferredResult: DeferredResult<A, E>) => {
switch (deferredResult._tag) {
case "InProgress":
return getMatcherResult(matcher.inProgress, undefined)
case "NotStarted":
return getMatcherResult(matcher.notStarted, undefined)
case "Resolved":
return pipe(
deferredResult.resolved,
Result.match({
ok: a => getMatcherResult(matcher.resolvedOk, a),
err: e => getMatcherResult(matcher.resolvedErr, e),
})
)
/* c8 ignore next 2 */
default:
return | assertExhaustive(deferredResult)
} |
}
/**
* Non-exhaustive pattern match against a `DeferredResult` value. Provide a raw
* value or a lambda function to use in the cases you care about. (But don't provide
* all the cases; if you want an exhaustive pattern match, use {@link match} instead.)
* Must provide an `orElse` matcher case to use if no other match case is hit.
*
* This function is especially useful for when you really only care about the "resolved"
* cases, for instance.
*
* @param matcher The matcher object containing the value or function to use in each case.
*
* @returns The result of evaluating the matcher case appropriate to the value.
*
* @group Pattern Matching
*
* @example
* ```ts
* declare const apiResponse: DeferredResult<Fruit, ApiError>
* pipe(
* apiResponse,
* DeferredResult.matchOrElse({
* resolvedOk: fruit => `Got fruit! ${fruit.name}`,
* resolvedErr: apiError => `Oh noes! ${apiError.message}`,
* orElse: "Still loading..."
* })
* )
* ```
*/
export const matchOrElse =
<A, E, R>(matcher: PartialDeferredResultMatcher<A, E, R>) =>
(deferredResult: DeferredResult<A, E>) => {
switch (deferredResult._tag) {
case "InProgress":
return objHasOptionalProp("inProgress", matcher)
? getMatcherResult(matcher.inProgress, undefined)
: getMatcherResult(matcher.orElse, undefined)
case "NotStarted":
return objHasOptionalProp("notStarted", matcher)
? getMatcherResult(matcher.notStarted, undefined)
: getMatcherResult(matcher.orElse, undefined)
case "Resolved":
return pipe(
deferredResult.resolved,
Result.match({
ok: a =>
objHasOptionalProp("resolvedOk", matcher)
? getMatcherResult(matcher.resolvedOk, a)
: getMatcherResult(matcher.orElse, undefined),
err: e =>
objHasOptionalProp("resolvedErr", matcher)
? getMatcherResult(matcher.resolvedErr, e)
: getMatcherResult(matcher.orElse, undefined),
})
)
/* c8 ignore next 2 */
default:
return assertExhaustive(deferredResult)
}
}
/* c8 ignore start */
/** @ignore */
export const DeferredResult = {
match,
matchOrElse,
}
/* c8 ignore start */
| src/DeferredResult.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Result.ts",
"retrieved_chunk": " case \"Ok\":\n return getMatcherResult(matcher.ok, result.ok)\n case \"Err\":\n return getMatcherResult(matcher.err, result.err)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(result)\n }\n }\n/**",
"score": 55.3202366450147
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " case \"None\":\n return getMatcherResult(matcher.none, void 0)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(option)\n }\n }\n/**\n * Maps the wrapped `Some` value using the given function.\n * Passes through `None` as-is.",
"score": 37.9581406685755
},
{
"filename": "src/Deferred.ts",
"retrieved_chunk": " switch (deferred._tag) {\n case \"NotStarted\":\n return resultOrValue(matcher.notStarted)\n case \"InProgress\":\n return resultOrValue(matcher.inProgress)\n case \"Resolved\":\n return resultOrValue(matcher.resolved, deferred.resolved)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(deferred) as R",
"score": 31.782615938177607
},
{
"filename": "src/Deferred.ts",
"retrieved_chunk": " case \"InProgress\":\n return resultOrValue(\n matcher.inProgress != null ? matcher.inProgress : matcher.orElse\n )\n case \"Resolved\":\n return matcher.resolved != null\n ? resultOrValue(matcher.resolved, deferred.resolved)\n : resultOrValue(matcher.orElse)\n /* c8 ignore next 2 */\n default:",
"score": 29.45272330700275
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " result,\n match({\n ok: a => ok(a),\n err: e => {\n f(e)\n return err(e)\n },\n })\n )\n/**",
"score": 27.828763872826958
}
] | typescript | assertExhaustive(deferredResult)
} |
import fs from 'fs';
import fg from 'fast-glob';
import prompts from 'prompts';
import escapeStringRegexp from 'escape-string-regexp';
import chalk from 'chalk';
import { GetFileResponse, GitFileChange } from '../interfaces';
class FileServiceError extends Error {
constructor(message: string) {
super(message);
this.name = 'FileServiceError';
}
}
export class FileService {
public static async getFileContentAndName(
directory: string,
filename: string,
): Promise<GetFileResponse> {
const escapedFilename = escapeStringRegexp(filename);
const pattern = `${directory}/**/*${escapedFilename}*`;
const matches = await fg(pattern, { onlyFiles: true });
if (matches.length === 0) {
throw new FileServiceError(
`File ${filename} not found in directory ${directory}`,
);
}
let file: string;
if (matches.length === 1) {
file = matches[0];
} else {
const response = await prompts({
type: 'autocomplete',
name: 'file',
message: 'Multiple files match. Please select a file to review:',
choices: matches
.sort()
.map((match) => ({ title: match, value: match })),
initial: 0,
suggest: (input, choices) => {
const inputValue = input.toLowerCase();
const filteredChoices = choices.filter((choice) =>
choice.title.toLowerCase().includes(inputValue),
);
return Promise.resolve(filteredChoices);
},
});
if (!response.file) {
throw new FileServiceError('No file was selected from the prompt');
}
file = response.file;
}
const content = fs.readFileSync(file, 'utf8');
return { filename: file, content };
}
public static async selectFiles(
| fileChanges: GitFileChange[],
): Promise<GitFileChange[]> { |
const response = await prompts({
type: 'multiselect',
name: 'files',
message: 'Select files to commit:',
choices: fileChanges
.sort((a, b) => a.filename.localeCompare(b.filename))
.map((fileChange) => ({
title: this.colorize(fileChange),
value: fileChange,
})),
initial: 0,
min: 1,
max: fileChanges.length,
});
if (!response.files) {
throw new FileServiceError('No files were selected from the prompt');
}
return response.files;
}
public static addLineNumbers(content: string): string {
return content
.split('\n')
.map((line, index) => `${index + 1} | ${line}`)
.join('\n');
}
private static colorize(fileChange: GitFileChange): string {
switch (fileChange.status) {
case 'added':
return chalk.green(fileChange.filename);
case 'deleted':
return chalk.red(fileChange.filename);
case 'changed':
return chalk.cyan(fileChange.filename);
}
}
}
| src/services/file.service.ts | phmz-revu-cli-1a19883 | [
{
"filename": "src/commands/commit.command.ts",
"retrieved_chunk": " return GitLocalService.getFilesDiff(filenames, {\n ignorePatterns: gitConfig.ignorePatterns,\n });\n }\n private async selectChangedFiles(): Promise<FileSelectionStatus> {\n const fileChanges = await GitLocalService.getFilesChanged();\n const selectedFiles = await FileService.selectFiles(fileChanges);\n const selectedFileNames = new Set(\n selectedFiles.map((file) => file.filename),\n );",
"score": 30.934230349554735
},
{
"filename": "src/services/git/github.service.ts",
"retrieved_chunk": " }\n private static convertParsedDiffToText(parsedDiff: ParsedFile[]): string {\n return parsedDiff\n .map((file) => {\n const chunks = file.chunks\n .map((chunk) => {\n const changes = chunk.changes\n .map((change) => {\n return `${change.type === 'normal' ? ' ' : change.type[0]}${\n change.content",
"score": 23.577208815724504
},
{
"filename": "src/services/git/git-local.service.ts",
"retrieved_chunk": " public static async getLocalDiff(options?: {\n ignorePatterns?: string[];\n }): Promise<GitDiff> {\n const fileChanges = await this.getFilesChanged();\n const filenames = fileChanges.map((fileChange) => fileChange.filename);\n return this.getFilesDiff(filenames, {\n ignorePatterns: options?.ignorePatterns,\n });\n }\n public static async getFilesChanged(): Promise<GitFileChange[]> {",
"score": 20.499556940461986
},
{
"filename": "src/main.ts",
"retrieved_chunk": " .option('-d, --directory <directory>', 'directory of the file to review', '.')\n .action(async (localReviewArgs: LocalReviewArgs) => {\n const localReviewCommand = new LocalReviewCommand({\n commandName: 'local-review',\n });\n await localReviewCommand.run(localReviewArgs);\n });\nprogram\n .command('commit')\n .description('Generate commit message and commit selected files')",
"score": 18.54149597124883
},
{
"filename": "src/services/git/github.service.ts",
"retrieved_chunk": " }`;\n })\n .join('\\n');\n return `@@ -${chunk.oldStart},${chunk.oldLines} +${chunk.newStart},${chunk.newLines} @@\\n${changes}`;\n })\n .join('\\n\\n');\n return `--- ${file.from}\\n+++ ${file.to}\\n${chunks}`;\n })\n .join('\\n\\n');\n }",
"score": 18.315292685191782
}
] | typescript | fileChanges: GitFileChange[],
): Promise<GitFileChange[]> { |
/**
See [Enums considered harmful](https://www.youtube.com/watch?v=jjMbPt_H3RQ) for the motivation
behind this custom type. (Also worth noting is that in TypeScript 5.0 [all Enums are considered
unions](https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#all-enums-are-union-enums).)
Similar to [variants](variants.md) for disciminated unions, `enumOf` allows you to more easily
and safely create and work with enums in TypeScript.
## Basic Example
```ts
export const MyEnum = enumOf(
{
Dog = "Dog",
Cat = "Cat",
ZEBRA = 1234,
} as const, // the `as const` won't be required in TypeScript 5.0
"MyEnum" // friendly name is optional; used to generate helpful parser errors
)
export type MyEnum = EnumOf<typeof MyEnum> // => "Dog" | "Cat" | 1234
```
## Methods
### Standard enum-style accessors
```ts
const dog = MyEnum.Dog // => "Dog"
const zebra = MyEnum.ZEBRA // => 1234
```
### Values
Access array of all valid values, correctly typed (but without any ordering guarantees).
```ts
const myEnumValues = MyEnum.values // => ["Dog", "Cat", 1234]
```
### Parser
Get a safe parser function for this enum automagically!
```ts
const parsed = MyEnum.parse("cat") // => a `Result<MyEnum, string>`, in this case `Result.ok("Cat")`
```
### Match
See `match` in the {@link Variants} module docs for more details on matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.match({
Dog: "woof woof",
Cat: () => "meow",
ZEBRA: "is my skin white with black stripes or black with white stripes??",
})
speak(myEnum)
```
### MatchOrElse
See `matchOrElse` in the {@link Variants} module docs for more details on partial matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.matchOrElse({
Dog: "woof woof",
Cat: () => "meow",
orELse: "I cannot speak.",
})
speak(myEnum)
```
@module Enums
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
import { Result } from "./Result"
import { String } from "./string"
import { Option } from "./Option"
import { pipe, flow } from "./Composition"
import { Array } from "./Array"
import { Identity, NonNullish } from "./prelude"
/** @ignore */
type StringKeys<T extends object> = Extract<keyof T, string>
/**
* A plain object that serves as the definition of the enum type.
* Until TypeScript 5.0 is released, you need to specify `as const`
* on this object definition.
*/
type RawEnum = Record<string, string | number>
/** @ignore */
type StringKeyValues<T extends RawEnum> = Identity<T[StringKeys<T>]>
/** @ignore */
type EnumMatcher<A, R extends RawEnum> = {
readonly [Label in StringKeys<R>]: (() => A) | A
}
/** @ignore */
type PartialEnumMatcher<A, R extends RawEnum> = Partial<EnumMatcher<A, R>> & {
readonly orElse: (() => A) | A
}
type EnumMatch<R extends RawEnum> = <A>(
matcher: EnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
type EnumMatchOrElse<R extends RawEnum> = <A>(
matcher: PartialEnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
/**
* The output of the {@link enumOf} function. Produces an object that serves both as
* the enum as well as a namespace for helper functions related to that enum.
*/
type EnumModule<R extends RawEnum> = Identity<
{
readonly [Label in StringKeys<R>]: R[Label]
} & {
/**
* Returns a readonly array containing the set of all possible enum values. No
* guarantees are made regarding the order of items in the resultant array.
*/
readonly values: ReadonlyArray<StringKeyValues<R>>
/**
* For string enum values, the parse function will trim and coerce values to lowercase
* before comparison. (This has no effect on numeric enum values.) Thus, if an
* enum is defined as `'Yes' | 'No'`, this decoder will parse `'yes'`, `' yES'`,
* and `' YES '` correctly into the canonical `'Yes'` enum value.
*/
readonly parse: (u: unknown) => Result<StringKeyValues<R>, string>
/**
* Use this function for an exhaustive case check that doesn't require using
* a switch/case block or any kind of assertExhaustive check.
*/
readonly match: EnumMatch<R>
/**
* Use this function for a partial case check that doesn't require using
* a switch/case block.
*/
readonly matchOrElse: EnumMatchOrElse<R>
}
>
/**
* Gets the union type representing all possible enum values.
*/
export type EnumOf<T> = T extends EnumModule<infer R>
? StringKeyValues<R>
: [never, "Error: T must be an EnumModule"]
const getParserErrorMessage = <T extends RawEnum>(
enumValues: EnumModule<T>["values"],
enumFriendlyName: string
) => `Must be an enum value in the set ${enumFriendlyName}{ ${enumValues.join(", ")} }`
const toTrimmedLowerCase = (a: string | number) =>
pipe(
Option.some(a),
Option.refine(String.isString),
Option.map(flow(String.trim, String.toLowerCase)),
Option.defaultValue(a)
)
const isStringOrNumber = (u: NonNullish): u is string | number =>
typeof u === "string" || typeof u === "number"
const getParseFn =
<R extends RawEnum>(enumValues: EnumModule<R>["values"], enumFriendlyName: string) =>
(u: unknown): Result<StringKeyValues<R>, string> =>
pipe(
Option.ofNullish(u),
Result.ofOption(
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} cannot be null/undefined`
),
Result.refine(
isStringOrNumber,
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} must be a string or number`
),
Result.map(toTrimmedLowerCase),
Result.bind(testVal =>
pipe(
enumValues,
Array.find | (val => toTrimmedLowerCase(val) === testVal),
Option.match({ |
some: a => Result.ok(a),
none: () =>
Result.err(
getParserErrorMessage(enumValues, enumFriendlyName)
),
})
)
)
)
const isFunc = (f: unknown): f is (...args: any[]) => any => typeof f === "function"
const getMatchFn =
<R extends RawEnum>(raw: R): EnumMatch<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (!Object.hasOwn(matcher, enumLabel)) {
throw new TypeError(
`Expected a matcher containing a case for '${enumLabel}'.`
)
}
const matcherBranch = matcher[enumLabel]
return isFunc(matcherBranch) ? matcherBranch() : matcherBranch
}
const getMatchOrElseFn =
<R extends RawEnum>(raw: R): EnumMatchOrElse<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (Object.hasOwn(matcher, enumLabel)) {
const branch = matcher[enumLabel]
// eslint-disable-next-line @typescript-eslint/no-unsafe-return
return isFunc(branch) ? branch() : branch
}
return isFunc(matcher.orElse) ? matcher.orElse() : matcher.orElse
}
/**
* Generates an "enum module" from a raw object. For motivation behind using a custom
* generative function instead of the built-in `enum` types, see [this video](https://youtu.be/jjMbPt_H3RQ).
*
* This function augments a raw "enum object" with several useful capabilities: `values`, `parse`, `match`,
* and `matchOrElse`.
* - `values` contains the list of valid enum values
* - `parse` is a parser funciton auto-magically created for this enum
* - `match` is a pipeable function that allows exhaustive pattern matching
* - `matchOrElse` is a pipeable function that allows inexhaustive pattern matching
*
* @remarks
* You can use the `parse` function together with `io-ts` to easily create a decoder for this enum.
*
* @example
* ```ts
* export const MyEnum = enumOf({
* Dog = 'Dog',
* Cat = 'Cat',
* ZEBRA = 1234,
* } as const, 'MyEnum') // => friendly name optional; used to generate helpful decoder errors
* export type MyEnum = EnumOf<typeof MyEnum>; //=> 'Dog' | 'Cat' | 1234
*
* // Standard enum-style accessors
* const dog = MyEnum.Dog; // => 'Dog'
* const zebra = MyEnum.ZEBRA; // => 1234
*
* // Access array of all valid values, correctly typed
* const myEnumValues = MyEnum.values; // => ['Dog', 'Cat', 1234]
*
* // Get a decoder instance for this enum automagically
* const myDecoder = MyEnum.decoder; // => a `D.Decoder<unknown, 'Dog' | 'Cat' | 1234>`
*
* // Match an enum value against all its cases (compiler ensures exhaustiveness)
* const value: MyEnum = 'Cat';
* const matchResult = pipe(
* value,
* MyEnum.match({
* Dog: 'woof woof',
* Cat: () => 'meow',
* ZEBRA: 'is my skin white with black stripes or black with white stripes??'
* })
* ) // => 'meow'
* ```
*/
export const enumOf = <T extends RawEnum>(
raw: T,
enumFriendlyName = ""
): EnumModule<T> => {
const entriesWithStringKeys = Object.entries(raw).reduce(
(acc, [label, value]) => ({
...acc,
[label]: value,
}),
{}
)
const values = Object.values(raw)
return {
...entriesWithStringKeys,
values,
parse: getParseFn(values, enumFriendlyName),
match: getMatchFn(raw),
matchOrElse: getMatchOrElseFn(raw),
} as unknown as EnumModule<T>
}
| src/Enums.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Array.ts",
"retrieved_chunk": " * @example\n * pipe(\n * [32, null, 55, undefined, 89], // (number | null | undefined)[]\n * Array.chooseR(x => pipe(\n * x, // number | null | undefined\n * Option.ofNullish, // Option<number>\n * Option.map(String), // Option<string>\n * Result.ofOption(() => \"err\") // Result<string, string>\n * )) // string[]\n * ) // => [\"32\", \"55\", \"89\"]",
"score": 22.29755769268663
},
{
"filename": "src/Array.ts",
"retrieved_chunk": " * @example\n * pipe(\n * [32, null, 55, undefined, 89], // (number | null | undefined)[]\n * Array.choose(x => pipe(\n * x, // number | null | undefined\n * Option.ofNullish, // Option<number>\n * Option.map(String) // Option<string>\n * )) // string[]\n * ) // => [\"32\", \"55\", \"89\"]\n */",
"score": 17.201516116921255
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * value. Pass a matcher function with cases for `ok` and `err` that\n * can either be lambdas or raw values.\n *\n * @group Pattern Matching\n *\n * @example\n * ```\n * pipe(\n * Result.err(\"failure\"),\n * Result.match({",
"score": 15.217992748603344
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * @group Mapping\n *\n * @example\n * pipe(\n * Result.ok(\"a\"),\n * Result.bind(s =>\n * s === \"a\" ? Result.ok(\"got an a!\") : Result.err(\"not an a\")\n * ),\n * Result.defaultValue(\"\")\n * ) // => \"got an a!\"",
"score": 14.517045940775231
},
{
"filename": "src/AsyncResult.ts",
"retrieved_chunk": " * await pipe(\n * AsyncResult.tryCatch(() => doHttpThing(\"/cats\")), // AsyncResult<number, Error>\n * AsyncResult.mapErr(e => e.message), // AsyncResult<number, string>\n * Async.start // Promise<Result<number, string>>\n * )\n * // yields `Result.ok(number)` if the call succeeded\n * // otherwise yields `Result.err(string)`\n * ```\n */\nexport function tryCatch<A>(mightThrow: Async<A>): AsyncResult<A, Error>",
"score": 14.152917074242527
}
] | typescript | (val => toTrimmedLowerCase(val) === testVal),
Option.match({ |
/**
See [Enums considered harmful](https://www.youtube.com/watch?v=jjMbPt_H3RQ) for the motivation
behind this custom type. (Also worth noting is that in TypeScript 5.0 [all Enums are considered
unions](https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#all-enums-are-union-enums).)
Similar to [variants](variants.md) for disciminated unions, `enumOf` allows you to more easily
and safely create and work with enums in TypeScript.
## Basic Example
```ts
export const MyEnum = enumOf(
{
Dog = "Dog",
Cat = "Cat",
ZEBRA = 1234,
} as const, // the `as const` won't be required in TypeScript 5.0
"MyEnum" // friendly name is optional; used to generate helpful parser errors
)
export type MyEnum = EnumOf<typeof MyEnum> // => "Dog" | "Cat" | 1234
```
## Methods
### Standard enum-style accessors
```ts
const dog = MyEnum.Dog // => "Dog"
const zebra = MyEnum.ZEBRA // => 1234
```
### Values
Access array of all valid values, correctly typed (but without any ordering guarantees).
```ts
const myEnumValues = MyEnum.values // => ["Dog", "Cat", 1234]
```
### Parser
Get a safe parser function for this enum automagically!
```ts
const parsed = MyEnum.parse("cat") // => a `Result<MyEnum, string>`, in this case `Result.ok("Cat")`
```
### Match
See `match` in the {@link Variants} module docs for more details on matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.match({
Dog: "woof woof",
Cat: () => "meow",
ZEBRA: "is my skin white with black stripes or black with white stripes??",
})
speak(myEnum)
```
### MatchOrElse
See `matchOrElse` in the {@link Variants} module docs for more details on partial matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.matchOrElse({
Dog: "woof woof",
Cat: () => "meow",
orELse: "I cannot speak.",
})
speak(myEnum)
```
@module Enums
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
import { Result } from "./Result"
import { String } from "./string"
import { Option } from "./Option"
import { pipe, flow } from "./Composition"
import { Array } from "./Array"
import { Identity, NonNullish } from "./prelude"
/** @ignore */
type StringKeys<T extends object> = Extract<keyof T, string>
/**
* A plain object that serves as the definition of the enum type.
* Until TypeScript 5.0 is released, you need to specify `as const`
* on this object definition.
*/
type RawEnum = Record<string, string | number>
/** @ignore */
type StringKeyValues< | T extends RawEnum> = Identity<T[StringKeys<T>]>
/** @ignore */
type EnumMatcher<A, R extends RawEnum> = { |
readonly [Label in StringKeys<R>]: (() => A) | A
}
/** @ignore */
type PartialEnumMatcher<A, R extends RawEnum> = Partial<EnumMatcher<A, R>> & {
readonly orElse: (() => A) | A
}
type EnumMatch<R extends RawEnum> = <A>(
matcher: EnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
type EnumMatchOrElse<R extends RawEnum> = <A>(
matcher: PartialEnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
/**
* The output of the {@link enumOf} function. Produces an object that serves both as
* the enum as well as a namespace for helper functions related to that enum.
*/
type EnumModule<R extends RawEnum> = Identity<
{
readonly [Label in StringKeys<R>]: R[Label]
} & {
/**
* Returns a readonly array containing the set of all possible enum values. No
* guarantees are made regarding the order of items in the resultant array.
*/
readonly values: ReadonlyArray<StringKeyValues<R>>
/**
* For string enum values, the parse function will trim and coerce values to lowercase
* before comparison. (This has no effect on numeric enum values.) Thus, if an
* enum is defined as `'Yes' | 'No'`, this decoder will parse `'yes'`, `' yES'`,
* and `' YES '` correctly into the canonical `'Yes'` enum value.
*/
readonly parse: (u: unknown) => Result<StringKeyValues<R>, string>
/**
* Use this function for an exhaustive case check that doesn't require using
* a switch/case block or any kind of assertExhaustive check.
*/
readonly match: EnumMatch<R>
/**
* Use this function for a partial case check that doesn't require using
* a switch/case block.
*/
readonly matchOrElse: EnumMatchOrElse<R>
}
>
/**
* Gets the union type representing all possible enum values.
*/
export type EnumOf<T> = T extends EnumModule<infer R>
? StringKeyValues<R>
: [never, "Error: T must be an EnumModule"]
const getParserErrorMessage = <T extends RawEnum>(
enumValues: EnumModule<T>["values"],
enumFriendlyName: string
) => `Must be an enum value in the set ${enumFriendlyName}{ ${enumValues.join(", ")} }`
const toTrimmedLowerCase = (a: string | number) =>
pipe(
Option.some(a),
Option.refine(String.isString),
Option.map(flow(String.trim, String.toLowerCase)),
Option.defaultValue(a)
)
const isStringOrNumber = (u: NonNullish): u is string | number =>
typeof u === "string" || typeof u === "number"
const getParseFn =
<R extends RawEnum>(enumValues: EnumModule<R>["values"], enumFriendlyName: string) =>
(u: unknown): Result<StringKeyValues<R>, string> =>
pipe(
Option.ofNullish(u),
Result.ofOption(
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} cannot be null/undefined`
),
Result.refine(
isStringOrNumber,
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} must be a string or number`
),
Result.map(toTrimmedLowerCase),
Result.bind(testVal =>
pipe(
enumValues,
Array.find(val => toTrimmedLowerCase(val) === testVal),
Option.match({
some: a => Result.ok(a),
none: () =>
Result.err(
getParserErrorMessage(enumValues, enumFriendlyName)
),
})
)
)
)
const isFunc = (f: unknown): f is (...args: any[]) => any => typeof f === "function"
const getMatchFn =
<R extends RawEnum>(raw: R): EnumMatch<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (!Object.hasOwn(matcher, enumLabel)) {
throw new TypeError(
`Expected a matcher containing a case for '${enumLabel}'.`
)
}
const matcherBranch = matcher[enumLabel]
return isFunc(matcherBranch) ? matcherBranch() : matcherBranch
}
const getMatchOrElseFn =
<R extends RawEnum>(raw: R): EnumMatchOrElse<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (Object.hasOwn(matcher, enumLabel)) {
const branch = matcher[enumLabel]
// eslint-disable-next-line @typescript-eslint/no-unsafe-return
return isFunc(branch) ? branch() : branch
}
return isFunc(matcher.orElse) ? matcher.orElse() : matcher.orElse
}
/**
* Generates an "enum module" from a raw object. For motivation behind using a custom
* generative function instead of the built-in `enum` types, see [this video](https://youtu.be/jjMbPt_H3RQ).
*
* This function augments a raw "enum object" with several useful capabilities: `values`, `parse`, `match`,
* and `matchOrElse`.
* - `values` contains the list of valid enum values
* - `parse` is a parser funciton auto-magically created for this enum
* - `match` is a pipeable function that allows exhaustive pattern matching
* - `matchOrElse` is a pipeable function that allows inexhaustive pattern matching
*
* @remarks
* You can use the `parse` function together with `io-ts` to easily create a decoder for this enum.
*
* @example
* ```ts
* export const MyEnum = enumOf({
* Dog = 'Dog',
* Cat = 'Cat',
* ZEBRA = 1234,
* } as const, 'MyEnum') // => friendly name optional; used to generate helpful decoder errors
* export type MyEnum = EnumOf<typeof MyEnum>; //=> 'Dog' | 'Cat' | 1234
*
* // Standard enum-style accessors
* const dog = MyEnum.Dog; // => 'Dog'
* const zebra = MyEnum.ZEBRA; // => 1234
*
* // Access array of all valid values, correctly typed
* const myEnumValues = MyEnum.values; // => ['Dog', 'Cat', 1234]
*
* // Get a decoder instance for this enum automagically
* const myDecoder = MyEnum.decoder; // => a `D.Decoder<unknown, 'Dog' | 'Cat' | 1234>`
*
* // Match an enum value against all its cases (compiler ensures exhaustiveness)
* const value: MyEnum = 'Cat';
* const matchResult = pipe(
* value,
* MyEnum.match({
* Dog: 'woof woof',
* Cat: () => 'meow',
* ZEBRA: 'is my skin white with black stripes or black with white stripes??'
* })
* ) // => 'meow'
* ```
*/
export const enumOf = <T extends RawEnum>(
raw: T,
enumFriendlyName = ""
): EnumModule<T> => {
const entriesWithStringKeys = Object.entries(raw).reduce(
(acc, [label, value]) => ({
...acc,
[label]: value,
}),
{}
)
const values = Object.values(raw)
return {
...entriesWithStringKeys,
values,
parse: getParseFn(values, enumFriendlyName),
match: getMatchFn(raw),
matchOrElse: getMatchOrElseFn(raw),
} as unknown as EnumModule<T>
}
| src/Enums.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/prelude.ts",
"retrieved_chunk": "/* c8 ignore end */\n/**\n * Internal utility type to get slight improvements in\n * intellisense for complex TypeScript object types.\n *\n * @ignore\n */\nexport type Identity<T> = T extends object\n ? NonNullish & {\n [P in keyof T]: T[P]",
"score": 54.422922756374966
},
{
"filename": "src/prelude.ts",
"retrieved_chunk": " }\n : T\n/**\n * Internal utility type for discriminated unions.\n *\n * @ignore\n */\nexport type Tagged<Tag extends string, A extends object> = Identity<\n Readonly<\n {",
"score": 52.217252927454176
},
{
"filename": "src/Variants.ts",
"retrieved_chunk": "type EmptyObjGuard<T> = T extends ObjectGuard<infer O>\n ? object extends O\n ? O\n : never\n : never\ntype Scoped<T extends string, Scope extends string = \"\"> = Scope extends \"\"\n ? T\n : `${Scope}${T}`\ntype ObjectGuard<T extends object> = Exclude<T, any[] | Func>\ntype NonEmptyStringKeys<T> = Exclude<Extract<keyof T, string>, \"\">",
"score": 50.73505320237626
},
{
"filename": "src/Variants.ts",
"retrieved_chunk": " Scope extends string = DefaultScope\n> = ObjectGuard<CaseReturnType<T>> extends never\n ? [never, \"Only objects are allowed as variant data. Wrap variant data in an object.\"]\n : T extends Func\n ? VariantConstructor<Parameters<T>, Case, CaseReturnType<T>, Discriminant, Scope>\n : Variant<Case, CaseReturnType<T>, Discriminant, Scope>\ntype VariantConstructors<\n Input extends VariantInputObject = Record<string, never>,\n Discriminant extends string = DefaultDiscriminant,\n Scope extends string = DefaultScope",
"score": 44.69836750631647
},
{
"filename": "src/Variants.ts",
"retrieved_chunk": "/********************\n * Foundational Types\n *********************/\ntype VariantInputObject = Record<string, Func | object>\ntype Variant<\n Case extends string,\n Data extends object = object,\n Discriminant extends string = DefaultDiscriminant,\n Scope extends string = DefaultScope\n> = Identity<",
"score": 43.94213058231147
}
] | typescript | T extends RawEnum> = Identity<T[StringKeys<T>]>
/** @ignore */
type EnumMatcher<A, R extends RawEnum> = { |
/**
See [Enums considered harmful](https://www.youtube.com/watch?v=jjMbPt_H3RQ) for the motivation
behind this custom type. (Also worth noting is that in TypeScript 5.0 [all Enums are considered
unions](https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#all-enums-are-union-enums).)
Similar to [variants](variants.md) for disciminated unions, `enumOf` allows you to more easily
and safely create and work with enums in TypeScript.
## Basic Example
```ts
export const MyEnum = enumOf(
{
Dog = "Dog",
Cat = "Cat",
ZEBRA = 1234,
} as const, // the `as const` won't be required in TypeScript 5.0
"MyEnum" // friendly name is optional; used to generate helpful parser errors
)
export type MyEnum = EnumOf<typeof MyEnum> // => "Dog" | "Cat" | 1234
```
## Methods
### Standard enum-style accessors
```ts
const dog = MyEnum.Dog // => "Dog"
const zebra = MyEnum.ZEBRA // => 1234
```
### Values
Access array of all valid values, correctly typed (but without any ordering guarantees).
```ts
const myEnumValues = MyEnum.values // => ["Dog", "Cat", 1234]
```
### Parser
Get a safe parser function for this enum automagically!
```ts
const parsed = MyEnum.parse("cat") // => a `Result<MyEnum, string>`, in this case `Result.ok("Cat")`
```
### Match
See `match` in the {@link Variants} module docs for more details on matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.match({
Dog: "woof woof",
Cat: () => "meow",
ZEBRA: "is my skin white with black stripes or black with white stripes??",
})
speak(myEnum)
```
### MatchOrElse
See `matchOrElse` in the {@link Variants} module docs for more details on partial matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.matchOrElse({
Dog: "woof woof",
Cat: () => "meow",
orELse: "I cannot speak.",
})
speak(myEnum)
```
@module Enums
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
import { Result } from "./Result"
import { String } from "./string"
import { Option } from "./Option"
import { pipe, flow } from "./Composition"
import { Array } from "./Array"
import { Identity, NonNullish } from "./prelude"
/** @ignore */
type StringKeys<T extends object> = Extract<keyof T, string>
/**
* A plain object that serves as the definition of the enum type.
* Until TypeScript 5.0 is released, you need to specify `as const`
* on this object definition.
*/
type RawEnum = Record<string, string | number>
/** @ignore */
type StringKeyValues<T extends RawEnum> = Identity<T[StringKeys<T>]>
/** @ignore */
type EnumMatcher<A, R extends RawEnum> = {
readonly [Label in StringKeys<R>]: (() => A) | A
}
/** @ignore */
type PartialEnumMatcher<A, R extends RawEnum> = Partial<EnumMatcher<A, R>> & {
readonly orElse: (() => A) | A
}
type EnumMatch<R extends RawEnum> = <A>(
matcher: EnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
type EnumMatchOrElse<R extends RawEnum> = <A>(
matcher: PartialEnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
/**
* The output of the {@link enumOf} function. Produces an object that serves both as
* the enum as well as a namespace for helper functions related to that enum.
*/
type EnumModule<R extends RawEnum> = Identity<
{
readonly [Label in StringKeys<R>]: R[Label]
} & {
/**
* Returns a readonly array containing the set of all possible enum values. No
* guarantees are made regarding the order of items in the resultant array.
*/
readonly values: ReadonlyArray<StringKeyValues<R>>
/**
* For string enum values, the parse function will trim and coerce values to lowercase
* before comparison. (This has no effect on numeric enum values.) Thus, if an
* enum is defined as `'Yes' | 'No'`, this decoder will parse `'yes'`, `' yES'`,
* and `' YES '` correctly into the canonical `'Yes'` enum value.
*/
readonly parse: (u: unknown) => Result<StringKeyValues<R>, string>
/**
* Use this function for an exhaustive case check that doesn't require using
* a switch/case block or any kind of assertExhaustive check.
*/
readonly match: EnumMatch<R>
/**
* Use this function for a partial case check that doesn't require using
* a switch/case block.
*/
readonly matchOrElse: EnumMatchOrElse<R>
}
>
/**
* Gets the union type representing all possible enum values.
*/
export type EnumOf<T> = T extends EnumModule<infer R>
? StringKeyValues<R>
: [never, "Error: T must be an EnumModule"]
const getParserErrorMessage = <T extends RawEnum>(
enumValues: EnumModule<T>["values"],
enumFriendlyName: string
) => `Must be an enum value in the set ${enumFriendlyName}{ ${enumValues.join(", ")} }`
const toTrimmedLowerCase = (a: string | number) =>
pipe(
Option.some(a),
Option.refine(String.isString),
Option.map(flow(String.trim, String.toLowerCase)),
Option.defaultValue(a)
)
const isStringOrNumber = (u: NonNullish): u is string | number =>
typeof u === "string" || typeof u === "number"
const getParseFn =
<R extends RawEnum>(enumValues: EnumModule<R>["values"], enumFriendlyName: string) =>
(u: unknown): Result<StringKeyValues<R>, string> =>
pipe(
Option.ofNullish(u),
Result.ofOption(
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} cannot be null/undefined`
),
Result.refine(
isStringOrNumber,
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} must be a string or number`
),
Result.map(toTrimmedLowerCase),
| Result.bind(testVal =>
pipe(
enumValues,
Array.find(val => toTrimmedLowerCase(val) === testVal),
Option.match({ |
some: a => Result.ok(a),
none: () =>
Result.err(
getParserErrorMessage(enumValues, enumFriendlyName)
),
})
)
)
)
const isFunc = (f: unknown): f is (...args: any[]) => any => typeof f === "function"
const getMatchFn =
<R extends RawEnum>(raw: R): EnumMatch<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (!Object.hasOwn(matcher, enumLabel)) {
throw new TypeError(
`Expected a matcher containing a case for '${enumLabel}'.`
)
}
const matcherBranch = matcher[enumLabel]
return isFunc(matcherBranch) ? matcherBranch() : matcherBranch
}
const getMatchOrElseFn =
<R extends RawEnum>(raw: R): EnumMatchOrElse<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (Object.hasOwn(matcher, enumLabel)) {
const branch = matcher[enumLabel]
// eslint-disable-next-line @typescript-eslint/no-unsafe-return
return isFunc(branch) ? branch() : branch
}
return isFunc(matcher.orElse) ? matcher.orElse() : matcher.orElse
}
/**
* Generates an "enum module" from a raw object. For motivation behind using a custom
* generative function instead of the built-in `enum` types, see [this video](https://youtu.be/jjMbPt_H3RQ).
*
* This function augments a raw "enum object" with several useful capabilities: `values`, `parse`, `match`,
* and `matchOrElse`.
* - `values` contains the list of valid enum values
* - `parse` is a parser funciton auto-magically created for this enum
* - `match` is a pipeable function that allows exhaustive pattern matching
* - `matchOrElse` is a pipeable function that allows inexhaustive pattern matching
*
* @remarks
* You can use the `parse` function together with `io-ts` to easily create a decoder for this enum.
*
* @example
* ```ts
* export const MyEnum = enumOf({
* Dog = 'Dog',
* Cat = 'Cat',
* ZEBRA = 1234,
* } as const, 'MyEnum') // => friendly name optional; used to generate helpful decoder errors
* export type MyEnum = EnumOf<typeof MyEnum>; //=> 'Dog' | 'Cat' | 1234
*
* // Standard enum-style accessors
* const dog = MyEnum.Dog; // => 'Dog'
* const zebra = MyEnum.ZEBRA; // => 1234
*
* // Access array of all valid values, correctly typed
* const myEnumValues = MyEnum.values; // => ['Dog', 'Cat', 1234]
*
* // Get a decoder instance for this enum automagically
* const myDecoder = MyEnum.decoder; // => a `D.Decoder<unknown, 'Dog' | 'Cat' | 1234>`
*
* // Match an enum value against all its cases (compiler ensures exhaustiveness)
* const value: MyEnum = 'Cat';
* const matchResult = pipe(
* value,
* MyEnum.match({
* Dog: 'woof woof',
* Cat: () => 'meow',
* ZEBRA: 'is my skin white with black stripes or black with white stripes??'
* })
* ) // => 'meow'
* ```
*/
export const enumOf = <T extends RawEnum>(
raw: T,
enumFriendlyName = ""
): EnumModule<T> => {
const entriesWithStringKeys = Object.entries(raw).reduce(
(acc, [label, value]) => ({
...acc,
[label]: value,
}),
{}
)
const values = Object.values(raw)
return {
...entriesWithStringKeys,
values,
parse: getParseFn(values, enumFriendlyName),
match: getMatchFn(raw),
matchOrElse: getMatchOrElseFn(raw),
} as unknown as EnumModule<T>
}
| src/Enums.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Array.ts",
"retrieved_chunk": " * @example\n * pipe(\n * [32, null, 55, undefined, 89], // (number | null | undefined)[]\n * Array.chooseR(x => pipe(\n * x, // number | null | undefined\n * Option.ofNullish, // Option<number>\n * Option.map(String), // Option<string>\n * Result.ofOption(() => \"err\") // Result<string, string>\n * )) // string[]\n * ) // => [\"32\", \"55\", \"89\"]",
"score": 22.29755769268663
},
{
"filename": "src/Array.ts",
"retrieved_chunk": " * @example\n * pipe(\n * [32, null, 55, undefined, 89], // (number | null | undefined)[]\n * Array.choose(x => pipe(\n * x, // number | null | undefined\n * Option.ofNullish, // Option<number>\n * Option.map(String) // Option<string>\n * )) // string[]\n * ) // => [\"32\", \"55\", \"89\"]\n */",
"score": 17.201516116921255
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * value. Pass a matcher function with cases for `ok` and `err` that\n * can either be lambdas or raw values.\n *\n * @group Pattern Matching\n *\n * @example\n * ```\n * pipe(\n * Result.err(\"failure\"),\n * Result.match({",
"score": 15.217992748603344
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * @group Mapping\n *\n * @example\n * pipe(\n * Result.ok(\"a\"),\n * Result.bind(s =>\n * s === \"a\" ? Result.ok(\"got an a!\") : Result.err(\"not an a\")\n * ),\n * Result.defaultValue(\"\")\n * ) // => \"got an a!\"",
"score": 14.517045940775231
},
{
"filename": "src/AsyncResult.ts",
"retrieved_chunk": " * await pipe(\n * AsyncResult.tryCatch(() => doHttpThing(\"/cats\")), // AsyncResult<number, Error>\n * AsyncResult.mapErr(e => e.message), // AsyncResult<number, string>\n * Async.start // Promise<Result<number, string>>\n * )\n * // yields `Result.ok(number)` if the call succeeded\n * // otherwise yields `Result.err(string)`\n * ```\n */\nexport function tryCatch<A>(mightThrow: Async<A>): AsyncResult<A, Error>",
"score": 14.152917074242527
}
] | typescript | Result.bind(testVal =>
pipe(
enumValues,
Array.find(val => toTrimmedLowerCase(val) === testVal),
Option.match({ |
/**
See [Enums considered harmful](https://www.youtube.com/watch?v=jjMbPt_H3RQ) for the motivation
behind this custom type. (Also worth noting is that in TypeScript 5.0 [all Enums are considered
unions](https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#all-enums-are-union-enums).)
Similar to [variants](variants.md) for disciminated unions, `enumOf` allows you to more easily
and safely create and work with enums in TypeScript.
## Basic Example
```ts
export const MyEnum = enumOf(
{
Dog = "Dog",
Cat = "Cat",
ZEBRA = 1234,
} as const, // the `as const` won't be required in TypeScript 5.0
"MyEnum" // friendly name is optional; used to generate helpful parser errors
)
export type MyEnum = EnumOf<typeof MyEnum> // => "Dog" | "Cat" | 1234
```
## Methods
### Standard enum-style accessors
```ts
const dog = MyEnum.Dog // => "Dog"
const zebra = MyEnum.ZEBRA // => 1234
```
### Values
Access array of all valid values, correctly typed (but without any ordering guarantees).
```ts
const myEnumValues = MyEnum.values // => ["Dog", "Cat", 1234]
```
### Parser
Get a safe parser function for this enum automagically!
```ts
const parsed = MyEnum.parse("cat") // => a `Result<MyEnum, string>`, in this case `Result.ok("Cat")`
```
### Match
See `match` in the {@link Variants} module docs for more details on matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.match({
Dog: "woof woof",
Cat: () => "meow",
ZEBRA: "is my skin white with black stripes or black with white stripes??",
})
speak(myEnum)
```
### MatchOrElse
See `matchOrElse` in the {@link Variants} module docs for more details on partial matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.matchOrElse({
Dog: "woof woof",
Cat: () => "meow",
orELse: "I cannot speak.",
})
speak(myEnum)
```
@module Enums
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
import { Result } from "./Result"
import { String } from "./string"
import { Option } from "./Option"
import { pipe, flow } from "./Composition"
import { Array } from "./Array"
import { Identity, NonNullish } from "./prelude"
/** @ignore */
type StringKeys<T extends object> = Extract<keyof T, string>
/**
* A plain object that serves as the definition of the enum type.
* Until TypeScript 5.0 is released, you need to specify `as const`
* on this object definition.
*/
type RawEnum = Record<string, string | number>
/** @ignore */
type StringKeyValues<T extends RawEnum> = Identity<T[StringKeys<T>]>
/** @ignore */
type EnumMatcher<A, R extends RawEnum> = {
readonly [Label in StringKeys<R>]: (() => A) | A
}
/** @ignore */
type PartialEnumMatcher<A, R extends RawEnum> = Partial<EnumMatcher<A, R>> & {
readonly orElse: (() => A) | A
}
type EnumMatch<R extends RawEnum> = <A>(
matcher: EnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
type EnumMatchOrElse<R extends RawEnum> = <A>(
matcher: PartialEnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
/**
* The output of the {@link enumOf} function. Produces an object that serves both as
* the enum as well as a namespace for helper functions related to that enum.
*/
type EnumModule<R extends RawEnum> = Identity<
{
readonly [Label in StringKeys<R>]: R[Label]
} & {
/**
* Returns a readonly array containing the set of all possible enum values. No
* guarantees are made regarding the order of items in the resultant array.
*/
readonly values: ReadonlyArray<StringKeyValues<R>>
/**
* For string enum values, the parse function will trim and coerce values to lowercase
* before comparison. (This has no effect on numeric enum values.) Thus, if an
* enum is defined as `'Yes' | 'No'`, this decoder will parse `'yes'`, `' yES'`,
* and `' YES '` correctly into the canonical `'Yes'` enum value.
*/
readonly parse: (u: unknown) => Result<StringKeyValues<R>, string>
/**
* Use this function for an exhaustive case check that doesn't require using
* a switch/case block or any kind of assertExhaustive check.
*/
readonly match: EnumMatch<R>
/**
* Use this function for a partial case check that doesn't require using
* a switch/case block.
*/
readonly matchOrElse: EnumMatchOrElse<R>
}
>
/**
* Gets the union type representing all possible enum values.
*/
export type EnumOf<T> = T extends EnumModule<infer R>
? StringKeyValues<R>
: [never, "Error: T must be an EnumModule"]
const getParserErrorMessage = <T extends RawEnum>(
enumValues: EnumModule<T>["values"],
enumFriendlyName: string
) => `Must be an enum value in the set ${enumFriendlyName}{ ${enumValues.join(", ")} }`
const toTrimmedLowerCase = (a: string | number) =>
pipe(
Option.some(a),
Option.refine(String.isString),
Option.map(flow(String.trim, String.toLowerCase)),
Option.defaultValue(a)
)
const isStringOrNumber = (u: NonNullish): u is string | number =>
typeof u === "string" || typeof u === "number"
const getParseFn =
<R extends RawEnum>(enumValues: EnumModule<R>["values"], enumFriendlyName: string) =>
(u: unknown): Result<StringKeyValues<R>, string> =>
pipe(
Option.ofNullish(u),
Result.ofOption(
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} cannot be null/undefined`
),
Result.refine(
isStringOrNumber,
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} must be a string or number`
),
Result.map(toTrimmedLowerCase),
Result.bind(testVal =>
pipe(
enumValues,
Array.find(val => toTrimmedLowerCase(val) === testVal),
| Option.match({ |
some: a => Result.ok(a),
none: () =>
Result.err(
getParserErrorMessage(enumValues, enumFriendlyName)
),
})
)
)
)
const isFunc = (f: unknown): f is (...args: any[]) => any => typeof f === "function"
const getMatchFn =
<R extends RawEnum>(raw: R): EnumMatch<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (!Object.hasOwn(matcher, enumLabel)) {
throw new TypeError(
`Expected a matcher containing a case for '${enumLabel}'.`
)
}
const matcherBranch = matcher[enumLabel]
return isFunc(matcherBranch) ? matcherBranch() : matcherBranch
}
const getMatchOrElseFn =
<R extends RawEnum>(raw: R): EnumMatchOrElse<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (Object.hasOwn(matcher, enumLabel)) {
const branch = matcher[enumLabel]
// eslint-disable-next-line @typescript-eslint/no-unsafe-return
return isFunc(branch) ? branch() : branch
}
return isFunc(matcher.orElse) ? matcher.orElse() : matcher.orElse
}
/**
* Generates an "enum module" from a raw object. For motivation behind using a custom
* generative function instead of the built-in `enum` types, see [this video](https://youtu.be/jjMbPt_H3RQ).
*
* This function augments a raw "enum object" with several useful capabilities: `values`, `parse`, `match`,
* and `matchOrElse`.
* - `values` contains the list of valid enum values
* - `parse` is a parser funciton auto-magically created for this enum
* - `match` is a pipeable function that allows exhaustive pattern matching
* - `matchOrElse` is a pipeable function that allows inexhaustive pattern matching
*
* @remarks
* You can use the `parse` function together with `io-ts` to easily create a decoder for this enum.
*
* @example
* ```ts
* export const MyEnum = enumOf({
* Dog = 'Dog',
* Cat = 'Cat',
* ZEBRA = 1234,
* } as const, 'MyEnum') // => friendly name optional; used to generate helpful decoder errors
* export type MyEnum = EnumOf<typeof MyEnum>; //=> 'Dog' | 'Cat' | 1234
*
* // Standard enum-style accessors
* const dog = MyEnum.Dog; // => 'Dog'
* const zebra = MyEnum.ZEBRA; // => 1234
*
* // Access array of all valid values, correctly typed
* const myEnumValues = MyEnum.values; // => ['Dog', 'Cat', 1234]
*
* // Get a decoder instance for this enum automagically
* const myDecoder = MyEnum.decoder; // => a `D.Decoder<unknown, 'Dog' | 'Cat' | 1234>`
*
* // Match an enum value against all its cases (compiler ensures exhaustiveness)
* const value: MyEnum = 'Cat';
* const matchResult = pipe(
* value,
* MyEnum.match({
* Dog: 'woof woof',
* Cat: () => 'meow',
* ZEBRA: 'is my skin white with black stripes or black with white stripes??'
* })
* ) // => 'meow'
* ```
*/
export const enumOf = <T extends RawEnum>(
raw: T,
enumFriendlyName = ""
): EnumModule<T> => {
const entriesWithStringKeys = Object.entries(raw).reduce(
(acc, [label, value]) => ({
...acc,
[label]: value,
}),
{}
)
const values = Object.values(raw)
return {
...entriesWithStringKeys,
values,
parse: getParseFn(values, enumFriendlyName),
match: getMatchFn(raw),
matchOrElse: getMatchOrElseFn(raw),
} as unknown as EnumModule<T>
}
| src/Enums.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Array.ts",
"retrieved_chunk": " * @example\n * pipe(\n * [32, null, 55, undefined, 89], // (number | null | undefined)[]\n * Array.chooseR(x => pipe(\n * x, // number | null | undefined\n * Option.ofNullish, // Option<number>\n * Option.map(String), // Option<string>\n * Result.ofOption(() => \"err\") // Result<string, string>\n * )) // string[]\n * ) // => [\"32\", \"55\", \"89\"]",
"score": 22.29755769268663
},
{
"filename": "src/Array.ts",
"retrieved_chunk": " * @example\n * pipe(\n * [32, null, 55, undefined, 89], // (number | null | undefined)[]\n * Array.choose(x => pipe(\n * x, // number | null | undefined\n * Option.ofNullish, // Option<number>\n * Option.map(String) // Option<string>\n * )) // string[]\n * ) // => [\"32\", \"55\", \"89\"]\n */",
"score": 17.201516116921255
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * value. Pass a matcher function with cases for `ok` and `err` that\n * can either be lambdas or raw values.\n *\n * @group Pattern Matching\n *\n * @example\n * ```\n * pipe(\n * Result.err(\"failure\"),\n * Result.match({",
"score": 15.217992748603344
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * @group Mapping\n *\n * @example\n * pipe(\n * Result.ok(\"a\"),\n * Result.bind(s =>\n * s === \"a\" ? Result.ok(\"got an a!\") : Result.err(\"not an a\")\n * ),\n * Result.defaultValue(\"\")\n * ) // => \"got an a!\"",
"score": 14.517045940775231
},
{
"filename": "src/AsyncResult.ts",
"retrieved_chunk": " * await pipe(\n * AsyncResult.tryCatch(() => doHttpThing(\"/cats\")), // AsyncResult<number, Error>\n * AsyncResult.mapErr(e => e.message), // AsyncResult<number, string>\n * Async.start // Promise<Result<number, string>>\n * )\n * // yields `Result.ok(number)` if the call succeeded\n * // otherwise yields `Result.err(string)`\n * ```\n */\nexport function tryCatch<A>(mightThrow: Async<A>): AsyncResult<A, Error>",
"score": 14.152917074242527
}
] | typescript | Option.match({ |
/**
* A `NonEmptyArray` is an array that is guaranteed by the type system to have
* at least one element. This type is useful for correctly modeling certain
* behaviors where empty arrays are absurd. It also makes it safer to work with
* functionality like destructuring the array or getting the first value.
*
* **Note:** A `NonEmptyArray` is just a _more specific_ type of readonly array,
* so any functions from the `Array` module can also be used with `NonEmptyArray`s.
*
* @module NonEmptyArray
*/
import { EqualityComparer } from "./EqualityComparer"
import { OrderingComparer } from "./OrderingComparer"
/** Represents a readonly array with at least one element. */
export interface NonEmptyArray<A> extends ReadonlyArray<A> {
0: A
}
/**
* Get the first element of a non-empty array.
*
* @group Utils
* @group Pattern Matching
*/
export const head = <A>(as: NonEmptyArray<A>) => as[0]
/**
* Alias of {@link head}.
*
* @group Pattern Matching
* @group Utils
*/
export const first = head
/**
* Destructure the non-empty array into an object containing
* the head and the tail.
*
* @group Pattern Matching
*
* @example
* NonEmptyArray.destruct([1, 2, 3]) // => { head: 1, tail: [2, 3] }
*/
export const destruct = <A>(
as: NonEmptyArray<A>
): {
readonly head: A
readonly tail: readonly A[]
} => ({
head: as[0],
tail: as.slice(1),
})
/**
* Curried version of the built-in map that maintains
* strong NonEmptyArray typing.
*
* @group Mapping
*
* @returns A new non-empty array containing the mapped elements.
*/
export const map =
<A, B>(f: (a: A) => B) =>
(as: NonEmptyArray<A>): NonEmptyArray<B> =>
as.map(f) as unknown as NonEmptyArray<B>
/**
* Uses the given function to map each element into a non-empty array,
* then flattens the results. Commonly called flatMap` or `chain`.
*
* @group Mapping
*
* @returns A new non-empty array containing the mapped/flattened elements.
*/
export const bind =
<A, B>(f: (a: A) => NonEmptyArray<B>) =>
(as: NonEmptyArray<A>): NonEmptyArray<B> =>
as.flatMap(f) as unknown as NonEmptyArray<B>
/**
* Alias for {@link bind}.
*
* @group Mapping
*/
export const flatMap = bind
/**
* Constructs a new non-empty array containing exactly one element.
*
* @group Constructors
*/
export const of = <A>(a: A): NonEmptyArray<A> => [a]
/**
* Create a new array by enumerating the integers between
* the given start and end, inclusive of both start and end.
*
* Both start and end are normalized to integers, and end is
* normalized to always be at least equal to start.
*
* @group Constructors
* @group Utils
*
* @example
* NonEmptyArray.range(1, 5) // => [1, 2, 3, 4, 5]
* NonEmptyArray.range(-10, 1) // => [-10, -9, -8, ..., 1]
* NonEmptyArray.range(2, -5) // => [2]
* NonEmptyArray.range(1, 1) // => [1]
*/
export const range = (
startInclusive: number,
endInclusive: number
): NonEmptyArray<number> => {
const start = Math.floor(startInclusive)
const end = Math.floor(endInclusive)
if (start >= end) {
return [start]
}
const out: number[] = []
for (let i = start; i <= end; i++) {
out.push(i)
}
return out as unknown as NonEmptyArray<number>
}
/**
* Construct a new non-empty array with the specified number
* of elements, using a constructor function for each element
* that takes a zero-based index of the element being constructed.
*
* @param length is normalized to a non-negative integer
*
* @group Constructors
* @group Utils
*
* @example
* ```
* NonEmptyArray.make(3, i => `${i}`) // => ["0", "1", "2"]
* ```
*/
export const make = <A>(
length: number,
createElement: (i: number) => A
): NonEmptyArray<A> => {
const n = length <= 1 ? 1 : Math.floor(length)
return [...Array(n).keys()].map(createElement) as unknown as NonEmptyArray<A>
}
/**
* Reverses an array. Preserves correct types.
*
* @group Utils
*
* @returns A new non-empty array with elements in reverse order.
*
* @example
* pipe(
* NonEmptyArray.range(1, 5),
* NonEmptyArray.reverse
* ) // => [5, 4, 3, 2, 1]
*/
export const reverse = <A>(as: NonEmptyArray<A>): NonEmptyArray<A> =>
as.slice(0).reverse() as unknown as NonEmptyArray<A>
/**
* Sort the array using the given `OrderingComaparer`, or the default
* ASCII-based comparer if not given.
*
* @group Utils
*
* @returns A new non-emty array with elements sorted.
*/
export const sort =
<A>(orderingComparer: OrderingComparer<A> = OrderingComparer.Default) =>
(as: NonEmptyArray<A>): NonEmptyArray<A> =>
as.slice(0).sort(orderingComparer.compare) as unknown as NonEmptyArray<A>
/**
* Get an `EqualityComparer` that represents structural equality for a non-empty array
* of type `A` by giving this function an `EqualityComparer` for each `A` element.
*
* @group Equality
* @group Utils
*
* @param equalityComparer The `EqualityComparer` to use for element-by-element comparison.
*
* @returns A new `EqualityComparer` instance
*/
export const getEqualityComparer = <A>({
equals,
| }: EqualityComparer<A>): EqualityComparer<NonEmptyArray<A>> =>
EqualityComparer.ofEquals((arr1, arr2) => { |
if (arr1.length !== arr2.length) {
return false
}
for (let i = 0; i < arr1.length; i++) {
if (!equals(arr1[i], arr2[i])) {
return false
}
}
return true
})
/* c8 ignore start */
/** @ignore */
export const NonEmptyArray = {
head,
first,
destruct,
map,
bind,
flatMap,
of,
range,
make,
reverse,
sort,
getEqualityComparer,
}
/* c8 ignore end */
| src/NonEmptyArray.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Array.ts",
"retrieved_chunk": " * of type `A` by giving this function an `EqualityComparer` for each `A` element.\n *\n * @group Equality\n * @group Utils\n *\n * @param equalityComparer The `EqualityComparer` to use for element-by-element comparison.\n *\n * @returns A new `EqualityComparer` instance\n *\n * @example",
"score": 64.57899094088799
},
{
"filename": "src/Array.ts",
"retrieved_chunk": " * const eq = Array.getEqualityComparer(EqualityComparer.Number)\n * eq.equals([1, 2, 3], [1, 2, 3]) // => true\n * eq.equals([1, 3], [3, 1]) // => false\n */\nexport const getEqualityComparer = <A>({\n equals,\n}: EqualityComparer<A>): EqualityComparer<readonly A[]> =>\n EqualityComparer.ofEquals((arr1, arr2) => {\n if (isEmpty(arr1) && isEmpty(arr2)) {\n return true",
"score": 52.61260058605675
},
{
"filename": "src/Result.ts",
"retrieved_chunk": " * @group Utils\n *\n * @param equalityComparerA The `EqualityComparer` to use for the inner ok value.\n * @param equalityComparerE The `EqualityComparer` to use for the inner err value.\n *\n * @returns A new `EqualityComparer` instance\n */\nexport const getEqualityComparer = <A, E>(\n equalityComparerA: EqualityComparer<A>,\n equalityComparerE: EqualityComparer<E>",
"score": 50.64715309492911
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " * Get an `EqualityComparer` for an `Option<A>` by giving this function an\n * `EqualityComparer` for type `A`. Represents structural (value-based) equality\n * for the `Option` type.\n *\n * @group Equality\n * @group Utils\n *\n * @param equalityComparer The `EqualityComparer` to use for the inner value.\n * @returns A new `EqualityComparer` instance\n */",
"score": 46.01954163697603
},
{
"filename": "src/Nullable.ts",
"retrieved_chunk": " * equals(4, 4) // => true\n * equals(4, 5) // => false\n * ```\n */\nexport const getEqualityComparer = <A extends NonNullish>(\n equalityComparer: EqualityComparer<A>\n) =>\n EqualityComparer.ofEquals<Nullable<A>>(\n (a1, a2) =>\n (a1 == null && a2 == null) ||",
"score": 39.12240765159553
}
] | typescript | }: EqualityComparer<A>): EqualityComparer<NonEmptyArray<A>> =>
EqualityComparer.ofEquals((arr1, arr2) => { |
/**
* A suite of useful functions for working with the built-in `Map` type.
*
* @module Map
*/
import { NonNullish, Predicate } from "./prelude"
import { Option } from "./Option"
import { pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
import { OrderingComparer } from "./OrderingComparer"
/**
* Lookup a key/value pair (wrapped in a `Some`) from a `Map` using the given key.
* If the `Map` doesn't contain the key, returns `None`.
*
* Uses the given equality comparer if passed. Otherwise, defaults to reference
* equality (triple equals) for equality comparisons.
*
* @group Lookups
*
* @returns An `Option` containing a tuple of the key and value.
*/
export const findWithKey =
<K>(key: K, { equals }: EqualityComparer<K> = EqualityComparer.Default) =>
<V>(map: ReadonlyMap<K, V>): Option<[K, V]> => {
if (map.size < 1) {
return Option.none
}
for (const [k, v] of map) {
if (equals(k, key)) {
return Option.some([k, v])
}
}
return Option.none
}
/**
* Test whether a `Map` contains the given key. Uses the given `EqualityComparer`
* if passed. Otherwise, defaults to reference equality (triple equals).
*
* @group Lookups
*
* @returns `true` if the key is in the `Map`, `false` otherwise.
*/
export const containsKey =
<K>(key: K, equalityComparer: EqualityComparer<K> = EqualityComparer.Default) =>
<V>(map: ReadonlyMap<K, V>): boolean =>
pipe(map, findWithKey(key, equalityComparer), Option.isSome)
/**
* Get a value associated with the given key from the `Map`. Returns a `Some`
* containing the value, or `None` if the key is not in the `Map`.
*
* Uses the given equality comparer if passed, otherwise defaults to using
* reference equality (triple equals) for equality comparison.
*
* @group Lookups
*/
export const find =
<K>(key: K, equalityComparer: EqualityComparer<K> = EqualityComparer.Default) =>
<V extends NonNullish>(map: ReadonlyMap<K, V>): Option<V> =>
pipe(
map,
findWithKey(key, equalityComparer),
Option.map(([, v]) => v)
)
/**
* Adds a key/value pair to a `Map`. If the given key already exists
* the value at that key will be updated with the given value.
*
* Will use the equality comparer if given, otherwise defaults to using
* reference equality (triple equals) for equality comparisons.
*
* @group Transformations
*
* @returns A new `Map` with the added key/value pair
*/
export const set =
<K, V>(
[key, value]: readonly [K, V],
equalityComparer: EqualityComparer<K> = EqualityComparer.Default
) =>
(map: ReadonlyMap<K, V>): ReadonlyMap<K, V> => {
if (map.size < 1) {
const out = empty<K, V>()
out.set(key, value)
return out
}
const copy = new globalThis.Map(map)
return pipe(
map,
findWithKey(key, equalityComparer),
Option.match({
none: () => {
copy.set(key, value)
return copy
},
| some: ([k]) => { |
copy.set(k, value)
return copy
},
})
)
}
/**
* Make a new `Map` by producing a new each value for each key using
* the given function.
*
* @group Mapping
* @group Transformations
*/
export const map =
<K, V, R>(f: (k: K, v: V) => R) =>
(map: ReadonlyMap<K, V>): ReadonlyMap<K, R> => {
if (map.size < 1) {
return empty<K, R>()
}
const out = empty<K, R>()
for (const [k, v] of map) {
out.set(k, f(k, v))
}
return out
}
/**
* Get the first key for which the given predicate function returns
* true, wrapped in a `Some`. If no key is found, returns `None`. Uses
* the given `OrderingComparer` if passed, otherwise defaults to default
* ASCII-based sort.
*
* @group Lookups
*/
export const findKey =
<K extends NonNullish>(
predicate: Predicate<K>,
orderingComparer: OrderingComparer<K> = OrderingComparer.Default
) =>
<V>(map: ReadonlyMap<K, V>): Option<K> =>
Option.ofNullish(keys(orderingComparer)(map).find(predicate))
/**
* Creates a new empty map. Essentially an alias for `new globalThis.Map()`.
* Provided for convience to avoid having to use `globalThis`.
*
* @group Constructors
*/
export const empty = <K = never, V = never>() => new globalThis.Map<K, V>()
/**
* Returns `true` if at least one _value_ in the `Map` returns `true`
* for the given predicate function.
*
* @group Lookups
* @group Utils
*/
export const exists =
<V>(predicate: Predicate<V>) =>
<K>(map: ReadonlyMap<K, V>): boolean => {
if (map.size < 1) {
return false
}
for (const [, v] of map) {
if (predicate(v)) {
return true
}
}
return false
}
/**
* Replace the value at a given key in the map using the given
* replacement function. Will use the given `EqualityComparer`
* if passed. Otherwise defaults to reference equality (triple equals).
*
* If the key isn't in the map, returns the map unchanged.
*
* @group Transformations
*/
export const change =
<K, V>(
key: K,
f: (v: V) => V,
equalityComparer: EqualityComparer<K> = EqualityComparer.Default
) =>
(map: ReadonlyMap<K, V>): ReadonlyMap<K, V> =>
pipe(
map,
findWithKey(key, equalityComparer),
Option.match({
some: ([k, v]) => {
const copy = new globalThis.Map(map)
copy.set(k, f(v))
return copy
},
none: map,
})
)
/**
* Get the number of key/value pairs in the map.
*
* @group Utils
*/
export const size = <K, V>(map: ReadonlyMap<K, V>) => map.size
/**
* Returns whether the map contains any key/value pairs.
*
* @group Utils
*
* @returns `true` if the map has no bindings, `false` otherwise.
*/
export const isEmpty = <K, V>(map: ReadonlyMap<K, V>) => map.size < 1
/**
* Get only the keys from the map as an array. Will use the given `OrderingComparer`
* to sort the keys, otherwise will the default ASCII-based sort.
*
* @group Utils
*/
export const keys =
<K>({ compare }: OrderingComparer<K> = OrderingComparer.Default) =>
<V>(map: ReadonlyMap<K, V>): readonly K[] =>
Array.from(map.keys()).sort(compare)
/**
* Gets all the values from the map as an array, including duplicates. Values
* will be sorted using the default ASCII-based sort or the `OrderingComparer`
* if it is given.
* @group Utils
*/
export const values =
<V>(orderingComparer: OrderingComparer<V> = OrderingComparer.Default) =>
<K>(map: ReadonlyMap<K, V>): readonly V[] => {
const values: V[] = []
for (const [, v] of map) {
values.push(v)
}
return values.sort(orderingComparer.compare)
}
/**
* Returns the map as an array of key-value tuples. The array will be sorted by
* key, using the given `OrderingComparer` or falling back to the default ASCII-based
* sort.
*
* @group Transformations
* @group Utils
*/
export const toArray =
<K>(orderingComparer: OrderingComparer<K> = OrderingComparer.Default) =>
<V>(map: ReadonlyMap<K, V>): readonly (readonly [K, V])[] =>
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
keys(orderingComparer)(map).map(key => [key, map.get(key)!])
/**
* Also commonly referred to as `fold` or `aggregate`. Applies each key/value
* pair in the map to a "reducer" (or "folding") function to build up a final
* accumulated value.
*
* Key/value pairs will be given to the reducer function based on the sort-order
* of the keys. That order can be specified by passing the `OrderingComparer`.
* Defaults to the standard ASCII-based sort.
*
* @group Transformations
* @group Utils
*
* @param f
* The reducer function. Accepts the accumulator value, the key, and the value and
* produces the next incremental accumulator value.
*/
export const reduce =
<S, K, V>(
init: S,
f: (acc: S, k: K, v: V) => S,
orderingComparer: OrderingComparer<K> = OrderingComparer.Default
) =>
(map: ReadonlyMap<K, V>): S =>
toArray(orderingComparer)(map).reduce((s, [k, v]) => f(s, k, v), init)
/**
* Like {@link reduce}, but the key-value pairs are passed to the reducer in
* _reverse_ sort-order.
*/
export const reduceRight =
<S, K, V>(
init: S,
f: (acc: S, k: K, v: V) => S,
orderingComparer: OrderingComparer<K> = OrderingComparer.Default
) =>
(map: ReadonlyMap<K, V>): S =>
toArray(orderingComparer)(map).reduceRight((s, [k, v]) => f(s, k, v), init)
/**
* Get a new map containing only the key/value pairs for which the given
* predicate function returns `true`.
*
* @group Transformations
* @group Filtering
*/
export const filter =
<K, V>(f: (k: K, v: V) => boolean) =>
(map: ReadonlyMap<K, V>): ReadonlyMap<K, V> => {
if (map.size < 1) {
return empty()
}
const out = empty<K, V>()
for (const [k, v] of map) {
if (f(k, v)) {
out.set(k, v)
}
}
return out
}
/**
* Test whether every key/value pair in a map returns `true` for the
* given predicate function.
*
* @group Utils
*/
export const every =
<K, V>(f: (k: K, v: V) => boolean) =>
(map: ReadonlyMap<K, V>): boolean => {
if (map.size < 1) {
return true
}
for (const [k, v] of map) {
if (!f(k, v)) {
return false
}
}
return true
}
/**
* Execute an arbitrary side-effect function for every key/value pair in the map.
* Does not affect the values contained in the map. Can be helpful for logging
* or debugging.
*
* @group Utils
*
* @param f Should not mutate its arguments. See {@link map} if you want to
* transform the map into a new map.
*
* @returns void
*/
export const iter =
<K, V>(f: (k: K, v: V) => void) =>
(map: ReadonlyMap<K, V>): void => {
if (map.size < 1) {
return
}
for (const [k, v] of map) {
f(k, v)
}
}
/**
* Convert an array of tuples into a map of key/value pairs.
*
* @group Constructors
*/
export const ofArray = <K, V>(
array: readonly (readonly [K, V])[],
equalityComparer: EqualityComparer<K> = EqualityComparer.Default
): ReadonlyMap<K, V> => {
if (array.length < 1) {
return new globalThis.Map()
}
return array.reduce<ReadonlyMap<K, V>>(
(map, kvp) => set(kvp, equalityComparer)(map),
empty()
)
}
/**
* Remove the given key from the map. Will use the `EqualityComparer` if passed,
* otherwise defaults to reference equality (triple equals). The map will be
* returned unchanged if the key is not found in the map.
*
* @group Transformations
*/
export const remove =
<K>(key: K, equalityComparer: EqualityComparer<K> = EqualityComparer.Default) =>
<V>(map: ReadonlyMap<K, V>) =>
pipe(
map,
findWithKey(key, equalityComparer),
Option.match({
some: ([k]) => {
const copy = new globalThis.Map(map)
copy.delete(k)
return copy
},
none: map,
})
)
/**
* Convert a `Record` object into a map of key/value pairs. Uses `Object.entries`
* under-the-hood, so keep in mind there are some gotchas about what comprise
* an object's "own, enumerable" properties. Designed primarily to be used for
* simple objects like those deserialized from a JSON blob, for instance.
*
* Will use the given `EqualityComparer` to determine key uniqueness if given.
* Otherwise, defaults to reference equality (triple equals).
*
* @group Constructors
*/
export const ofRecord = <K extends string, V>(
record: Record<K, V>,
equalityComparer: EqualityComparer<K> = EqualityComparer.Default
) =>
Object.entries<V>(record).reduce<ReadonlyMap<K, V>>(
(map, [k, v]) => set([k as K, v], equalityComparer)(map),
empty()
)
/* c8 ignore start */
/** @ignore */
export const Map = {
exists,
containsKey,
findWithKey,
find,
findKey,
set,
remove,
change,
map,
filter,
every,
iter,
empty,
size,
isEmpty,
reduce,
reduceRight,
toArray,
ofArray,
ofRecord,
keys,
values,
}
/* c8 ignore end */
| src/Map.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Array.ts",
"retrieved_chunk": " * ['5', [5]]\n * ])\n */\nexport const groupBy =\n <A>(selector: (a: A) => string) =>\n (as: readonly A[]): ReadonlyMap<string, NonEmptyArray<A>> => {\n const groups: Map<string, NonEmptyArray<A>> = new Map()\n as.forEach(a => {\n const key = selector(a)\n return groups.has(key)",
"score": 25.777705373610694
},
{
"filename": "src/EqualityComparer.ts",
"retrieved_chunk": " * @returns A new `EqualityComparer` instance.\n */\nexport const ofStruct = <A extends object>(\n struct: EqualityComparerRecord<A>\n): EqualityComparer<Readonly<A>> =>\n ofEquals((a1, a2) => {\n for (const key in struct) {\n if (!struct[key].equals(a1[key], a2[key])) {\n return false\n }",
"score": 23.165568922651673
},
{
"filename": "src/Array.ts",
"retrieved_chunk": " ? // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n groups.set(key, pipe(groups.get(key)!, append(a)))\n : groups.set(key, [a])\n })\n return groups\n }\n/**\n * Add an array of values to the _end_ of the subsequently\n * passed (partially applied) array, in a way that makes sense\n * when reading top-to-bottom/left-to-right using `pipe`.",
"score": 22.176616938510158
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " * ```\n * pipe(\n * 56,\n * Option.ofNullish,\n * Option.filter(n => n > 50),\n * Option.map(String),\n * Option.match({\n * some: a => `${a}!`,\n * none: \"!\"\n * }),",
"score": 19.627760850285252
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " (options: readonly [Option<A>, Option<B>]): Option<C> => {\n if (isSome(options[0]) && isSome(options[1])) {\n return some(map(options[0].some, options[1].some))\n }\n return none\n }\n/**\n * Returns a Some containing the value returned from the map function\n * if all three `Option`s are `Some`s. Otherwise, returns `None`.\n *",
"score": 19.61874548751975
}
] | typescript | some: ([k]) => { |
/**
See [Enums considered harmful](https://www.youtube.com/watch?v=jjMbPt_H3RQ) for the motivation
behind this custom type. (Also worth noting is that in TypeScript 5.0 [all Enums are considered
unions](https://devblogs.microsoft.com/typescript/announcing-typescript-5-0/#all-enums-are-union-enums).)
Similar to [variants](variants.md) for disciminated unions, `enumOf` allows you to more easily
and safely create and work with enums in TypeScript.
## Basic Example
```ts
export const MyEnum = enumOf(
{
Dog = "Dog",
Cat = "Cat",
ZEBRA = 1234,
} as const, // the `as const` won't be required in TypeScript 5.0
"MyEnum" // friendly name is optional; used to generate helpful parser errors
)
export type MyEnum = EnumOf<typeof MyEnum> // => "Dog" | "Cat" | 1234
```
## Methods
### Standard enum-style accessors
```ts
const dog = MyEnum.Dog // => "Dog"
const zebra = MyEnum.ZEBRA // => 1234
```
### Values
Access array of all valid values, correctly typed (but without any ordering guarantees).
```ts
const myEnumValues = MyEnum.values // => ["Dog", "Cat", 1234]
```
### Parser
Get a safe parser function for this enum automagically!
```ts
const parsed = MyEnum.parse("cat") // => a `Result<MyEnum, string>`, in this case `Result.ok("Cat")`
```
### Match
See `match` in the {@link Variants} module docs for more details on matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.match({
Dog: "woof woof",
Cat: () => "meow",
ZEBRA: "is my skin white with black stripes or black with white stripes??",
})
speak(myEnum)
```
### MatchOrElse
See `matchOrElse` in the {@link Variants} module docs for more details on partial matchers.
```ts
const speak: (e: MyEnum) => string = MyEnum.matchOrElse({
Dog: "woof woof",
Cat: () => "meow",
orELse: "I cannot speak.",
})
speak(myEnum)
```
@module Enums
*/
/* eslint-disable @typescript-eslint/no-explicit-any */
import { Result } from "./Result"
import { String } from "./string"
import { Option } from "./Option"
import { pipe, flow } from "./Composition"
import { Array } from "./Array"
import { Identity, NonNullish } from "./prelude"
/** @ignore */
type StringKeys<T extends object> = Extract<keyof T, string>
/**
* A plain object that serves as the definition of the enum type.
* Until TypeScript 5.0 is released, you need to specify `as const`
* on this object definition.
*/
type RawEnum = Record<string, string | number>
/** @ignore */
type StringKeyValues<T extends RawEnum> = Identity<T[StringKeys<T>]>
/** @ignore */
type EnumMatcher<A, R extends RawEnum> = {
readonly [Label in StringKeys<R>]: (() => A) | A
}
/** @ignore */
type PartialEnumMatcher<A, R extends RawEnum> = Partial<EnumMatcher<A, R>> & {
readonly orElse: (() => A) | A
}
type EnumMatch<R extends RawEnum> = <A>(
matcher: EnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
type EnumMatchOrElse<R extends RawEnum> = <A>(
matcher: PartialEnumMatcher<A, R>
) => (value: StringKeyValues<R>) => A
/**
* The output of the {@link enumOf} function. Produces an object that serves both as
* the enum as well as a namespace for helper functions related to that enum.
*/
type EnumModule<R extends RawEnum> = Identity<
{
readonly [Label in StringKeys<R>]: R[Label]
} & {
/**
* Returns a readonly array containing the set of all possible enum values. No
* guarantees are made regarding the order of items in the resultant array.
*/
readonly values: ReadonlyArray<StringKeyValues<R>>
/**
* For string enum values, the parse function will trim and coerce values to lowercase
* before comparison. (This has no effect on numeric enum values.) Thus, if an
* enum is defined as `'Yes' | 'No'`, this decoder will parse `'yes'`, `' yES'`,
* and `' YES '` correctly into the canonical `'Yes'` enum value.
*/
readonly parse: (u: unknown) => Result<StringKeyValues<R>, string>
/**
* Use this function for an exhaustive case check that doesn't require using
* a switch/case block or any kind of assertExhaustive check.
*/
readonly match: EnumMatch<R>
/**
* Use this function for a partial case check that doesn't require using
* a switch/case block.
*/
readonly matchOrElse: EnumMatchOrElse<R>
}
>
/**
* Gets the union type representing all possible enum values.
*/
export type EnumOf<T> = T extends EnumModule<infer R>
? StringKeyValues<R>
: [never, "Error: T must be an EnumModule"]
const getParserErrorMessage = <T extends RawEnum>(
enumValues: EnumModule<T>["values"],
enumFriendlyName: string
) => `Must be an enum value in the set ${enumFriendlyName}{ ${enumValues.join(", ")} }`
const toTrimmedLowerCase = (a: string | number) =>
pipe(
Option.some(a),
Option.refine(String.isString),
Option.map(flow(String.trim, String.toLowerCase)),
Option.defaultValue(a)
)
const isStringOrNumber = (u: NonNullish): u is string | number =>
typeof u === "string" || typeof u === "number"
const getParseFn =
<R extends RawEnum>(enumValues: EnumModule<R>["values"], enumFriendlyName: string) =>
(u: unknown): Result<StringKeyValues<R>, string> =>
pipe(
Option | .ofNullish(u),
Result.ofOption(
() =>
`Enum${ |
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} cannot be null/undefined`
),
Result.refine(
isStringOrNumber,
() =>
`Enum${
enumFriendlyName ? ` ${enumFriendlyName}` : ""
} must be a string or number`
),
Result.map(toTrimmedLowerCase),
Result.bind(testVal =>
pipe(
enumValues,
Array.find(val => toTrimmedLowerCase(val) === testVal),
Option.match({
some: a => Result.ok(a),
none: () =>
Result.err(
getParserErrorMessage(enumValues, enumFriendlyName)
),
})
)
)
)
const isFunc = (f: unknown): f is (...args: any[]) => any => typeof f === "function"
const getMatchFn =
<R extends RawEnum>(raw: R): EnumMatch<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (!Object.hasOwn(matcher, enumLabel)) {
throw new TypeError(
`Expected a matcher containing a case for '${enumLabel}'.`
)
}
const matcherBranch = matcher[enumLabel]
return isFunc(matcherBranch) ? matcherBranch() : matcherBranch
}
const getMatchOrElseFn =
<R extends RawEnum>(raw: R): EnumMatchOrElse<R> =>
matcher =>
value => {
const enumEntry = Object.entries(raw).find(([, v]) => v === value)
if (!enumEntry) {
throw new TypeError(
`Expected to match against an enum where '${value}' is a valid value.`
)
}
const enumLabel = enumEntry[0]
if (Object.hasOwn(matcher, enumLabel)) {
const branch = matcher[enumLabel]
// eslint-disable-next-line @typescript-eslint/no-unsafe-return
return isFunc(branch) ? branch() : branch
}
return isFunc(matcher.orElse) ? matcher.orElse() : matcher.orElse
}
/**
* Generates an "enum module" from a raw object. For motivation behind using a custom
* generative function instead of the built-in `enum` types, see [this video](https://youtu.be/jjMbPt_H3RQ).
*
* This function augments a raw "enum object" with several useful capabilities: `values`, `parse`, `match`,
* and `matchOrElse`.
* - `values` contains the list of valid enum values
* - `parse` is a parser funciton auto-magically created for this enum
* - `match` is a pipeable function that allows exhaustive pattern matching
* - `matchOrElse` is a pipeable function that allows inexhaustive pattern matching
*
* @remarks
* You can use the `parse` function together with `io-ts` to easily create a decoder for this enum.
*
* @example
* ```ts
* export const MyEnum = enumOf({
* Dog = 'Dog',
* Cat = 'Cat',
* ZEBRA = 1234,
* } as const, 'MyEnum') // => friendly name optional; used to generate helpful decoder errors
* export type MyEnum = EnumOf<typeof MyEnum>; //=> 'Dog' | 'Cat' | 1234
*
* // Standard enum-style accessors
* const dog = MyEnum.Dog; // => 'Dog'
* const zebra = MyEnum.ZEBRA; // => 1234
*
* // Access array of all valid values, correctly typed
* const myEnumValues = MyEnum.values; // => ['Dog', 'Cat', 1234]
*
* // Get a decoder instance for this enum automagically
* const myDecoder = MyEnum.decoder; // => a `D.Decoder<unknown, 'Dog' | 'Cat' | 1234>`
*
* // Match an enum value against all its cases (compiler ensures exhaustiveness)
* const value: MyEnum = 'Cat';
* const matchResult = pipe(
* value,
* MyEnum.match({
* Dog: 'woof woof',
* Cat: () => 'meow',
* ZEBRA: 'is my skin white with black stripes or black with white stripes??'
* })
* ) // => 'meow'
* ```
*/
export const enumOf = <T extends RawEnum>(
raw: T,
enumFriendlyName = ""
): EnumModule<T> => {
const entriesWithStringKeys = Object.entries(raw).reduce(
(acc, [label, value]) => ({
...acc,
[label]: value,
}),
{}
)
const values = Object.values(raw)
return {
...entriesWithStringKeys,
values,
parse: getParseFn(values, enumFriendlyName),
match: getMatchFn(raw),
matchOrElse: getMatchOrElseFn(raw),
} as unknown as EnumModule<T>
}
| src/Enums.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/string.ts",
"retrieved_chunk": " * @returns boolean\n */\nexport const isString = (u: unknown): u is string => typeof u === \"string\"\n/**\n * Get the length of a string.\n *\n * @group Utils\n */\nexport const length = (s: string) => s.length\n/**",
"score": 60.41812573343187
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " *\n * @example\n * ```\n * const isString = (u: unknown): u is string => typeof u === \"string\"\n *\n * pipe(\n * Option.some(\"cheese\" as any), // Option<any>\n * Option.refine(isString), // Option<string> (type is narrowed by the guard)\n * Option.map(s => s.length) // Option<number> (TS infers the type of `s`)\n * ) // => Option.some(6)",
"score": 58.47179415989953
},
{
"filename": "src/Array.ts",
"retrieved_chunk": " * @example\n * pipe(\n * [32, null, 55, undefined, 89], // (number | null | undefined)[]\n * Array.chooseR(x => pipe(\n * x, // number | null | undefined\n * Option.ofNullish, // Option<number>\n * Option.map(String), // Option<string>\n * Result.ofOption(() => \"err\") // Result<string, string>\n * )) // string[]\n * ) // => [\"32\", \"55\", \"89\"]",
"score": 34.6317238020702
},
{
"filename": "src/string.ts",
"retrieved_chunk": " * Curried version of the built-in toUpperCase method.\n *\n * @group Utils\n */\nexport const toUpperCase = (s: string) => s.toUpperCase()\n/**\n * Type guard that holds true when `u` is a string.\n *\n * @group Type Guards\n *",
"score": 32.81479904668395
},
{
"filename": "src/Result.ts",
"retrieved_chunk": "interface ResultMatcher<A, E, R> {\n readonly ok: R | ((ok: A) => R)\n readonly err: R | ((err: E) => R)\n}\nconst isRawValue = <A, E, R>(caseFn: R | ((ok: A) => R) | ((err: E) => E)): caseFn is R =>\n typeof caseFn !== \"function\"\nconst getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>\n isRawValue(match) ? match : match(arg)\n/**\n * Exhaustive pattern match against a `Result` to \"unwrap\" its inner",
"score": 28.480244852973424
}
] | typescript | .ofNullish(u),
Result.ofOption(
() =>
`Enum${ |
/**
* The `Result` type represents the outcome of a completed operation
* that either succeeded with some `Ok` value (also called a "success"
* or "right" value), or failed with some `Err` value (also called a
* "failure" or "left" value).
*
* Generally speaking, `Result` is not intended to _replace_ exception
* handling, but to augment it, so that exceptions can be used to handle
* truly _exceptional_ things. (i.e., Is it really exceptional that a
* network request failed?)
*
* This API has been optimized for use with left-to-right function composition
* using `pipe` and `flow`.
*
* @example
* ```
* pipe(
* Result.tryCatch(() => readFileMightThrow()),
* Result.mapErr(FileError.create),
* Result.bind(fileText => pipe(
* Result.tryCatch(() => transmitMightThrow(fileText)),
* Result.mapErr(FileError.create)
* )),
* Result.map(transmitResponse => transmitResponse?.status),
* Result.defaultValue("failed")
* )
* // may return, e.g., "pending" if everything worked
* // or "failed" if something fell down along the way
* ```
*
* @module Result
*/
/* eslint-disable @typescript-eslint/no-empty-interface */
import { Tagged, assertExhaustive, Refinement, NonNullish } from "./prelude"
import { Option } from "./Option"
import { flow, pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
export interface Ok<A | > extends Tagged<"Ok", { ok: A }> {} |
export interface Err<E> extends Tagged<"Err", { err: E }> {}
export type Result<A, E> = Ok<A> | Err<E>
/**
* Construct a new Ok instance.
*
* @group Constructors
*
* @returns A new Ok instance containing the given value.
*/
export const ok = <A, E = never>(ok: A): Result<A, E> => ({
_tag: "Ok",
ok,
})
/**
* Construct a new Err instance.
*
* @group Constructors
*
* @returns A new Err instance with the given value. */
export const err = <E, A = never>(err: E): Result<A, E> => ({
_tag: "Err",
err,
})
/**
* Alias for {@link ok}.
*
* @group Constructors
*/
export const of = ok
/**
* @ignore
*/
interface ResultMatcher<A, E, R> {
readonly ok: R | ((ok: A) => R)
readonly err: R | ((err: E) => R)
}
const isRawValue = <A, E, R>(caseFn: R | ((ok: A) => R) | ((err: E) => E)): caseFn is R =>
typeof caseFn !== "function"
const getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>
isRawValue(match) ? match : match(arg)
/**
* Exhaustive pattern match against a `Result` to "unwrap" its inner
* value. Pass a matcher function with cases for `ok` and `err` that
* can either be lambdas or raw values.
*
* @group Pattern Matching
*
* @example
* ```
* pipe(
* Result.err("failure"),
* Result.match({
* ok: a => `${a.length}`,
* err: s => `${s}!`
* })
* ) // => "failure!"
* ```
*/
export const match =
<A, E, R>(matcher: ResultMatcher<A, E, R>) =>
(result: Result<A, E>) => {
switch (result._tag) {
case "Ok":
return getMatcherResult(matcher.ok, result.ok)
case "Err":
return getMatcherResult(matcher.err, result.err)
/* c8 ignore next 2 */
default:
return assertExhaustive(result)
}
}
/**
* Filter a `Result` using a type guard (a.k.a. `Refinement` function) that, if
* it succeeds, will return an `Ok` with a narrowed type. If it fails, will use
* the given `onFail` function to produce an error branch.
*
* @group Utils
* @group Filtering
*
* @example
* ```
* const isCat = (s: string): s is "cat" => s === "cat"
* pipe(
* Result.ok("dog"),
* Result.refine(isCat, a => `"${a}" is not "cat"!`)
* ) // => Result.err('"dog" is not "cat"!')
* ```
*/
export const refine =
<A, B extends A, E>(refinement: Refinement<A, B>, onFail: (a: A) => E) =>
(result: Result<A, E>): Result<B, E> =>
pipe(
result,
match({
ok: a => (refinement(a) ? ok(a) : err(onFail(a))),
err: e => err(e),
})
)
/**
* Map the inner `Ok` value using the given function and
* return a new `Result`. Passes `Err` values through as-is.
*
* @group Mapping
*
* @example
* pipe(
* Result.ok(2),
* Result.map(n => n + 3)
* ) // => Result.ok(5)
*/
export const map =
<A, B>(f: (a: A) => B) =>
<E>(result: Result<A, E>): Result<B, E> =>
pipe(
result,
match({
ok: a => ok(f(a)),
err: e => err(e),
})
)
/**
* Map the inner `Err` value using the given function and
* return a new `Result`. `Ok` values are passed through as-is.
*
* @group Mapping
*
* @example
* pipe(
* Result.err("cheese melted"),
* Result.mapErr(s => s.length)
* ) // => Result.err(13)
*/
export const mapErr =
<E1, E2>(f: (e: E1) => E2) =>
<A>(result: Result<A, E1>) =>
pipe(
result,
match({
ok: a => ok(a),
err: e => err(f(e)),
})
)
/**
* Map both branches of the Result by specifying a lambda
* to use in either case. Equivalent to calling {@link map} followed
* by {@link mapErr}.
*
* @group Mapping
*/
export const mapBoth = <A1, E1, A2, E2>(mapOk: (a: A1) => A2, mapErr: (e: E1) => E2) =>
match<A1, E1, Result<A2, E2>>({
ok: a => ok(mapOk(a)),
err: e => err(mapErr(e)),
})
/**
* Return the inner `Ok` value or the given default value
* if the Result is an Err.
*
* @group Pattern Matching
*/
export const defaultValue =
<A>(a: A) =>
<E>(result: Result<A, E>) =>
pipe(
result,
match({
ok: a => a,
err: a,
})
)
/**
* Return the inner `Ok` value or use the given lambda
* to compute the default value if the `Result` is an `Err`.
*
* @group Pattern Matching
*/
export const defaultWith =
<A>(f: () => A) =>
<E>(result: Result<A, E>) =>
pipe(
result,
match({
ok: a => a,
err: f,
})
)
/**
* Maps the inner `Ok` value using a function that
* also returns a `Result`, and flattens the result.
* `Err` values are passed through as-is. This function
* is also referred to as `flatMap`.
*
* @group Mapping
*
* @example
* pipe(
* Result.ok("a"),
* Result.bind(s =>
* s === "a" ? Result.ok("got an a!") : Result.err("not an a")
* ),
* Result.defaultValue("")
* ) // => "got an a!"
*/
export const bind = <A, E, B>(f: (a: A) => Result<B, E>) =>
match<A, E, Result<B, E>>({
ok: f,
err: e => err(e),
})
/**
* Alias for {@link bind}.
*
* @group Mapping
*/
export const flatMap = bind
/**
* A type guard (a.k.a. `Refinement`) that holds if the result
* is an `Ok`. Allows the TypeScript compiler to narrow the type
* and allow type-safe access to `.ok`.
*
* @group Type Guards
*/
export const isOk = <A, E = never>(result: Result<A, E>): result is Ok<A> =>
result._tag === "Ok"
/**
* A type guard (a.k.a. `Refinement`) that holds if the result is
* an `Err`. Allows the TypeScript compiler to narrow the type and
* allow safe access to `.err`.
*
* @group Type Guards
*/
export const isErr = <E, A = never>(result: Result<A, E>): result is Err<E> =>
result._tag === "Err"
/**
* Map a tuple of `Result`s.
*
* If given two `Ok` values, uses the given mapper function and produces
* a new `Ok` instance with the result. If either of the `Result`s are an
* `Err`, returns an `Err`. If both results are an `Err`, returns the first
* one and ignores the second.
*
* @remarks
* This is effectively a shortcut to pattern matching a 2-tuple of Results.
*
* @group Mapping
*/
export const map2 =
<A, B, C>(map: (a: A, b: B) => C) =>
<E>(results: readonly [Result<A, E>, Result<B, E>]): Result<C, E> => {
if (isOk(results[0]) && isOk(results[1])) {
return ok(map(results[0].ok, results[1].ok))
} else if (isErr(results[0])) {
return err(results[0].err)
} else {
return err((results[1] as Err<E>).err)
}
}
/**
* Map a 3-tuple of `Result`s.
*
* If given three `Ok` values, uses the given mapper function and returns
* a new `Ok` value with the result. If any of the `Result`s are an `Err`,
* returns an `Err`.
*
* If multiple `Result`s are an `Err`, returns the first one found and
* ignores the others.
*
* @remarks
* This is effectively a shortcut to pattern matching a 3-tuple of Results.
*
* @group Pattern Matching
*/
export const map3 =
<A, B, C, D>(map: (a: A, b: B, c: C) => D) =>
<E>(results: readonly [Result<A, E>, Result<B, E>, Result<C, E>]): Result<D, E> => {
if (isOk(results[0]) && isOk(results[1]) && isOk(results[2])) {
return ok(map(results[0].ok, results[1].ok, results[2].ok))
} else if (isErr(results[0])) {
return err(results[0].err)
} else if (isErr(results[1])) {
return err(results[1].err)
} else {
return err((results[2] as Err<E>).err)
}
}
/* eslint-disable func-style */
/**
* Attempts to invoke a function that may throw. If the function
* succeeds, returns an Ok with the result. If the function throws,
* returns an Err containing the thrown Error, optionally transformed.
*
* @group Utils
*
* @param onThrow
* Optional. If given, accepts the thrown `unknown` object and produces
* the Err branch. If omitted, the thrown object will be stringified and
* wrapped in a new Error instance if it is not already an Error instance.
*/
export function tryCatch<A>(mightThrow: () => A): Result<A, Error>
export function tryCatch<A, E = unknown>(
mightThrow: () => A,
onThrow: (thrown: unknown) => E
): Result<A, E>
export function tryCatch<A, E = unknown>(
mightThrow: () => A,
onThrow?: (err: unknown) => E
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): Result<A, any> {
const toError = (err: unknown) => (err instanceof Error ? err : Error(String(err)))
try {
return ok(mightThrow())
} catch (err) {
if (onThrow != null) {
return Result.err(onThrow(err))
}
return Result.err(toError(err))
}
}
/* eslint-enable func-style */
/**
* Allows some arbitrary side-effect function to be called
* using the wrapped `Ok` value. Useful for debugging and logging.
*
* @group Utils
*
* @param f Should not mutate its arguments. Use {@link map} if you
* want to map the inner value of the Result instead.
*
* @example
* ```
* pipe(
* Result.ok(23),
* Result.tee(console.log), // logs `23`
* Result.map(n => n + 1), // inner value is unchanged
* Result.defaultValue(0)
* ) // => 24
* ```
*/
export const tee =
<A>(f: (a: A) => void) =>
<E>(result: Result<A, E>): Result<A, E> =>
pipe(
result,
match({
ok: a => {
f(a)
return ok(a)
},
err: e => err(e),
})
)
/**
* Allows some arbitrary side-effect function to be called
* using the wrapped `Err` value. Useful for debugging and logging.
*
* @param f Should not mutate its arguments. Use {@link mapErr} if
* you want to map the inner `Err` value.
*
* @group Utils
*
* @example
* ```
* pipe(
* Result.err("melted"),
* Result.teeErr(console.log), // logs `melted`
* Result.mapErr(s => s.length), // inner value is unchanged
* ) // => Result.err(6)
* ```
*/
export const teeErr =
<E>(f: (e: E) => void) =>
<A>(result: Result<A, E>): Result<A, E> =>
pipe(
result,
match({
ok: a => ok(a),
err: e => {
f(e)
return err(e)
},
})
)
/**
* Converts an `Option` to a `Result`.
*
* @group Constructors
* @group Utils
*
* @param onNone Used to convert a `None` branch into an `Err` branch.
*
* @returns a new `Result`.
*/
export const ofOption = <A extends NonNullish, E>(onNone: () => E) =>
Option.match<A, Result<A, E>>({
some: ok,
none: flow(onNone, err),
})
/**
* Get an `EqualityComparer` for an `Result<A, E>` by giving this function an
* `EqualityComparer` for type `A` and one for type `E`. Represents structural
* (value-based) equality for the `Result` type.
*
* @group Equality
* @group Utils
*
* @param equalityComparerA The `EqualityComparer` to use for the inner ok value.
* @param equalityComparerE The `EqualityComparer` to use for the inner err value.
*
* @returns A new `EqualityComparer` instance
*/
export const getEqualityComparer = <A, E>(
equalityComparerA: EqualityComparer<A>,
equalityComparerE: EqualityComparer<E>
): EqualityComparer<Result<A, E>> =>
EqualityComparer.ofEquals((r1, r2) => {
if (isErr(r1) && isErr(r2) && equalityComparerE.equals(r1.err, r2.err)) {
return true
}
return pipe(
[r1, r2] as const,
map2((a1: A, a2: A) => equalityComparerA.equals(a1, a2)),
defaultValue(false)
)
})
/* c8 ignore start */
/** @ignore */
export const Result = {
ok,
of,
err,
isOk,
isErr,
match,
map,
map2,
map3,
mapErr,
mapBoth,
bind,
flatMap,
defaultValue,
defaultWith,
tryCatch,
tee,
teeErr,
ofOption,
getEqualityComparer,
refine,
}
/* c8 ignore end */
| src/Result.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/Option.ts",
"retrieved_chunk": " * console.info\n * ) // logs \"56!\"\n * ```\n *\n * @module Option\n */\n/* eslint-disable @typescript-eslint/no-empty-interface */\nimport { Tagged, assertExhaustive, Refinement, NonNullish } from \"./prelude\"\nimport { pipe } from \"./Composition\"\nimport { EqualityComparer } from \"./EqualityComparer\"",
"score": 120.65402927288419
},
{
"filename": "src/Deferred.ts",
"retrieved_chunk": " * @module Deferred\n */\n/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-empty-interface */\nimport { Tagged, assertExhaustive } from \"./prelude\"\nimport { pipe } from \"./Composition\"\nimport { EqualityComparer } from \"./EqualityComparer\"\n/** The `NotStarted` type. */\nexport interface NotStarted extends Tagged<\"NotStarted\", object> {}\n/** The `InProgress` type. */",
"score": 110.05132141139626
},
{
"filename": "src/Enums.ts",
"retrieved_chunk": " orELse: \"I cannot speak.\",\n})\nspeak(myEnum)\n```\n@module Enums\n*/\n/* eslint-disable @typescript-eslint/no-explicit-any */\nimport { Result } from \"./Result\"\nimport { String } from \"./string\"\nimport { Option } from \"./Option\"",
"score": 75.09273333211803
},
{
"filename": "src/Map.ts",
"retrieved_chunk": "/**\n * A suite of useful functions for working with the built-in `Map` type.\n *\n * @module Map\n */\nimport { NonNullish, Predicate } from \"./prelude\"\nimport { Option } from \"./Option\"\nimport { pipe } from \"./Composition\"\nimport { EqualityComparer } from \"./EqualityComparer\"\nimport { OrderingComparer } from \"./OrderingComparer\"",
"score": 73.65785083870537
},
{
"filename": "src/Variants.ts",
"retrieved_chunk": "/* eslint-disable @typescript-eslint/no-unsafe-call */\n/* eslint-disable @typescript-eslint/no-unsafe-argument */\nimport { Identity } from \"./prelude\"\nimport { String } from \"./string\"\n/**************\n * Helper Types\n ***************/\ntype DefaultDiscriminant = \"_tag\"\ntype DefaultScope = \"\"\ntype Func = (...args: any[]) => any",
"score": 64.5065677699027
}
] | typescript | > extends Tagged<"Ok", { ok: A }> {} |
/**
* The `Result` type represents the outcome of a completed operation
* that either succeeded with some `Ok` value (also called a "success"
* or "right" value), or failed with some `Err` value (also called a
* "failure" or "left" value).
*
* Generally speaking, `Result` is not intended to _replace_ exception
* handling, but to augment it, so that exceptions can be used to handle
* truly _exceptional_ things. (i.e., Is it really exceptional that a
* network request failed?)
*
* This API has been optimized for use with left-to-right function composition
* using `pipe` and `flow`.
*
* @example
* ```
* pipe(
* Result.tryCatch(() => readFileMightThrow()),
* Result.mapErr(FileError.create),
* Result.bind(fileText => pipe(
* Result.tryCatch(() => transmitMightThrow(fileText)),
* Result.mapErr(FileError.create)
* )),
* Result.map(transmitResponse => transmitResponse?.status),
* Result.defaultValue("failed")
* )
* // may return, e.g., "pending" if everything worked
* // or "failed" if something fell down along the way
* ```
*
* @module Result
*/
/* eslint-disable @typescript-eslint/no-empty-interface */
import { Tagged, assertExhaustive, Refinement, NonNullish } from "./prelude"
import { Option } from "./Option"
import { flow, pipe } from "./Composition"
import { EqualityComparer } from "./EqualityComparer"
export interface Ok<A> extends Tagged<"Ok", { ok: A }> {}
export interface Err<E> extends Tagged<"Err", { err: E }> {}
export type Result<A, E> = Ok<A> | Err<E>
/**
* Construct a new Ok instance.
*
* @group Constructors
*
* @returns A new Ok instance containing the given value.
*/
export const ok = <A, E = never>(ok: A): Result<A, E> => ({
_tag: "Ok",
ok,
})
/**
* Construct a new Err instance.
*
* @group Constructors
*
* @returns A new Err instance with the given value. */
export const err = <E, A = never>(err: E): Result<A, E> => ({
_tag: "Err",
err,
})
/**
* Alias for {@link ok}.
*
* @group Constructors
*/
export const of = ok
/**
* @ignore
*/
interface ResultMatcher<A, E, R> {
readonly ok: R | ((ok: A) => R)
readonly err: R | ((err: E) => R)
}
const isRawValue = <A, E, R>(caseFn: R | ((ok: A) => R) | ((err: E) => E)): caseFn is R =>
typeof caseFn !== "function"
const getMatcherResult = <T, R>(match: ((t: T) => R) | R, arg: T) =>
isRawValue(match) ? match : match(arg)
/**
* Exhaustive pattern match against a `Result` to "unwrap" its inner
* value. Pass a matcher function with cases for `ok` and `err` that
* can either be lambdas or raw values.
*
* @group Pattern Matching
*
* @example
* ```
* pipe(
* Result.err("failure"),
* Result.match({
* ok: a => `${a.length}`,
* err: s => `${s}!`
* })
* ) // => "failure!"
* ```
*/
export const match =
<A, E, R>(matcher: ResultMatcher<A, E, R>) =>
(result: Result<A, E>) => {
switch (result._tag) {
case "Ok":
return getMatcherResult(matcher.ok, result.ok)
case "Err":
| return getMatcherResult(matcher.err, result.err)
/* c8 ignore next 2 */
default:
return assertExhaustive(result)
} |
}
/**
* Filter a `Result` using a type guard (a.k.a. `Refinement` function) that, if
* it succeeds, will return an `Ok` with a narrowed type. If it fails, will use
* the given `onFail` function to produce an error branch.
*
* @group Utils
* @group Filtering
*
* @example
* ```
* const isCat = (s: string): s is "cat" => s === "cat"
* pipe(
* Result.ok("dog"),
* Result.refine(isCat, a => `"${a}" is not "cat"!`)
* ) // => Result.err('"dog" is not "cat"!')
* ```
*/
export const refine =
<A, B extends A, E>(refinement: Refinement<A, B>, onFail: (a: A) => E) =>
(result: Result<A, E>): Result<B, E> =>
pipe(
result,
match({
ok: a => (refinement(a) ? ok(a) : err(onFail(a))),
err: e => err(e),
})
)
/**
* Map the inner `Ok` value using the given function and
* return a new `Result`. Passes `Err` values through as-is.
*
* @group Mapping
*
* @example
* pipe(
* Result.ok(2),
* Result.map(n => n + 3)
* ) // => Result.ok(5)
*/
export const map =
<A, B>(f: (a: A) => B) =>
<E>(result: Result<A, E>): Result<B, E> =>
pipe(
result,
match({
ok: a => ok(f(a)),
err: e => err(e),
})
)
/**
* Map the inner `Err` value using the given function and
* return a new `Result`. `Ok` values are passed through as-is.
*
* @group Mapping
*
* @example
* pipe(
* Result.err("cheese melted"),
* Result.mapErr(s => s.length)
* ) // => Result.err(13)
*/
export const mapErr =
<E1, E2>(f: (e: E1) => E2) =>
<A>(result: Result<A, E1>) =>
pipe(
result,
match({
ok: a => ok(a),
err: e => err(f(e)),
})
)
/**
* Map both branches of the Result by specifying a lambda
* to use in either case. Equivalent to calling {@link map} followed
* by {@link mapErr}.
*
* @group Mapping
*/
export const mapBoth = <A1, E1, A2, E2>(mapOk: (a: A1) => A2, mapErr: (e: E1) => E2) =>
match<A1, E1, Result<A2, E2>>({
ok: a => ok(mapOk(a)),
err: e => err(mapErr(e)),
})
/**
* Return the inner `Ok` value or the given default value
* if the Result is an Err.
*
* @group Pattern Matching
*/
export const defaultValue =
<A>(a: A) =>
<E>(result: Result<A, E>) =>
pipe(
result,
match({
ok: a => a,
err: a,
})
)
/**
* Return the inner `Ok` value or use the given lambda
* to compute the default value if the `Result` is an `Err`.
*
* @group Pattern Matching
*/
export const defaultWith =
<A>(f: () => A) =>
<E>(result: Result<A, E>) =>
pipe(
result,
match({
ok: a => a,
err: f,
})
)
/**
* Maps the inner `Ok` value using a function that
* also returns a `Result`, and flattens the result.
* `Err` values are passed through as-is. This function
* is also referred to as `flatMap`.
*
* @group Mapping
*
* @example
* pipe(
* Result.ok("a"),
* Result.bind(s =>
* s === "a" ? Result.ok("got an a!") : Result.err("not an a")
* ),
* Result.defaultValue("")
* ) // => "got an a!"
*/
export const bind = <A, E, B>(f: (a: A) => Result<B, E>) =>
match<A, E, Result<B, E>>({
ok: f,
err: e => err(e),
})
/**
* Alias for {@link bind}.
*
* @group Mapping
*/
export const flatMap = bind
/**
* A type guard (a.k.a. `Refinement`) that holds if the result
* is an `Ok`. Allows the TypeScript compiler to narrow the type
* and allow type-safe access to `.ok`.
*
* @group Type Guards
*/
export const isOk = <A, E = never>(result: Result<A, E>): result is Ok<A> =>
result._tag === "Ok"
/**
* A type guard (a.k.a. `Refinement`) that holds if the result is
* an `Err`. Allows the TypeScript compiler to narrow the type and
* allow safe access to `.err`.
*
* @group Type Guards
*/
export const isErr = <E, A = never>(result: Result<A, E>): result is Err<E> =>
result._tag === "Err"
/**
* Map a tuple of `Result`s.
*
* If given two `Ok` values, uses the given mapper function and produces
* a new `Ok` instance with the result. If either of the `Result`s are an
* `Err`, returns an `Err`. If both results are an `Err`, returns the first
* one and ignores the second.
*
* @remarks
* This is effectively a shortcut to pattern matching a 2-tuple of Results.
*
* @group Mapping
*/
export const map2 =
<A, B, C>(map: (a: A, b: B) => C) =>
<E>(results: readonly [Result<A, E>, Result<B, E>]): Result<C, E> => {
if (isOk(results[0]) && isOk(results[1])) {
return ok(map(results[0].ok, results[1].ok))
} else if (isErr(results[0])) {
return err(results[0].err)
} else {
return err((results[1] as Err<E>).err)
}
}
/**
* Map a 3-tuple of `Result`s.
*
* If given three `Ok` values, uses the given mapper function and returns
* a new `Ok` value with the result. If any of the `Result`s are an `Err`,
* returns an `Err`.
*
* If multiple `Result`s are an `Err`, returns the first one found and
* ignores the others.
*
* @remarks
* This is effectively a shortcut to pattern matching a 3-tuple of Results.
*
* @group Pattern Matching
*/
export const map3 =
<A, B, C, D>(map: (a: A, b: B, c: C) => D) =>
<E>(results: readonly [Result<A, E>, Result<B, E>, Result<C, E>]): Result<D, E> => {
if (isOk(results[0]) && isOk(results[1]) && isOk(results[2])) {
return ok(map(results[0].ok, results[1].ok, results[2].ok))
} else if (isErr(results[0])) {
return err(results[0].err)
} else if (isErr(results[1])) {
return err(results[1].err)
} else {
return err((results[2] as Err<E>).err)
}
}
/* eslint-disable func-style */
/**
* Attempts to invoke a function that may throw. If the function
* succeeds, returns an Ok with the result. If the function throws,
* returns an Err containing the thrown Error, optionally transformed.
*
* @group Utils
*
* @param onThrow
* Optional. If given, accepts the thrown `unknown` object and produces
* the Err branch. If omitted, the thrown object will be stringified and
* wrapped in a new Error instance if it is not already an Error instance.
*/
export function tryCatch<A>(mightThrow: () => A): Result<A, Error>
export function tryCatch<A, E = unknown>(
mightThrow: () => A,
onThrow: (thrown: unknown) => E
): Result<A, E>
export function tryCatch<A, E = unknown>(
mightThrow: () => A,
onThrow?: (err: unknown) => E
// eslint-disable-next-line @typescript-eslint/no-explicit-any
): Result<A, any> {
const toError = (err: unknown) => (err instanceof Error ? err : Error(String(err)))
try {
return ok(mightThrow())
} catch (err) {
if (onThrow != null) {
return Result.err(onThrow(err))
}
return Result.err(toError(err))
}
}
/* eslint-enable func-style */
/**
* Allows some arbitrary side-effect function to be called
* using the wrapped `Ok` value. Useful for debugging and logging.
*
* @group Utils
*
* @param f Should not mutate its arguments. Use {@link map} if you
* want to map the inner value of the Result instead.
*
* @example
* ```
* pipe(
* Result.ok(23),
* Result.tee(console.log), // logs `23`
* Result.map(n => n + 1), // inner value is unchanged
* Result.defaultValue(0)
* ) // => 24
* ```
*/
export const tee =
<A>(f: (a: A) => void) =>
<E>(result: Result<A, E>): Result<A, E> =>
pipe(
result,
match({
ok: a => {
f(a)
return ok(a)
},
err: e => err(e),
})
)
/**
* Allows some arbitrary side-effect function to be called
* using the wrapped `Err` value. Useful for debugging and logging.
*
* @param f Should not mutate its arguments. Use {@link mapErr} if
* you want to map the inner `Err` value.
*
* @group Utils
*
* @example
* ```
* pipe(
* Result.err("melted"),
* Result.teeErr(console.log), // logs `melted`
* Result.mapErr(s => s.length), // inner value is unchanged
* ) // => Result.err(6)
* ```
*/
export const teeErr =
<E>(f: (e: E) => void) =>
<A>(result: Result<A, E>): Result<A, E> =>
pipe(
result,
match({
ok: a => ok(a),
err: e => {
f(e)
return err(e)
},
})
)
/**
* Converts an `Option` to a `Result`.
*
* @group Constructors
* @group Utils
*
* @param onNone Used to convert a `None` branch into an `Err` branch.
*
* @returns a new `Result`.
*/
export const ofOption = <A extends NonNullish, E>(onNone: () => E) =>
Option.match<A, Result<A, E>>({
some: ok,
none: flow(onNone, err),
})
/**
* Get an `EqualityComparer` for an `Result<A, E>` by giving this function an
* `EqualityComparer` for type `A` and one for type `E`. Represents structural
* (value-based) equality for the `Result` type.
*
* @group Equality
* @group Utils
*
* @param equalityComparerA The `EqualityComparer` to use for the inner ok value.
* @param equalityComparerE The `EqualityComparer` to use for the inner err value.
*
* @returns A new `EqualityComparer` instance
*/
export const getEqualityComparer = <A, E>(
equalityComparerA: EqualityComparer<A>,
equalityComparerE: EqualityComparer<E>
): EqualityComparer<Result<A, E>> =>
EqualityComparer.ofEquals((r1, r2) => {
if (isErr(r1) && isErr(r2) && equalityComparerE.equals(r1.err, r2.err)) {
return true
}
return pipe(
[r1, r2] as const,
map2((a1: A, a2: A) => equalityComparerA.equals(a1, a2)),
defaultValue(false)
)
})
/* c8 ignore start */
/** @ignore */
export const Result = {
ok,
of,
err,
isOk,
isErr,
match,
map,
map2,
map3,
mapErr,
mapBoth,
bind,
flatMap,
defaultValue,
defaultWith,
tryCatch,
tee,
teeErr,
ofOption,
getEqualityComparer,
refine,
}
/* c8 ignore end */
| src/Result.ts | fp-toolkit-fp-toolkit-a5f0d7d | [
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " return getMatcherResult(matcher.inProgress, undefined)\n case \"NotStarted\":\n return getMatcherResult(matcher.notStarted, undefined)\n case \"Resolved\":\n return pipe(\n deferredResult.resolved,\n Result.match({\n ok: a => getMatcherResult(matcher.resolvedOk, a),\n err: e => getMatcherResult(matcher.resolvedErr, e),\n })",
"score": 55.75784858975522
},
{
"filename": "src/AsyncResult.ts",
"retrieved_chunk": " const result = await async()\n return await pipe(\n result,\n Result.match({\n ok: f,\n err: e => err(e),\n }),\n Async.start\n )\n }",
"score": 51.99670367871909
},
{
"filename": "src/Deferred.ts",
"retrieved_chunk": " switch (deferred._tag) {\n case \"NotStarted\":\n return resultOrValue(matcher.notStarted)\n case \"InProgress\":\n return resultOrValue(matcher.inProgress)\n case \"Resolved\":\n return resultOrValue(matcher.resolved, deferred.resolved)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(deferred) as R",
"score": 51.0774464780995
},
{
"filename": "src/Option.ts",
"retrieved_chunk": " case \"None\":\n return getMatcherResult(matcher.none, void 0)\n /* c8 ignore next 2 */\n default:\n return assertExhaustive(option)\n }\n }\n/**\n * Maps the wrapped `Some` value using the given function.\n * Passes through `None` as-is.",
"score": 45.8162735445724
},
{
"filename": "src/DeferredResult.ts",
"retrieved_chunk": " ? getMatcherResult(matcher.inProgress, undefined)\n : getMatcherResult(matcher.orElse, undefined)\n case \"NotStarted\":\n return objHasOptionalProp(\"notStarted\", matcher)\n ? getMatcherResult(matcher.notStarted, undefined)\n : getMatcherResult(matcher.orElse, undefined)\n case \"Resolved\":\n return pipe(\n deferredResult.resolved,\n Result.match({",
"score": 42.260009033724614
}
] | typescript | return getMatcherResult(matcher.err, result.err)
/* c8 ignore next 2 */
default:
return assertExhaustive(result)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.