@stackframe/stack-shared 1.0.0

package/dist/interface/clientInterface.js

@@ -0,0 +1,444 @@
+import * as oauth from 'oauth4webapi';
+import crypto from "crypto";
+import { AccessTokenExpiredErrorCode, GrantInvalidErrorCode, KnownErrorCodes, KnownError, SignUpErrorCodes, SignInErrorCodes, EmailVerificationLinkErrorCodes, PasswordResetLinkErrorCodes } from "../utils/types";
+import { Result } from "../utils/results";
+import { parseJson } from '../utils/json';
+import { AsyncCache, AsyncValueCache } from '../utils/caches';
+import { typedAssign } from '../utils/objects';
+import { AsyncStore } from '../utils/stores';
+import { runAsynchronously } from '../utils/promises';
+function getSessionCookieName(projectId) {
+    return "__stack-token-" + crypto.createHash("sha256").update(projectId).digest("hex");
+}
+export class StackClientInterface {
+    options;
+    // note that we intentionally use TokenStore (a reference type) as a key, as different token stores with the same tokens should be treated differently
+    // (if we wouldn't do that, we would cache users across requests, which may cause caching issues)
+    currentUserCache;
+    clientProjectCache;
+    constructor(options) {
+        this.options = options;
+        this.currentUserCache = new AsyncCache(async (key, isFirst) => {
+            if (isFirst) {
+                key.onChange((newValue, oldValue) => {
+                    if (JSON.stringify(newValue) === JSON.stringify(oldValue))
+                        return;
+                    runAsynchronously(this.currentUserCache.refresh(key));
+                });
+            }
+            const user = await this.getClientUserByToken(key);
+            return Result.or(user, null);
+        });
+        this.clientProjectCache = new AsyncValueCache(async () => {
+            return Result.orThrow(await this.getClientProject());
+        });
+    }
+    get projectId() {
+        return this.options.projectId;
+    }
+    getSessionCookieName() {
+        return getSessionCookieName(this.projectId);
+    }
+    getApiUrl() {
+        return this.options.baseUrl + "/api/v1";
+    }
+    async refreshUser(tokenStore) {
+        await this.currentUserCache.refresh(tokenStore);
+    }
+    async refreshProject() {
+        await this.clientProjectCache.refresh();
+    }
+    async refreshAccessToken(tokenStore) {
+        if (!('publishableClientKey' in this.options)) {
+            // TODO fix
+            throw new Error("Admin session token is currently not supported for fetching new access token");
+        }
+        const refreshToken = (await tokenStore.getOrWait()).refreshToken;
+        if (!refreshToken) {
+            tokenStore.set({
+                accessToken: null,
+                refreshToken: null,
+            });
+            return;
+        }
+        const as = {
+            issuer: this.options.baseUrl,
+            algorithm: 'oauth2',
+            token_endpoint: this.getApiUrl() + '/auth/token',
+        };
+        const client = {
+            client_id: this.projectId,
+            client_secret: this.options.publishableClientKey,
+            token_endpoint_auth_method: 'client_secret_basic',
+        };
+        const response = await oauth.refreshTokenGrantRequest(as, client, refreshToken);
+        if (!response.ok) {
+            const error = await response.text();
+            let errorJsonResult = parseJson(error);
+            if (response.status === 401
+                && errorJsonResult.status === "ok"
+                && errorJsonResult.data
+                && errorJsonResult.data.error_code === GrantInvalidErrorCode) {
+                return tokenStore.set({
+                    accessToken: null,
+                    refreshToken: null,
+                });
+            }
+            throw new Error(`Failed to send refresh token request: ${response.status} ${error}`);
+        }
+        let challenges;
+        if ((challenges = oauth.parseWwwAuthenticateChallenges(response))) {
+            for (const challenge of challenges) {
+                console.error('WWW-Authenticate Challenge', challenge);
+            }
+            throw new Error(); // Handle WWW-Authenticate Challenges as needed
+        }
+        const result = await oauth.processRefreshTokenResponse(as, client, response);
+        if (oauth.isOAuth2Error(result)) {
+            console.error('Error Response', result);
+            throw new Error(); // Handle OAuth 2.0 response body error
+        }
+        tokenStore.update(old => ({
+            accessToken: result.access_token ?? null,
+            refreshToken: result.refresh_token ?? old?.refreshToken ?? null,
+        }));
+    }
+    async sendClientRequest(path, requestOptions, tokenStoreOrNull) {
+        const tokenStore = tokenStoreOrNull ?? new AsyncStore({
+            accessToken: null,
+            refreshToken: null,
+        });
+        return await Result.orThrowAsync(Result.retry(() => this.sendClientRequestInner(path, requestOptions, tokenStore), 5, { exponentialDelayBase: 1000 }));
+    }
+    async sendClientRequestAndCatchKnownError(path, requestOptions, tokenStoreOrNull, errorCodes) {
+        try {
+            return Result.ok(await this.sendClientRequest(path, requestOptions, tokenStoreOrNull));
+        }
+        catch (e) {
+            if (e instanceof KnownError && errorCodes.includes(e.errorCode)) {
+                return Result.error(e.errorCode);
+            }
+            throw e;
+        }
+    }
+    async sendClientRequestInner(path, options, 
+    /**
+     * This object will be modified for future retries, so it should be passed by reference.
+     */
+    tokenStore) {
+        let tokenObj = await tokenStore.getOrWait();
+        if (!tokenObj.accessToken && tokenObj.refreshToken) {
+            await this.refreshAccessToken(tokenStore);
+            tokenObj = await tokenStore.getOrWait();
+        }
+        const url = this.getApiUrl() + path;
+        const params = {
+            ...options,
+            headers: {
+                ...tokenObj.accessToken ? {
+                    "authorization": "StackSession " + tokenObj.accessToken,
+                } : {},
+                "x-stack-project-id": this.projectId,
+                ...'publishableClientKey' in this.options ? {
+                    "x-stack-publishable-client-key": this.options.publishableClientKey,
+                } : {},
+                ...'internalAdminAccessToken' in this.options ? {
+                    "x-stack-admin-access-token": this.options.internalAdminAccessToken,
+                } : {},
+                ...options.headers,
+            },
+        };
+        const res = await fetch(url, params);
+        typedAssign(res, {
+            usedTokens: tokenObj,
+        });
+        if (res.ok) {
+            return Result.ok(res);
+        }
+        else {
+            const error = await res.text();
+            let errorJsonResult = parseJson(error);
+            if (res.status === 401
+                && errorJsonResult.status === "ok"
+                && errorJsonResult.data
+                && errorJsonResult.data.error_code === AccessTokenExpiredErrorCode) {
+                tokenStore.set({
+                    accessToken: null,
+                    refreshToken: tokenObj.refreshToken,
+                });
+                return Result.error(new Error("Access token expired"));
+            }
+            if (res.status >= 400 && res.status <= 599
+                && errorJsonResult.status === "ok"
+                && errorJsonResult.data
+                && KnownErrorCodes.includes(errorJsonResult.data.error_code)) {
+                throw new KnownError(errorJsonResult.data.error_code);
+            }
+            // Do not retry, throw error instead of returning one
+            throw new Error(`Failed to send request to ${url}: ${res.status} ${error}`);
+        }
+    }
+    async sendForgotPasswordEmail(email, redirectUrl) {
+        const res = await this.sendClientRequestAndCatchKnownError("/auth/forgot-password", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                email,
+                redirectUrl,
+            }),
+        }, null, PasswordResetLinkErrorCodes);
+        if (res.status === "error") {
+            return res.error;
+        }
+    }
+    async resetPassword(options) {
+        const res = await this.sendClientRequestAndCatchKnownError("/auth/password-reset", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify(options),
+        }, null, PasswordResetLinkErrorCodes);
+        if (res.status === "error") {
+            return res.error;
+        }
+    }
+    async verifyPasswordResetCode(code) {
+        const res = await this.sendClientRequestAndCatchKnownError("/auth/password-reset", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                code,
+                onlyVerifyCode: true,
+            }),
+        }, null, PasswordResetLinkErrorCodes);
+        if (res.status === "error") {
+            return res.error;
+        }
+    }
+    async verifyEmail(code) {
+        const res = await this.sendClientRequestAndCatchKnownError("/auth/email-verification", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                code,
+            }),
+        }, null, EmailVerificationLinkErrorCodes);
+        if (res.status === "error") {
+            return res.error;
+        }
+    }
+    async signInWithCredential(email, password, tokenStore) {
+        const res = await this.sendClientRequestAndCatchKnownError("/auth/signin", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                email,
+                password,
+            }),
+        }, tokenStore, SignInErrorCodes);
+        if (res.status === "error") {
+            return res.error;
+        }
+        const result = await res.data.json();
+        tokenStore.set({
+            accessToken: result.access_token,
+            refreshToken: result.refresh_token,
+        });
+        await this.refreshUser(tokenStore);
+    }
+    async signUpWithCredential(email, password, emailVerificationRedirectUrl, tokenStore) {
+        const res = await this.sendClientRequestAndCatchKnownError("/auth/signup", {
+            headers: {
+                "Content-Type": "application/json"
+            },
+            method: "POST",
+            body: JSON.stringify({
+                email,
+                password,
+                emailVerificationRedirectUrl,
+            }),
+        }, tokenStore, SignUpErrorCodes);
+        if (res.status === "error") {
+            return res.error;
+        }
+        const result = await res.data.json();
+        tokenStore.set({
+            accessToken: result.access_token,
+            refreshToken: result.refresh_token,
+        });
+        await this.refreshUser(tokenStore);
+    }
+    async getOauthUrl(provider, redirectUrl, codeChallenge, state) {
+        const updatedRedirectUrl = new URL(redirectUrl);
+        for (const key of ["code", "state"]) {
+            if (updatedRedirectUrl.searchParams.has(key)) {
+                console.warn("Redirect URL already contains " + key + " parameter, removing it as it will be overwritten by the OAuth callback");
+            }
+            updatedRedirectUrl.searchParams.delete(key);
+        }
+        if (!('publishableClientKey' in this.options)) {
+            // TODO fix
+            throw new Error("Admin session token is currently not supported for Oauth");
+        }
+        const url = new URL(this.getApiUrl() + "/auth/authorize/" + provider.toLowerCase());
+        url.searchParams.set("client_id", this.projectId);
+        url.searchParams.set("client_secret", this.options.publishableClientKey);
+        url.searchParams.set("redirect_uri", updatedRedirectUrl.toString());
+        url.searchParams.set("scope", "openid");
+        url.searchParams.set("state", state);
+        url.searchParams.set("grant_type", "authorization_code");
+        url.searchParams.set("code_challenge", codeChallenge);
+        url.searchParams.set("code_challenge_method", "S256");
+        url.searchParams.set("response_type", "code");
+        return url.toString();
+    }
+    async callOauthCallback(oauthParams, redirectUri, codeVerifier, state, tokenStore) {
+        if (!('publishableClientKey' in this.options)) {
+            // TODO fix
+            throw new Error("Admin session token is currently not supported for Oauth");
+        }
+        const as = {
+            issuer: this.options.baseUrl,
+            algorithm: 'oauth2',
+            token_endpoint: this.getApiUrl() + '/auth/token',
+        };
+        const client = {
+            client_id: this.projectId,
+            client_secret: this.options.publishableClientKey,
+            token_endpoint_auth_method: 'client_secret_basic',
+        };
+        const params = oauth.validateAuthResponse(as, client, oauthParams, state);
+        if (oauth.isOAuth2Error(params)) {
+            console.error('Error validating OAuth response', params);
+            throw new Error("Error validating OAuth response"); // Handle OAuth 2.0 redirect error
+        }
+        const response = await oauth.authorizationCodeGrantRequest(as, client, params, redirectUri, codeVerifier);
+        let challenges;
+        if ((challenges = oauth.parseWwwAuthenticateChallenges(response))) {
+            for (const challenge of challenges) {
+                console.error('WWW-Authenticate Challenge', challenge);
+            }
+            throw new Error(); // Handle WWW-Authenticate Challenges as needed
+        }
+        const result = await oauth.processAuthorizationCodeOAuth2Response(as, client, response);
+        if (oauth.isOAuth2Error(result)) {
+            console.error('Error Response', result);
+            throw new Error(); // Handle OAuth 2.0 response body error
+        }
+        tokenStore.update(old => ({
+            accessToken: result.access_token ?? null,
+            refreshToken: result.refresh_token ?? old?.refreshToken ?? null,
+        }));
+        await this.refreshUser(tokenStore);
+    }
+    async signOut(tokenStore) {
+        const tokenObj = await tokenStore.getOrWait();
+        const res = await this.sendClientRequest("/auth/signout", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                refreshToken: tokenObj.refreshToken ?? "",
+            }),
+        }, tokenStore);
+        await res.json();
+        tokenStore.set({
+            accessToken: null,
+            refreshToken: null,
+        });
+        await this.refreshUser(tokenStore);
+    }
+    async getClientUserByToken(tokenStore) {
+        const response = await this.sendClientRequest("/current-user", {}, tokenStore);
+        const user = await response.json();
+        if (!user)
+            return Result.error(new Error("Failed to get user"));
+        return Result.ok(user);
+    }
+    async getClientProject() {
+        const response = await this.sendClientRequest("/projects/" + this.options.projectId, {}, null);
+        const project = await response.json();
+        if (!project)
+            return Result.error(new Error("Failed to get project"));
+        return Result.ok(project);
+    }
+    async setClientUserCustomizableData(update, tokenStore) {
+        await this.sendClientRequest("/current-user", {
+            method: "PUT",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(update),
+        }, tokenStore);
+        await this.refreshUser(tokenStore);
+    }
+    async listProjects(tokenStore) {
+        const response = await this.sendClientRequest("/projects", {}, tokenStore);
+        if (!response.ok) {
+            throw new Error("Failed to list projects: " + response.status + " " + (await response.text()));
+        }
+        const json = await response.json();
+        return json;
+    }
+    async createProject(project, tokenStore) {
+        const fetchResponse = await this.sendClientRequest("/projects", {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(project),
+        }, tokenStore);
+        if (!fetchResponse.ok) {
+            throw new Error("Failed to create project: " + fetchResponse.status + " " + (await fetchResponse.text()));
+        }
+        const json = await fetchResponse.json();
+        return json;
+    }
+}
+export function getProductionModeErrors(project) {
+    const errors = [];
+    for (const { domain, handlerPath } of project.evaluatedConfig.domains) {
+        // TODO: check if handlerPath is valid
+        const fixUrlRelative = `/projects/${encodeURIComponent(project.id)}/auth/urls-and-callbacks`;
+        let url;
+        try {
+            url = new URL(domain);
+        }
+        catch (e) {
+            errors.push({
+                errorMessage: "Domain should be a valid URL: " + domain,
+                fixUrlRelative,
+            });
+            continue;
+        }
+        if (url.hostname === "localhost") {
+            errors.push({
+                errorMessage: "Domain should not be localhost: " + domain,
+                fixUrlRelative,
+            });
+        }
+        else if (!url.hostname.includes(".") || url.hostname.match(/\d+(\.\d+)*/)) {
+            errors.push({
+                errorMessage: "Not a valid domain" + domain,
+                fixUrlRelative,
+            });
+        }
+        else if (url.protocol !== "https:") {
+            errors.push({
+                errorMessage: "Auth callback prefix should be HTTPS: " + domain,
+                fixUrlRelative,
+            });
+        }
+    }
+    return errors;
+}

package/dist/interface/serverInterface.d.ts

@@ -0,0 +1,33 @@
+import { ClientInterfaceOptions, UserCustomizableJson, UserJson, TokenStore, StackClientInterface } from "./clientInterface";
+import { Result } from "../utils/results";
+import { ReadonlyJson } from "../utils/types";
+import { AsyncCache } from "../utils/caches";
+export type ServerUserJson = UserJson & {
+    readonly serverMetadata: ReadonlyJson;
+};
+export type ServerUserCustomizableJson = UserCustomizableJson & {
+    readonly serverMetadata: ReadonlyJson;
+    readonly primaryEmail: string | null;
+    readonly primaryEmailVerified: boolean;
+};
+export type ServerAuthApplicationOptions = (ClientInterfaceOptions & ({
+    readonly secretServerKey: string;
+} | {
+    readonly internalAdminAccessToken: string;
+}));
+export declare class StackServerInterface extends StackClientInterface {
+    options: ServerAuthApplicationOptions;
+    readonly currentServerUserCache: AsyncCache<TokenStore, ServerUserJson | null>;
+    constructor(options: ServerAuthApplicationOptions);
+    refreshUser(tokenStore: TokenStore): Promise<void>;
+    protected sendServerRequest(path: string, options: RequestInit, tokenStore: TokenStore | null): Promise<Response & {
+        usedTokens: Readonly<{
+            refreshToken: string | null;
+            accessToken: string | null;
+        }>;
+    }>;
+    getServerUserByToken(tokenStore: TokenStore): Promise<Result<ServerUserJson>>;
+    listUsers(): Promise<ServerUserJson[]>;
+    setServerUserCustomizableData(userId: string, update: Partial<ServerUserCustomizableJson>): Promise<void>;
+    deleteServerUser(userId: string): Promise<void>;
+}

package/dist/interface/serverInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverInterface.d.ts","sourceRoot":"","sources":["../../src/interface/serverInterface.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,oBAAoB,EACpB,QAAQ,EACR,UAAU,EACV,oBAAoB,EACrB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC1C,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAG7C,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG;IACtC,QAAQ,CAAC,cAAc,EAAE,YAAY,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,0BAA0B,GAAG,oBAAoB,GAAG;IAC9D,QAAQ,CAAC,cAAc,EAAE,YAAY,CAAC;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,QAAQ,CAAC,oBAAoB,EAAE,OAAO,CAAC;CACxC,CAAA;AAGD,MAAM,MAAM,4BAA4B,GAAG,CACvC,sBAAsB,GACtB,CACE;IACA,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC,GACC;IACA,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;CAC3C,CACF,CACF,CAAC;AAGF,qBAAa,oBAAqB,SAAQ,oBAAoB;IAKhC,OAAO,EAAE,4BAA4B;IAFjE,SAAgB,sBAAsB,EAAE,UAAU,CAAC,UAAU,EAAE,cAAc,GAAG,IAAI,CAAC,CAAC;gBAE1D,OAAO,EAAE,4BAA4B;IAelD,WAAW,CAAC,UAAU,EAAE,UAAU;cAOjC,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,GAAG,IAAI;;;;;;IAc7F,oBAAoB,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAW7E,SAAS,IAAI,OAAO,CAAC,cAAc,EAAE,CAAC;IAKtC,6BAA6B,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,0BAA0B,CAAC;IAczF,gBAAgB,CAAC,MAAM,EAAE,MAAM;CAatC"}

package/dist/interface/serverInterface.js

@@ -0,0 +1,70 @@
+import { StackClientInterface, } from "./clientInterface";
+import { Result } from "../utils/results";
+import { AsyncCache } from "../utils/caches";
+import { runAsynchronously } from "../utils/promises";
+export class StackServerInterface extends StackClientInterface {
+    options;
+    // note that we intentionally use TokenStore (a reference type) as a key, as different token stores with the same tokens should be treated differently
+    // (if we wouldn't do that, we would cache users across requests, which may cause caching issues)
+    currentServerUserCache;
+    constructor(options) {
+        super(options);
+        this.options = options;
+        this.currentServerUserCache = new AsyncCache(async (key, isFirst) => {
+            if (isFirst) {
+                key.onChange((newValue, oldValue) => {
+                    if (JSON.stringify(newValue) === JSON.stringify(oldValue))
+                        return;
+                    runAsynchronously(this.currentServerUserCache.refresh(key));
+                });
+            }
+            const user = await this.getServerUserByToken(key);
+            return Result.or(user, null);
+        });
+        // TODO override the client user cache to use the server user cache, so we save some requests
+    }
+    async refreshUser(tokenStore) {
+        await Promise.all([
+            super.refreshUser(tokenStore),
+            this.currentServerUserCache.refresh(tokenStore),
+        ]);
+    }
+    async sendServerRequest(path, options, tokenStore) {
+        return await this.sendClientRequest(path, {
+            ...options,
+            headers: {
+                "x-stack-secret-server-key": "secretServerKey" in this.options ? this.options.secretServerKey : "",
+                ...options.headers,
+            },
+        }, tokenStore);
+    }
+    async getServerUserByToken(tokenStore) {
+        const response = await this.sendServerRequest("/current-user?server=true", {}, tokenStore);
+        const user = await response.json();
+        if (!user)
+            return Result.error(new Error("Failed to get user"));
+        return Result.ok(user);
+    }
+    async listUsers() {
+        const response = await this.sendServerRequest("/users?server=true", {}, null);
+        return await response.json();
+    }
+    async setServerUserCustomizableData(userId, update) {
+        await this.sendServerRequest(`/users/${userId}?server=true`, {
+            method: "PUT",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify(update),
+        }, null);
+    }
+    async deleteServerUser(userId) {
+        await this.sendServerRequest(`/users/${userId}?server=true`, {
+            method: "DELETE",
+            headers: {
+                "content-type": "application/json",
+            },
+            body: JSON.stringify({}),
+        }, null);
+    }
+}

package/dist/utils/arrays.d.ts

@@ -0,0 +1,10 @@
+export declare function typedIncludes<T extends readonly any[]>(arr: T, item: unknown): item is T[number];
+export declare function enumerate<T extends readonly any[]>(arr: T): [number, T[number]][];
+export declare function isShallowEqual(a: readonly any[], b: readonly any[]): boolean;
+export declare function groupBy<T extends readonly any[], K>(arr: T, key: (item: T[number]) => K): Map<K, T[number][]>;
+export declare function range(endExclusive: number): number[];
+export declare function range(startInclusive: number, endExclusive: number): number[];
+export declare function range(startInclusive: number, endExclusive: number, step: number): number[];
+export declare function rotateLeft(arr: readonly any[], n: number): any[];
+export declare function rotateRight(arr: readonly any[], n: number): any[];
+export declare function shuffle<T>(arr: readonly T[]): T[];

package/dist/utils/arrays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrays.d.ts","sourceRoot":"","sources":["../../src/utils/arrays.tsx"],"names":[],"mappings":"AAEA,wBAAgB,aAAa,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,CAAC,CAAC,MAAM,CAAC,CAEhG;AAED,wBAAgB,SAAS,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,EAAE,CAEjF;AAED,wBAAgB,cAAc,CAAC,CAAC,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,SAAS,GAAG,EAAE,GAAG,OAAO,CAM5E;AAED,wBAAgB,OAAO,CAAC,CAAC,SAAS,SAAS,GAAG,EAAE,EAAE,CAAC,EACjD,GAAG,EAAE,CAAC,EACN,GAAG,EAAE,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,GAC1B,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAQrB;AAGD,wBAAgB,KAAK,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AACtD,wBAAgB,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAC9E,wBAAgB,KAAK,CAAC,cAAc,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;AAgB5F,wBAAgB,UAAU,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAGhE;AAED,wBAAgB,WAAW,CAAC,GAAG,EAAE,SAAS,GAAG,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,GAAG,EAAE,CAEjE;AAGD,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,EAAE,CAOjD"}

package/dist/utils/arrays.js

@@ -0,0 +1,54 @@
+import { remainder } from "./math";
+export function typedIncludes(arr, item) {
+    return arr.includes(item);
+}
+export function enumerate(arr) {
+    return arr.map((item, index) => [index, item]);
+}
+export function isShallowEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (a[i] !== b[i])
+            return false;
+    }
+    return true;
+}
+export function groupBy(arr, key) {
+    const result = new Map;
+    for (const item of arr) {
+        const k = key(item);
+        if (result.get(k) === undefined)
+            result.set(k, []);
+        result.get(k).push(item);
+    }
+    return result;
+}
+export function range(startInclusive, endExclusive, step) {
+    if (endExclusive === undefined) {
+        endExclusive = startInclusive;
+        startInclusive = 0;
+    }
+    if (step === undefined)
+        step = 1;
+    const result = [];
+    for (let i = startInclusive; step > 0 ? (i < endExclusive) : (i > endExclusive); i += step) {
+        result.push(i);
+    }
+    return result;
+}
+export function rotateLeft(arr, n) {
+    const index = remainder(n, arr.length);
+    return [...arr.slice(n), arr.slice(0, n)];
+}
+export function rotateRight(arr, n) {
+    return rotateLeft(arr, -n);
+}
+export function shuffle(arr) {
+    const result = [...arr];
+    for (let i = result.length - 1; i > 0; i--) {
+        const j = Math.floor(Math.random() * (i + 1));
+        [result[i], result[j]] = [result[j], result[i]];
+    }
+    return result;
+}