roblox-deeplink-parser 0.1.23 → 0.1.25

package/dist/AuthedProtocolParser.d.ts

@@ -0,0 +1,86 @@
+type AuthedProtocolUrls<T> = {
+	robloxPlayerProtocol: T;
+	robloxStudioProtocol: T;
+	robloxStudioAuthProtocol: T;
+	placeLauncherUrl: string;
+};
+type AuthedProtocolParserConstructorProps<T extends string> = {
+	urls?: Partial<AuthedProtocolUrls<T>>;
+};
+type AuthedLaunchMode = "edit" | "plugin" | "play" | "build" | "app" | "asset";
+type AuthLaunchExp = "InApp" | "PreferInApp" | "InBrowser";
+type AuthedStudioTask = "EditFile" | "EditPlace" | "EditPlaceRevision" | "StartClient" | "StartTeamTest" | "InstallPlugin" | "TryAsset" | "RemoteDebug" | "StartServer";
+type AuthedDistributorType = "Global" | "ChinaJoinVenture";
+type AuthedOtherParams = {
+	browsertrackerid?: number;
+	robloxLocale?: string;
+	gameLocale?: string;
+	channel?: string;
+	LaunchExp?: AuthLaunchExp;
+	avatar?: string;
+	assetid?: number;
+	pluginid?: number;
+	placeid?: number;
+	universeid?: number;
+	script?: string;
+	placelauncherurl?: string;
+	task?: AuthedStudioTask;
+	traceId?: string;
+	userId?: number;
+	browser?: string;
+	distributorType?: AuthedDistributorType;
+	[key: string]: string | number | undefined;
+};
+type BuildAuthedProtocolUrlParameters<T extends string> = {
+	type: T;
+	launchMode?: AuthedLaunchMode;
+	gameInfo?: string;
+	launchTime?: string;
+	baseUrl?: string;
+	otherParams?: AuthedOtherParams;
+	state?: string;
+	code?: string;
+};
+type BuildAuthedPlaceLauncherRequest = "RequestGame" | "RequestCloudEdit" | "RequestGameJob" | "RequestFollowUser" | "RequestPrivateGame" | "RequestPlayTogetherGame" | "RequestGameApp" | "RequestInvalid" | "RequestPlayWithParty" | "CheckGameJobStatus" | "RequestReservedGame" | "RequestCrossExpVoice";
+type AuthedPrivateGameMode = "ReservedServer";
+type BuildAuthedPlaceLauncherURLParameters<T extends string> = {
+	request: BuildAuthedPlaceLauncherRequest;
+	placeId?: number;
+	jobId?: string;
+	gameId?: string;
+	gender?: string;
+	genderId?: number;
+	accessCode?: string;
+	linkCode?: string;
+	launchData?: string;
+	privateGameMode?: AuthedPrivateGameMode;
+	teleportType?: string;
+	reservedServerAccessCode?: string;
+	referralPage?: string;
+	referredByPlayerId?: number;
+	conversationId?: number;
+	isPartyLeader?: boolean;
+	isTeleport?: boolean;
+	partyGuid?: string;
+	isPlayTogetherGame?: boolean;
+	joinAttemptId?: string;
+	joinAttemptOrigin?: T;
+	callId?: string;
+	browserTrackerId?: number;
+	eventId?: string;
+	isolationContext?: string;
+	gameJoinContext?: string;
+	userId?: number;
+};
+declare class AuthedProtocolParser<
+	T extends string,
+	U extends string
+> {
+	_urls: AuthedProtocolUrls<T>;
+	constructor(props?: AuthedProtocolParserConstructorProps<T>);
+	buildAuthedProtocolUrl(request: BuildAuthedProtocolUrlParameters<T>): string;
+	buildAuthedPlaceLauncherUrl(request: BuildAuthedPlaceLauncherURLParameters<U>): string;
+	parseAuthedProtocolUrl(url: string): BuildAuthedProtocolUrlParameters<T> | null;
+	parseAuthedPlaceLauncherUrl(urlStr: string): BuildAuthedPlaceLauncherURLParameters<U> | null;
+}
+export { AuthedProtocolParser as default, BuildAuthedProtocolUrlParameters, BuildAuthedPlaceLauncherURLParameters, BuildAuthedPlaceLauncherRequest, AuthedStudioTask, AuthedProtocolUrls, AuthedProtocolParserConstructorProps, AuthedPrivateGameMode, AuthedOtherParams, AuthedLaunchMode, AuthedDistributorType, AuthLaunchExp };

package/dist/AuthedProtocolParser.js

@@ -0,0 +1,147 @@
+import {
+  DEFAULT_PLACELAUNCHER_URL,
+  DEFAULT_ROBLOX_PLAYER_AUTHED_PROTOCOL,
+  DEFAULT_ROBLOX_STUDIO_AUTHED_PROTOCOL,
+  DEFAULT_ROBLOX_STUDIO_AUTH_AUTHED_PROTOCOL
+} from "./shared/chunk-pqjz2eep.js";
+
+// src/AuthedProtocolParser.ts
+class AuthedProtocolParser {
+  _urls = {
+    robloxPlayerProtocol: DEFAULT_ROBLOX_PLAYER_AUTHED_PROTOCOL,
+    robloxStudioProtocol: DEFAULT_ROBLOX_STUDIO_AUTHED_PROTOCOL,
+    robloxStudioAuthProtocol: DEFAULT_ROBLOX_STUDIO_AUTH_AUTHED_PROTOCOL,
+    placeLauncherUrl: DEFAULT_PLACELAUNCHER_URL
+  };
+  constructor(props) {
+    if (props?.urls) {
+      if (props.urls.robloxPlayerProtocol) {
+        this._urls.robloxPlayerProtocol = props.urls.robloxPlayerProtocol;
+      }
+      if (props.urls.robloxStudioProtocol) {
+        this._urls.robloxStudioProtocol = props.urls.robloxStudioProtocol;
+      }
+      if (props.urls.robloxStudioAuthProtocol) {
+        this._urls.robloxStudioAuthProtocol = props.urls.robloxStudioAuthProtocol;
+      }
+      if (props.urls.placeLauncherUrl) {
+        this._urls.placeLauncherUrl = props.urls.placeLauncherUrl;
+      }
+    }
+  }
+  buildAuthedProtocolUrl(request) {
+    if (request.type === this._urls.robloxStudioAuthProtocol && request.state && request.code) {
+      return `${this._urls.robloxStudioAuthProtocol}://?state=${request.state}&code=${request.code}`;
+    }
+    const params = ["1"];
+    if (request.launchMode)
+      params.push(`launchmode:${request.launchMode}`);
+    if (request.gameInfo)
+      params.push(`gameinfo:${request.gameInfo}`);
+    if (request.launchTime)
+      params.push(`launchtime:${request.launchTime}`);
+    if (request.baseUrl)
+      params.push(`baseUrl:${request.baseUrl}`);
+    if (request.otherParams) {
+      for (const key in request.otherParams) {
+        const value = request.otherParams[key];
+        if (key === value) {
+          params.push(key);
+        } else if (value !== undefined && value !== null) {
+          params.push(`${key}:${encodeURIComponent(value)}`);
+        }
+      }
+    }
+    return `${request.type}:${params.join("+")}`;
+  }
+  buildAuthedPlaceLauncherUrl(request) {
+    const url = new URL(this._urls.placeLauncherUrl);
+    const stringifiedParameters = {};
+    for (const key in request) {
+      const value = request[key];
+      if (value !== undefined && value !== null) {
+        stringifiedParameters[key] = String(value);
+      }
+    }
+    url.search = new URLSearchParams(stringifiedParameters).toString();
+    return url.toString();
+  }
+  parseAuthedProtocolUrl(url) {
+    if (url.startsWith(`${this._urls.robloxStudioAuthProtocol}:`)) {
+      const urlObj = new URL(url);
+      return {
+        type: this._urls.robloxStudioAuthProtocol,
+        state: urlObj.searchParams.get("state") ?? undefined,
+        code: urlObj.searchParams.get("code") ?? undefined
+      };
+    }
+    const isPlayer = url.startsWith(`${this._urls.robloxPlayerProtocol}:1`);
+    const isStudio = url.startsWith(`${this._urls.robloxStudioProtocol}:1`);
+    if (!isPlayer && !isStudio) {
+      return null;
+    }
+    const split = url.split("+");
+    const type = isPlayer ? this._urls.robloxPlayerProtocol : this._urls.robloxStudioProtocol;
+    const params = {
+      type
+    };
+    for (let i = 1;i < split.length; i++) {
+      const item = split[i];
+      const [key, value] = item.split(":");
+      if (!value)
+        continue;
+      switch (key.toLowerCase()) {
+        case "launchmode": {
+          params.launchMode = value;
+          break;
+        }
+        case "gameinfo": {
+          params.gameInfo = value;
+          break;
+        }
+        case "launchtime": {
+          params.launchTime = value;
+          break;
+        }
+        default: {
+          params.otherParams ??= {};
+          params.otherParams[key] = decodeURIComponent(value);
+        }
+      }
+    }
+    return params;
+  }
+  parseAuthedPlaceLauncherUrl(urlStr) {
+    try {
+      const url = new URL(urlStr);
+      const request = url.searchParams.get("request");
+      if (!request)
+        return null;
+      const obj = {
+        request
+      };
+      for (const [key, value] of url.searchParams) {
+        let valueToSet;
+        if (value === "true") {
+          valueToSet = true;
+        } else if (value === "false") {
+          valueToSet = false;
+        } else {
+          const parsedNumber = Number(value);
+          if (!Number.isNaN(parsedNumber)) {
+            valueToSet = parsedNumber;
+          } else {
+            valueToSet = value;
+          }
+        }
+        obj[key] = valueToSet;
+      }
+      return obj;
+    } catch {
+      return null;
+    }
+  }
+}
+export {
+  AuthedProtocolParser as default
+};

package/dist/DeepLinkParser.d.ts

@@ -0,0 +1,82 @@
+type DeepLinkUrlQueryParameter<T extends string | number | symbol> = {
+	regex?: RegExp;
+	required?: boolean | string;
+} & ({
+	name: T;
+} | {
+	name: string;
+	mappedName: T;
+});
+type DeepLinkUrlPathParameter<T extends string | number | symbol> = {
+	name: T;
+};
+type DeepLinkUrl<T extends Record<string, unknown>> = {
+	regex: RegExp;
+	query?: DeepLinkUrlQueryParameter<keyof T>[];
+	path?: DeepLinkUrlPathParameter<keyof T>[];
+};
+type EmptyObj = {};
+type DeepLink<
+	T extends string,
+	U extends Record<string, unknown> = EmptyObj,
+	V extends Record<string, unknown> = EmptyObj,
+	W extends Record<string, unknown> = U
+> = {
+	name: T;
+	protocolUrls?: DeepLinkUrl<U>[];
+	websiteUrls?: DeepLinkUrl<V>[];
+	transformProtocolParams?: (params: U) => W | Promise<W | undefined>;
+	transformWebsiteParams?: (params: V, url: URL) => W | Promise<W | undefined>;
+	arbitaryParameters?: Record<string, boolean | "protocol" | "website" | undefined>;
+	toProtocolUrl?: ((params: W) => string) | string;
+	toWebsiteUrl?: ((params: W) => string) | string;
+};
+declare function getDeepLinks(getUniverseRootPlaceId: (universeId: number) => Promise<number | null>, getPlaceUniverseId: (placeId: number) => Promise<number | null>, robloxUrl: string): unknown;
+type ExtractParameterType<T> = T extends DeepLink<infer U, infer _V, infer _W, infer X> ? {
+	type: U;
+	params: X;
+} : never;
+declare class ParsedDeepLink<T extends DeepLink<string>> {
+	data: ExtractParameterType<T>;
+	private _deepLinkParser;
+	private _deepLink;
+	constructor(data: ExtractParameterType<T>, _deepLinkParser: DeepLinkParser);
+	toProtocolUrl(): string | null;
+	toWebsiteUrl(): string | null;
+	toAppsFlyerUrl(): string | null;
+}
+type DeepLinkParserUrls = {
+	appsFlyerBaseUrl: string;
+	robloxPlayerDeepLinkProtocol: string;
+	robloxUrl: string;
+	robloxApiDomain: string;
+};
+type DeepLinkParserFns = {
+	getPlaceUniverseId: (placeId: number) => Promise<number | null>;
+	getUniverseRootPlaceId: (placeId: number) => Promise<number | null>;
+};
+type DisallowedParams<T extends DeepLink<string, any, any, any>> = T extends DeepLink<infer K, any, any, infer P> ? Record<K, Array<keyof P>> : never;
+type DeepLinkParserConstructorProps<T extends DeepLink<string, any, any, any>> = {
+	urls?: Partial<DeepLinkParserUrls>;
+	fns?: Partial<DeepLinkParserFns>;
+	fetchFn?: typeof fetch;
+	disallowedParams?: DisallowedParams<T>;
+};
+declare class DeepLinkParser<T extends DeepLink<string, any, any, any> = ReturnType<typeof getDeepLinks>[number]> {
+	_urls: DeepLinkParserUrls;
+	private _fns;
+	private _fetchFn;
+	private _disallowedParams;
+	_deepLinks: T[];
+	constructor(data?: DeepLinkParserConstructorProps<T>);
+	createDeepLink<U extends T["name"]>(type: U, params: ExtractParameterType<Extract<T, {
+		name: U;
+	}>>["params"]): ParsedDeepLink<Extract<T, {
+		name: U;
+	}>> | null;
+	parseAppsFlyerLink(url: string): Promise<ParsedDeepLink<T> | null>;
+	parseWebsiteLink(url: string): Promise<ParsedDeepLink<T> | null>;
+	parseProtocolLink(url: string): Promise<ParsedDeepLink<T> | null>;
+	parseLink(url: string): Promise<ParsedDeepLink<T> | null>;
+}
+export { DeepLinkParser as default, DisallowedParams, DeepLinkParserUrls, DeepLinkParserFns, DeepLinkParserConstructorProps };