@sleeperhq/mini-core 1.0.3 → 1.0.5

package/bin/build_mini.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process');
+const os = require('os');
+const path = require('path');
+const readLine = require('readline');
+const fs = require('fs');
+
+const isWindows = os.platform() === 'win32';
+
+const getCommands = (projectName) => {
+  // Pathing
+  const distPath = path.join('dist', projectName);
+  const zipFilePath = `${distPath}.zip`;
+  const assetsDestPath = {
+    ios: path.join(distPath, 'ios'),
+    android: path.join(distPath, 'android'),
+  };
+  const bundleOutputPath = {
+    ios: path.join(assetsDestPath["ios"], 'index.bundle'),
+    android: path.join(assetsDestPath["android"], 'index.bundle'),
+  };
+  const sourcemapOutputPath = {
+    ios: path.join(assetsDestPath["ios"], 'index.bundle.map'),
+    android: path.join(assetsDestPath["android"], 'index.bundle.map'),
+  };
+  const reactNativeCliPath = path.join('node_modules', 'react-native', 'cli.js');
+  
+  // Commands
+  const removeDir = (isWindows ? 'rmdir /s /q ' : 'rm -rf ');
+  // TODO (Windows): double check this zip command.
+  const zip = isWindows ?
+    `powershell Compress-Archive -Path "${distPath}" -DestinationPath "${zipFilePath}"` :
+    `cd dist && zip -r "${projectName}.zip" * && cd -`;
+  const openFile = isWindows ? `start .` : `open .`;
+  const cleanIndex = `${removeDir} "${bundleOutputPath["ios"]}" "${bundleOutputPath["android"]}" "${sourcemapOutputPath["ios"]}" "${sourcemapOutputPath["android"]}"`;
+  const cleanAll = `${removeDir} dist node_modules`;
+  const cleanBuild = `${removeDir} "${distPath}" "${assetsDestPath["ios"]}" "${assetsDestPath["android"]}"`;
+  const install = `yarn install && cd ios && pod install && cd -`;
+
+  const getBundleCommand = (platform) => {
+    return `node "${reactNativeCliPath}" webpack-bundle \
+    --entry-file index.tsx \
+    --platform ${platform} \
+    --dev false \
+    --reset-cache \
+    --bundle-output "${bundleOutputPath[platform]}" \
+    --sourcemap-output "${sourcemapOutputPath[platform]}" \
+    --minify false \
+    --assets-dest "${assetsDestPath[platform]}"`;
+  };
+  
+  // Exposed
+  return {
+    bundleIOS: getBundleCommand('ios'),
+    bundleAndroid: getBundleCommand('android'),
+    zip,
+    openFile,
+    cleanIndex,
+    cleanAll,
+    cleanBuild,
+    zipFilePath,
+    install,
+  }
+}
+
+const spawnProcess = (command, errorMessage) => {
+  return new Promise((resolve) => {
+    const child = isWindows
+      ? spawn('cmd.exe', ['/c', command])
+      : spawn(command, { shell: true });
+
+    child.stdout.on('data', (data) => {
+      process.stdout.write(data); // output the data to the console
+    });
+
+    child.stderr.on('data', (data) => {
+      process.stderr.write(data); // output the error to the console
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        printError(errorMessage || `command exited with non-zero code: ${code}`);
+        process.exit(1);
+      }
+      resolve();
+    });
+  });
+};
+
+const printError = (error) => {
+  console.error("\n\033[91m" + error + "\033[0m");
+};
+
+const printInfo = (message) => {
+  console.log("\n\033[96m" + message + "\033[0m");
+};
+
+const printComplete = (message) => {
+  console.log("\033[92m" + message + "\033[0m");
+};
+
+const getInput = (message, fallback) => {
+  const interface = readLine.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  
+  return new Promise((resolve) => {
+    interface.question("\n\033[96m[current: " + fallback + "]\033[0m " + message, (name) => {
+      const result = name.trim();
+      if (!result) {
+        resolve(fallback);
+      }
+      resolve(name.trim());
+    });
+  });
+};
+
+const getProjectName = () => {
+  const appJsonPath = 'app.json';
+  const appJson = JSON.parse(fs.readFileSync(appJsonPath));
+  return appJson.name;
+}
+
+const setProjectName = (name) => {
+  const podfilePath = path.join('ios', 'Podfile');
+  const podfileString = fs.readFileSync(podfilePath).toString();
+  const newPodfileString = podfileString.replace(/target '.*'/, `target '${name}'`);
+  fs.writeFileSync(podfilePath, newPodfileString);
+}
+
+const validateProjectName = (name) => {
+  const regex = /^[a-zA-Z0-9_]+$/;
+  return regex.test(name);
+}
+
+const main = async () => {
+  // Enter project name.
+  const fallback = getProjectName();
+  const projectName = await getInput("Enter project name: ", fallback);
+  if (!validateProjectName(projectName)) {
+    printError("Invalid project name. Only alphanumeric characters and underscores are allowed.");
+    process.exit(1);
+  }
+  
+  if (projectName !== fallback) {
+    await spawnProcess(`yarn react-native-rename "${projectName}" --skipGitStatusCheck`, "rename command exited with non-zero code");
+    setProjectName(projectName);
+  }
+
+  const commands = getCommands(projectName);
+
+  // Clean build folders
+  await spawnProcess(commands.cleanAll, "clean command exited with non-zero code");
+
+  // Run yarn + pod install
+  await spawnProcess(commands.install, "clean command exited with non-zero code");
+
+  // Build iOS
+  printInfo("Building iOS...");
+  await spawnProcess(commands.bundleIOS, "webpack-bundle ios command exited with non-zero code");
+  printComplete("iOS build complete.");
+
+  // Build Android
+  printInfo("Building Android...");
+  await spawnProcess(commands.bundleAndroid, "webpack-bundle android command exited with non-zero code");
+  printComplete("Android build complete.");
+
+  // Create Zip Archive
+  printInfo("Creating zip archive...");
+  await spawnProcess(commands.cleanIndex, "clean command exited with non-zero code");
+  await spawnProcess(commands.zip, "zip command exited with non-zero code");
+  printComplete(`Zip archive created successfully at ${commands.zipFilePath}`);
+
+  // Clean build folders
+  await spawnProcess(commands.cleanBuild, "clean command exited with non-zero code");
+
+  // Open output folder
+  await spawnProcess(commands.openFile);
+  process.exit(0);
+};
+
+main();

package/declarations/button/index.d.ts

@@ -1,37 +1,37 @@
-/// <reference types="react" />
-import { GestureResponderEvent } from 'react-native';
-export interface ButtonProps {
-    height?: number;
-    gradient?: (string | number)[];
-    start?: {
-        x: number;
-        y: number;
-    };
-    end?: {
-        x: number;
-        y: number;
-    };
-    disable?: boolean;
-    onPress?: (event: GestureResponderEvent) => void;
-    text?: string;
-}
-declare const Button: {
-    (props: ButtonProps): JSX.Element;
-    defaultProps: {
-        height: number;
-        shadowHeight: number;
-        gradient: string[];
-        type: string;
-        size: string;
-        isForSmallScreen: boolean;
-        start: {
-            x: number;
-            y: number;
-        };
-        end: {
-            x: number;
-            y: number;
-        };
-    };
-};
-export default Button;
+/// <reference types="react" />
+import { GestureResponderEvent } from 'react-native';
+export interface ButtonProps {
+    height?: number;
+    gradient?: (string | number)[];
+    start?: {
+        x: number;
+        y: number;
+    };
+    end?: {
+        x: number;
+        y: number;
+    };
+    disable?: boolean;
+    onPress?: (event: GestureResponderEvent) => void;
+    text?: string;
+}
+declare const Button: {
+    (props: ButtonProps): JSX.Element;
+    defaultProps: {
+        height: number;
+        shadowHeight: number;
+        gradient: string[];
+        type: string;
+        size: string;
+        isForSmallScreen: boolean;
+        start: {
+            x: number;
+            y: number;
+        };
+        end: {
+            x: number;
+            y: number;
+        };
+    };
+};
+export default Button;

package/declarations/index.d.ts

@@ -1,3 +1,4 @@
-export * from './types';
-declare const _default: any;
-export default _default;
+export * from './types';
+export * from './sleeper_message';
+declare const _default: any;
+export default _default;

package/declarations/jersey/index.d.ts

@@ -1,9 +1,9 @@
-import { ColorValue, ViewStyle } from 'react-native';
-import SleeperJersey from 'components/ui/jersey';
-export interface JerseyProps {
-    style: ViewStyle;
-    sport: 'nfl' | 'nba' | 'cbb' | 'cfb' | 'mlb';
-    number: string;
-    fill: ColorValue;
-}
-export default SleeperJersey;
+import { ColorValue, ViewStyle } from 'react-native';
+import SleeperJersey from 'components/ui/jersey';
+export interface JerseyProps {
+    style: ViewStyle;
+    sport: 'nfl' | 'nba' | 'cbb' | 'cfb' | 'mlb';
+    number: string;
+    fill: ColorValue;
+}
+export default SleeperJersey;

package/declarations/sleeper_actions.d.ts

@@ -1,5 +1,5 @@
-import { NavigationType, NavigationTypeId } from './types';
-declare class SleeperActions {
-    navigate: (navType: NavigationType, navTypeId: NavigationTypeId) => void;
-}
-export default SleeperActions;
+import { NavigationType, NavigationTypeId } from './types';
+declare class SleeperActions {
+    navigate: (navType: NavigationType, navTypeId: NavigationTypeId) => void;
+}
+export default SleeperActions;

package/declarations/sleeper_context.d.ts

@@ -1,10 +1,15 @@
-import { User, Navigation, League } from './types';
-import SleeperActions from './sleeper_actions';
-declare class SleeperContext {
-    user: User;
-    navigation: Navigation;
-    league: League;
-    actions: SleeperActions;
-    constructor(user: User, navigation: Navigation, league: League);
-}
-export default SleeperContext;
+import { User, Navigation, League, LeaguesMap, RostersInLeagueMap, UserMap, MatchupsInLeagueMap } from './types';
+import SleeperActions from './sleeper_actions';
+declare class SleeperContext {
+    user: User;
+    navigation: Navigation;
+    league: League;
+    leaguesMap: LeaguesMap;
+    userLeagueList: string[];
+    rostersInLeagueMap: RostersInLeagueMap;
+    userMap: UserMap;
+    matchupsInLeagueMap: MatchupsInLeagueMap;
+    actions: SleeperActions;
+    constructor();
+}
+export default SleeperContext;

package/declarations/sleeper_message.d.ts

@@ -0,0 +1,7 @@
+type SocketMessage = {
+    _ip?: string;
+    _name?: string;
+    _webpack?: string;
+    _contextGet?: string;
+};
+export default SocketMessage;

package/declarations/text/index.d.ts

@@ -1,13 +1,13 @@
-import { PureComponent } from 'react';
-import { TextProps } from 'react-native';
-declare type Props = {
-    color?: string;
-    inheritStyles?: boolean;
-    screenShrink?: number;
-} & TextProps;
-export declare type AppTextProps = Props;
-export default class AppText extends PureComponent<Props> {
-    private getStyles;
-    render(): JSX.Element;
-}
-export {};
+import { PureComponent } from 'react';
+import { TextProps } from 'react-native';
+type Props = {
+    color?: string;
+    inheritStyles?: boolean;
+    screenShrink?: number;
+} & TextProps;
+export type AppTextProps = Props;
+export default class AppText extends PureComponent<Props> {
+    private getStyles;
+    render(): JSX.Element;
+}
+export {};

package/declarations/types/index.d.ts

@@ -1,9 +1,20 @@
-import { NAVIGATION_ID, NAVIGATION_TYPE } from './redux/native_nav/constants.d';
-export declare type NavigationType = typeof NAVIGATION_TYPE[keyof typeof NAVIGATION_TYPE];
-export declare type NavigationTypeId = typeof NAVIGATION_ID[keyof typeof NAVIGATION_ID];
-export * from './shared/graphql.d';
-export declare type Navigation = {
-    selectedNavType: NavigationType;
-    selectedNavTypeId: NavigationTypeId;
-    selectedNavData: {};
-};
+import { NAVIGATION_ID, NAVIGATION_TYPE } from './redux/native_nav/constants.d';
+import { League, Roster, User, MatchupLeg } from './shared/graphql.d';
+export type NavigationType = typeof NAVIGATION_TYPE[keyof typeof NAVIGATION_TYPE];
+export type NavigationTypeId = typeof NAVIGATION_ID[keyof typeof NAVIGATION_ID];
+export * from './shared/graphql.d';
+export type Navigation = {
+    selectedNavType: NavigationType;
+    selectedNavTypeId: NavigationTypeId;
+    selectedNavData: {};
+};
+export type LeagueId = string;
+export type RosterId = string;
+export type UserId = string;
+export type MatchupWeek = number;
+export type LeaguesMap = Record<LeagueId, League>;
+export type RostersMap = Record<RosterId, Roster>;
+export type RostersInLeagueMap = Record<LeagueId, RostersMap>;
+export type UserMap = Record<UserId, User>;
+export type MathchupWeekMap = Record<MatchupWeek, MatchupLeg>;
+export type MatchupsInLeagueMap = Record<LeagueId, MathchupWeekMap>;

package/declarations/types/redux/native_nav/constants.d.ts

@@ -1,23 +1,23 @@
-export declare const NAVIGATION_TYPE: {
-    readonly DM: "DM";
-    readonly INBOX: "INBOX";
-    readonly MY_FEED: "MY_FEED";
-    readonly FRIENDS: "FRIENDS";
-    readonly LEAGUE: "LEAGUE";
-    readonly ASYNC_SPORT: "ASYNC_SPORT";
-    readonly CREATE_LEAGUE: "CREATE_LEAGUE";
-    readonly LEAGUE_SYNC: "LEAGUE_SYNC";
-    readonly DRAFTBOARDS: "DRAFTBOARDS";
-    readonly SOLO_OVER_UNDER: "SOLO_OVER_UNDER";
-    readonly CHANNEL: "CHANNEL";
-    readonly MANAGE_CHANNELS: "MANAGE_CHANNELS";
-};
-export declare const NAVIGATION_ID: {
-    readonly DRAFTBOARDS: 1;
-    readonly CREATE_DM: 2;
-    readonly DM_SCREEN: 3;
-    readonly CREATE_LEAGUE: 4;
-    readonly MY_FEED: 5;
-    readonly MENTIONS: 6;
-    readonly FRIENDS: 7;
-};
+export declare const NAVIGATION_TYPE: {
+    readonly DM: "DM";
+    readonly INBOX: "INBOX";
+    readonly MY_FEED: "MY_FEED";
+    readonly FRIENDS: "FRIENDS";
+    readonly LEAGUE: "LEAGUE";
+    readonly ASYNC_SPORT: "ASYNC_SPORT";
+    readonly CREATE_LEAGUE: "CREATE_LEAGUE";
+    readonly LEAGUE_SYNC: "LEAGUE_SYNC";
+    readonly DRAFTBOARDS: "DRAFTBOARDS";
+    readonly SOLO_OVER_UNDER: "SOLO_OVER_UNDER";
+    readonly CHANNEL: "CHANNEL";
+    readonly MANAGE_CHANNELS: "MANAGE_CHANNELS";
+};
+export declare const NAVIGATION_ID: {
+    readonly DRAFTBOARDS: 1;
+    readonly CREATE_DM: 2;
+    readonly DM_SCREEN: 3;
+    readonly CREATE_LEAGUE: 4;
+    readonly MY_FEED: 5;
+    readonly MENTIONS: 6;
+    readonly FRIENDS: 7;
+};

package/declarations/types/shared/graphql.d.ts

@@ -1,98 +1,131 @@
-export declare type Maybe<T> = T | null;
-export declare type InputMaybe<T> = Maybe<T>;
-export declare type Exact<T extends {
-    [key: string]: unknown;
-}> = {
-    [K in keyof T]: T[K];
-};
-export declare type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
-    [SubKey in K]?: Maybe<T[SubKey]>;
-};
-export declare type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
-    [SubKey in K]: Maybe<T[SubKey]>;
-};
-/** All built-in and custom scalars, mapped to their actual values */
-export declare type Scalars = {
-    ID: string;
-    String: string;
-    Boolean: boolean;
-    Int: number;
-    Float: number;
-    /** JSON */
-    Json: {
-        [key: string]: any;
-    };
-    /** Lists */
-    List: string[];
-    /** Map / Dictionary */
-    Map: {
-        [key: string]: any;
-    };
-    MapWithSnowflakeKey: {
-        [key: string]: any;
-    };
-    /** Sets */
-    Set: string[];
-    /** Snowflake ID */
-    Snowflake: string;
-    SnowflakeList: string[];
-    SnowflakeSet: string[];
-};
-export declare type League = {
-    __typename?: 'League';
-    avatar?: Maybe<Scalars['String']>;
-    company_id?: Maybe<Scalars['Snowflake']>;
-    display_order?: Maybe<Scalars['Int']>;
-    draft_id?: Maybe<Scalars['Snowflake']>;
-    group_id?: Maybe<Scalars['Snowflake']>;
-    last_author_avatar?: Maybe<Scalars['String']>;
-    last_author_display_name?: Maybe<Scalars['String']>;
-    last_author_id?: Maybe<Scalars['Snowflake']>;
-    last_author_is_bot?: Maybe<Scalars['Boolean']>;
-    last_message_attachment?: Maybe<Scalars['Json']>;
-    last_message_id?: Maybe<Scalars['Snowflake']>;
-    last_message_text?: Maybe<Scalars['String']>;
-    last_message_text_map?: Maybe<Scalars['Json']>;
-    last_message_time?: Maybe<Scalars['Int']>;
-    last_pinned_message_id?: Maybe<Scalars['Snowflake']>;
-    last_read_id?: Maybe<Scalars['Snowflake']>;
-    last_transaction_id?: Maybe<Scalars['Snowflake']>;
-    league_id?: Maybe<Scalars['Snowflake']>;
-    matchup_legs?: Maybe<Scalars['List']>;
-    metadata?: Maybe<Scalars['Map']>;
-    name?: Maybe<Scalars['String']>;
-    previous_league_id?: Maybe<Scalars['Snowflake']>;
-    roster_positions?: Maybe<Scalars['List']>;
-    scoring_settings?: Maybe<Scalars['Map']>;
-    season?: Maybe<Scalars['String']>;
-    season_type?: Maybe<Scalars['String']>;
-    settings?: Maybe<Scalars['Map']>;
-    sport?: Maybe<Scalars['String']>;
-    status?: Maybe<Scalars['String']>;
-    total_rosters?: Maybe<Scalars['Int']>;
-};
-export declare type User = {
-    __typename?: 'User';
-    async_bundles?: Maybe<Scalars['List']>;
-    avatar?: Maybe<Scalars['String']>;
-    cookies?: Maybe<Scalars['Int']>;
-    created?: Maybe<Scalars['Int']>;
-    currencies?: Maybe<Scalars['Map']>;
-    data_updated?: Maybe<Scalars['Map']>;
-    deleted?: Maybe<Scalars['Int']>;
-    display_name?: Maybe<Scalars['String']>;
-    email?: Maybe<Scalars['String']>;
-    is_bot?: Maybe<Scalars['Boolean']>;
-    metadata?: Maybe<Scalars['Json']>;
-    notifications?: Maybe<Scalars['Map']>;
-    pending?: Maybe<Scalars['Boolean']>;
-    phone?: Maybe<Scalars['String']>;
-    real_name?: Maybe<Scalars['String']>;
-    solicitable?: Maybe<Scalars['Boolean']>;
-    summoner_name?: Maybe<Scalars['String']>;
-    summoner_region?: Maybe<Scalars['String']>;
-    token?: Maybe<Scalars['String']>;
-    user_id?: Maybe<Scalars['Snowflake']>;
-    username?: Maybe<Scalars['String']>;
-    verification?: Maybe<Scalars['String']>;
-};
+export type Maybe<T> = T | null;
+export type InputMaybe<T> = Maybe<T>;
+export type Exact<T extends {
+    [key: string]: unknown;
+}> = {
+    [K in keyof T]: T[K];
+};
+export type MakeOptional<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]?: Maybe<T[SubKey]>;
+};
+export type MakeMaybe<T, K extends keyof T> = Omit<T, K> & {
+    [SubKey in K]: Maybe<T[SubKey]>;
+};
+/** All built-in and custom scalars, mapped to their actual values */
+export type Scalars = {
+    ID: string;
+    String: string;
+    Boolean: boolean;
+    Int: number;
+    Float: number;
+    /** JSON */
+    Json: {
+        [key: string]: any;
+    };
+    /** Lists */
+    List: string[];
+    /** Map / Dictionary */
+    Map: {
+        [key: string]: any;
+    };
+    MapWithSnowflakeKey: {
+        [key: string]: any;
+    };
+    /** Sets */
+    Set: string[];
+    /** Snowflake ID */
+    Snowflake: string;
+    SnowflakeList: string[];
+    SnowflakeSet: string[];
+};
+export type League = {
+    __typename?: 'League';
+    avatar?: Maybe<Scalars['String']>;
+    company_id?: Maybe<Scalars['Snowflake']>;
+    display_order?: Maybe<Scalars['Int']>;
+    draft_id?: Maybe<Scalars['Snowflake']>;
+    group_id?: Maybe<Scalars['Snowflake']>;
+    last_author_avatar?: Maybe<Scalars['String']>;
+    last_author_display_name?: Maybe<Scalars['String']>;
+    last_author_id?: Maybe<Scalars['Snowflake']>;
+    last_author_is_bot?: Maybe<Scalars['Boolean']>;
+    last_message_attachment?: Maybe<Scalars['Json']>;
+    last_message_id?: Maybe<Scalars['Snowflake']>;
+    last_message_text?: Maybe<Scalars['String']>;
+    last_message_text_map?: Maybe<Scalars['Json']>;
+    last_message_time?: Maybe<Scalars['Int']>;
+    last_pinned_message_id?: Maybe<Scalars['Snowflake']>;
+    last_read_id?: Maybe<Scalars['Snowflake']>;
+    last_transaction_id?: Maybe<Scalars['Snowflake']>;
+    league_id?: Maybe<Scalars['Snowflake']>;
+    matchup_legs?: Maybe<Scalars['List']>;
+    metadata?: Maybe<Scalars['Map']>;
+    name?: Maybe<Scalars['String']>;
+    previous_league_id?: Maybe<Scalars['Snowflake']>;
+    roster_positions?: Maybe<Scalars['List']>;
+    scoring_settings?: Maybe<Scalars['Map']>;
+    season?: Maybe<Scalars['String']>;
+    season_type?: Maybe<Scalars['String']>;
+    settings?: Maybe<Scalars['Map']>;
+    sport?: Maybe<Scalars['String']>;
+    status?: Maybe<Scalars['String']>;
+    total_rosters?: Maybe<Scalars['Int']>;
+};
+export type MatchupLeg = {
+    __typename?: 'MatchupLeg';
+    bans?: Maybe<Scalars['Map']>;
+    custom_points?: Maybe<Scalars['Float']>;
+    league_id?: Maybe<Scalars['Snowflake']>;
+    leg?: Maybe<Scalars['Int']>;
+    matchup_id?: Maybe<Scalars['Int']>;
+    max_points?: Maybe<Scalars['Float']>;
+    picks?: Maybe<Scalars['Map']>;
+    player_map?: Maybe<Scalars['Map']>;
+    players?: Maybe<Scalars['Set']>;
+    points?: Maybe<Scalars['Float']>;
+    proj_points?: Maybe<Scalars['Float']>;
+    roster_id?: Maybe<Scalars['Int']>;
+    round?: Maybe<Scalars['Int']>;
+    starters?: Maybe<Scalars['List']>;
+    starters_games?: Maybe<Scalars['Map']>;
+};
+export type Roster = {
+    __typename?: 'Roster';
+    co_owners?: Maybe<Scalars['SnowflakeSet']>;
+    keepers?: Maybe<Scalars['Set']>;
+    league_id?: Maybe<Scalars['Snowflake']>;
+    metadata?: Maybe<Scalars['Map']>;
+    owner_id?: Maybe<Scalars['Snowflake']>;
+    player_map?: Maybe<Scalars['Map']>;
+    players?: Maybe<Scalars['Set']>;
+    reserve?: Maybe<Scalars['Set']>;
+    roster_id?: Maybe<Scalars['Int']>;
+    settings?: Maybe<Scalars['Map']>;
+    starters?: Maybe<Scalars['List']>;
+    taxi?: Maybe<Scalars['Set']>;
+};
+export type User = {
+    __typename?: 'User';
+    async_bundles?: Maybe<Scalars['List']>;
+    avatar?: Maybe<Scalars['String']>;
+    cookies?: Maybe<Scalars['Int']>;
+    created?: Maybe<Scalars['Int']>;
+    currencies?: Maybe<Scalars['Map']>;
+    data_updated?: Maybe<Scalars['Map']>;
+    deleted?: Maybe<Scalars['Int']>;
+    display_name?: Maybe<Scalars['String']>;
+    email?: Maybe<Scalars['String']>;
+    is_bot?: Maybe<Scalars['Boolean']>;
+    metadata?: Maybe<Scalars['Json']>;
+    notifications?: Maybe<Scalars['Map']>;
+    pending?: Maybe<Scalars['Boolean']>;
+    phone?: Maybe<Scalars['String']>;
+    real_name?: Maybe<Scalars['String']>;
+    solicitable?: Maybe<Scalars['Boolean']>;
+    summoner_name?: Maybe<Scalars['String']>;
+    summoner_region?: Maybe<Scalars['String']>;
+    token?: Maybe<Scalars['String']>;
+    user_id?: Maybe<Scalars['Snowflake']>;
+    username?: Maybe<Scalars['String']>;
+    verification?: Maybe<Scalars['String']>;
+};

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@sleeperhq/mini-core",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Core library frameworks for developing Sleeper Mini Apps.",
   "main": "index.ts",
   "types": "index.d.ts",
+  "bin": {
+    "build-mini": "./bin/build_mini.js"
+  },
   "scripts": {
     "test": "jest",
     "lint": "eslint ."
@@ -30,15 +33,16 @@
     "access": "public"
   },
   "peerDependencies": {
-    "@callstack/repack": "blitzstudios/repack.git#callstack-repack-v2.5.3-gitpkg",
+    "@callstack/repack": "blitzstudios/repack.git#callstack-repack-v2.6.0-gitpkg",
     "@react-native-community/netinfo": "^9.3.7",
     "axios": "0.15.3",
     "lodash": "4.17.21",
     "react": "17.0.2",
     "react-native": "0.66.5",
     "react-native-linear-gradient": "2.5.6",
+    "react-native-rename": "^3.2.12",
     "react-native-svg": "13.7.0",
-    "react-native-udp": "^4.1.6"
+    "react-native-tcp-socket": "^6.0.6"
   },
   "devDependencies": {
     "@babel/core": "^7.12.9",

package/src/dev_server/index.tsx

@@ -1,73 +1,255 @@
-import React, {useEffect} from 'react';
+import React, {useEffect, useRef, useState} from 'react';
 import {Platform} from 'react-native';
-import {Config} from '../types';
-import {ScriptManager, Federated} from '@callstack/repack/client';
+import {Config, SocketMessage} from '../types';
+import { ScriptLocatorResolver, ScriptManager, Federated } from '@callstack/repack/client';
 import NetInfo from '@react-native-community/netinfo';
-import dgram from 'react-native-udp';
-import axios from 'axios';
+import TcpSocket from 'react-native-tcp-socket';
+import { fetchMainVersionMap, getMainUrl } from './url_resolver';
 
 let config: Config;
+const RETRY_TIMER = 5000;
 
 const DevServer = props => {
-  const onSocket = msg => {
-    const json = JSON.parse(msg.toString());
-    if (json?._connected) {
-      return;
-    }
+  const connection = useRef<TcpSocket.Socket>();
+  const partialMessage = useRef('');
+  const _retryTimer = useRef<NodeJS.Timeout>();
+
+  const [data, setData] = useState({
+    platform: '',
+    binaryVersion: '',
+    dist: '',
+    isStaging: false,
+  });
+  const _dataRef = useRef<typeof data>();
+  const _versionMap = useRef<Record<string, string>>();
 
-    props.onContextChanged(json);
+  const _onConnected = async (value: boolean) => {
+    props.onConnected(value);
   };
 
-  const onError = err => {
-    console.error('[Sleeper] Socket error: ' + err);
+  const onSocket = (handler) => msg => {
+    let json;
+    try {
+      json = JSON.parse(msg); 
+    } catch(e) {
+      partialMessage.current += msg;
+    }
+
+    if (partialMessage.current.length > 0) {
+      try {
+        json = JSON.parse(partialMessage.current);
+        partialMessage.current = '';
+      } catch (e) {
+        return;
+      }
+    }
+
+    // Set connection data
+    if (json._platform || json._binaryVersion || json._dist || json._isStaging) {
+      console.log("[Sleeper] Received context data:", json._platform, json._binaryVersion, json._dist, json._isStaging);
+      setData({
+        platform: json._platform,
+        binaryVersion: json._binaryVersion,
+        dist: json._dist,
+        isStaging: json._isStaging,
+      });
+    }
+
+    // We should have a context object now
+    const context = new Proxy(json, handler);
+    props.onContextChanged(context);
   };
 
-  const bindSocket = async socket => {
+  const sendContextRequest = (socket, propertyPath) => {
+    const message: SocketMessage = {_contextGet: propertyPath};
+    const json = JSON.stringify(message);
+    try {
+      socket?.write(json + '\n');
+    } catch (e) {
+      console.log("[Sleeper] Failed to send context request: ", e);
+    }
+  }
+
+  const proxyHandler = (socket) => {
+    return {
+      get: (target, property) => {
+        let value = Reflect.get(target, property);
+
+        // Check if we need to add a proxy to this object
+        if (!!value && typeof value === 'object' && !value._isProxy && value._isProxyInternal) {
+          const isLeaf = !value._continueProxy;
+          // Adding proxies to objects
+          const handler = proxyHandlerChild(socket, property, isLeaf);
+          const proxiedValue = new Proxy(value, handler);
+          Reflect.set(target, property, proxiedValue);
+          value = proxiedValue;
+        }
+
+        return value;
+      }
+    };
+  }
+
+  const proxyHandlerChild = (socket, path, isLeaf) => {
+    return {
+      get: (target, property) => {
+        // Check if a proxy was already added to this object
+        if (property === '_isProxy') {
+          return true;
+        }
+
+        const value = Reflect.get(target, property);
+        const fullPropertyPath = `${path}.${property}`;
+
+        // If the value is undefined, we need to request it from the server
+        if (value === undefined && isLeaf) {
+          sendContextRequest(socket, fullPropertyPath);
+        }
+
+        // Check if we need to add a second layer proxy to this object
+        if (!isLeaf && !value?._isProxy) {
+          const nextLeaf = true; // Currently we only support 2 layers of proxies
+          // Adding proxies to objects
+          // These proxies aren't stored in the context object so we will regenerate them every time
+          const handler = proxyHandlerChild(socket, fullPropertyPath, nextLeaf);
+          if (value === undefined) {
+            return new Proxy({}, handler);
+          } else {
+            return new Proxy(value, handler);
+          }
+        }
+
+        return value;
+      }
+    };
+  }
+
+  const startSocket = async () => {
     const netInfo = await NetInfo.fetch();
     const netInfoDetails = netInfo?.details;
+    const ipAddress = netInfoDetails?.ipAddress;
 
     if (!netInfoDetails || !('ipAddress' in netInfoDetails)) {
       console.error('[Sleeper] Failed to determine local IP address.');
-      return;
+      return stopSocket();
     }
 
-    socket.bind({port: config.localSocketPort, address: netInfoDetails.ipAddress});
-  };
+    connection.current = TcpSocket.createConnection({
+      port: config.remoteSocketPort || 9092,
+      host: config.remoteIP,
+      localAddress: ipAddress,
+      reuseAddress: true,
+    }, () => {
+      // When we establish a connection, send the IP address to the server
+      const message: SocketMessage = { 
+        _ip: ipAddress, 
+        _name: config.name, 
+      };
+      const json = JSON.stringify(message);
+      console.log('[Sleeper] Send IP address: ', ipAddress, config.name);
+      try {
+        connection.current?.write(json + '\n', "utf8", (error) => {
+          if (error) {
+            return stopSocket();
+          }
+          console.log('[Sleeper] Connected to the Sleeper App.');
+          _onConnected(true);
+        });
+      } catch (e) {
+        return stopSocket();
+      }
+    });
+  
+    connection.current.on('data', (data, ...args) => {
+      const handler = proxyHandler(connection.current);
+      const onSocketHandler = onSocket(handler);
+      onSocketHandler(data);
+    });
+    connection.current.on('error', err => {
+      return stopSocket();
+    });
+    connection.current.on('close', (hadError) => {
+      return stopSocket();
+    });
+  }
 
-  const pingServer = socket => {
-    // Continue to ping the sleeper app server until it responds.
-    return new Promise(() => {
-      NetInfo.fetch().then(netInfo => {
-        const netInfoDetails = netInfo?.details;
-        if (!netInfoDetails || !('ipAddress' in netInfoDetails)) {
-          console.error('[Sleeper] Failed to determine local IP address.');
-          return;
-        }
+  const stopSocket = (retry = true) => {
+    _onConnected(false);
 
-        const json = JSON.stringify({_ip: netInfoDetails.ipAddress});
+    if (connection.current) {
+      connection.current.destroy();
+      connection.current = undefined;
+    }
 
-        (async function ping() {
-          socket.send(json, undefined, undefined, config.remoteSocketPort, config.remoteIP);
-          setTimeout(ping, 5000);
-        })();
-      });
+    // Any time the socket is closed, attempt to connect again.
+    if (retry) {
+      clearTimeout(_retryTimer.current);
+      _retryTimer.current = setTimeout(() => {
+        console.log('[Sleeper] Unable to connect to sleeper, retrying...');
+        startSocket();
+      }, RETRY_TIMER);
+    }
+  }
+
+  const _waitForInitialization = () => {
+    return new Promise<void>((resolve) => {
+      (function checkData() {
+        let isInitialized = !!_dataRef.current?.dist;
+
+        // Non-staging builds also require a version map to be defined.
+        if (!_dataRef.current?.isStaging) {
+          isInitialized = !!_versionMap.current;
+        }
+
+        if (isInitialized) return resolve();
+        setTimeout(checkData, 1000);
+      })();
     });
   };
 
+  const _resolveRemoteChunk: ScriptLocatorResolver = async (scriptId: string, caller: string) => {
+    await _waitForInitialization();
+
+    const bundleName = !caller ? `${scriptId}.container.bundle` : `${scriptId}.chunk.bundle`;
+    
+    // Try to resolve URL based on scriptId and caller
+    const url = getMainUrl(scriptId, caller, {
+      platform: _dataRef.current?.platform,
+      bundleVersion: _versionMap.current?.[bundleName],
+      binaryVersion: _dataRef.current?.binaryVersion,
+      dist: _dataRef.current?.dist,
+      isStaging: _dataRef.current?.isStaging,
+      remoteIP: config.remoteIP,
+      dev: config.dev,
+    });
+    const query = config.dev ? {platform: Platform.OS} : undefined;
+
+    console.log('[Sleeper] load script:', scriptId, caller, url);
+    return {url, query};
+  }
+
+  const _fetchVersionMap = async (platform, binaryVersion, dist) => {
+    _versionMap.current = await fetchMainVersionMap(platform, binaryVersion, dist);
+  }
+
+  useEffect(() => {
+    _dataRef.current = data;
+    if (!data.platform || !data.binaryVersion || !data.dist) return;
+    
+    _fetchVersionMap(data.platform, data.binaryVersion, data.dist);
+  }, [data.platform, data.binaryVersion, data.dist, data.isStaging]);
+
   useEffect(() => {
     if (!config) {
       console.error('[Sleeper] No config file specified. Please make sure you call DevServer.init() early in the app lifecycle.');
       return;
     }
 
-    const socket = dgram.createSocket({type: 'udp4'});
-    bindSocket(socket);
-    pingServer(socket);
+    ScriptManager.shared.addResolver(_resolveRemoteChunk.bind(this));
+    startSocket();
 
-    socket.on('message', onSocket);
-    socket.on('error', onError);
     return () => {
-      socket.removeAllListeners();
+      stopSocket(false);
     };
   }, []);
 
@@ -76,34 +258,6 @@ const DevServer = props => {
 
 DevServer.init = (_config: Config) => {
   config = _config;
-
-  const remoteBundleHost = config.release ? config.remoteIP : 'localhost';
-  const remoteBundlePort = config.release ? config.remoteBundlePort : 8081;
-
-  ScriptManager.shared.addResolver(async (scriptId, caller) => {
-    const extension =
-      scriptId === 'sleeper' ? '.container.bundle' : '.chunk.bundle';
-    const resolveURL = Federated.createURLResolver({
-      containers: {
-        sleeper: `http://${remoteBundleHost}:${remoteBundlePort}/[name]${extension}`,
-      },
-    });
-  
-    // Try to resolve URL based on scriptId and caller
-    const url = resolveURL(scriptId, caller);
-    const query = config.release ? undefined : {platform: Platform.OS};
-  
-    const response = await axios
-      .get(url + '?' + new URLSearchParams(query), {method: 'HEAD'})
-      .catch(() => ({
-        status: 404,
-      }));
-  
-    console.log('[Sleeper] load script:', scriptId, caller);
-    if (response?.status === 200) {
-      return {url, query};
-    }
-  });
-};
+}
 
 export default DevServer;

package/src/dev_server/url_resolver.tsx

@@ -0,0 +1,71 @@
+import axios, { AxiosPromise, AxiosRequestConfig } from 'axios';
+import { 
+  getWebpackContext,
+  Federated,
+} from '@callstack/repack/client';
+import { Platform } from 'react-native';
+
+export type MainPlatformData = {
+  // Received from socket
+  platform?: string,
+  bundleVersion?: string,
+  binaryVersion?: string,
+  dist?: string,
+  isStaging?: boolean,
+
+  // From app.json
+  remoteIP: string,
+  dev?: boolean,
+}
+
+const PROD_CDN = "https://sleepercdn.com/bundles/";
+const TEST_CDN = "https://test.sleepercdn.com/bundles/";
+
+// Query a list of urls, and grab the first one that returns a 200 response.
+const _fetchFirstAvailable = (config: AxiosRequestConfig, ...urls: string[]) => {
+  return new Promise<any>((resolve) => {
+    (async function fetchMap() {
+      const promises = urls.map((url) => axios.get(url, config).catch(() => null));
+      const responses = await Promise.all<AxiosPromise>(promises);
+      
+      const successfulResponse = responses.find((response) => response?.status === 200);
+      if (config?.method === 'HEAD') {
+        successfulResponse ? resolve({ url: successfulResponse.config.url }) : setTimeout(fetchMap, 5000);
+      } else {
+        successfulResponse ? resolve(successfulResponse.data) : setTimeout(fetchMap, 5000);
+      }
+    })();
+  });
+}
+
+export const fetchMainVersionMap = (platform: string, binaryVersion: string, dist: string) => {
+  const baseUrl = `${PROD_CDN}/version_maps/${platform}/${binaryVersion}/${dist}.json`;
+  const codepushUrl = `${PROD_CDN}/version_maps/${platform}/codepush/${dist}.json`;
+
+  return _fetchFirstAvailable({}, baseUrl, codepushUrl);
+}
+
+export const getMainUrl = (scriptId: string, caller: string, config: MainPlatformData) => {
+  let sleeper: string;
+
+  if (config.dev) {
+    sleeper = `http://${config.remoteIP}:8081/`;
+  } else if (config.isStaging) {
+    if (config.dist === '0') {
+      sleeper = `${TEST_CDN}/${config.platform}/${config.binaryVersion}/${config.dist}/`;
+    } else {
+      sleeper = `${TEST_CDN}/${config.platform}/codepush/${config.dist}/`;
+    }
+  } else {
+    sleeper = `${PROD_CDN}/data/${Platform.OS}/${config.bundleVersion}/`;
+  }
+
+  const resolveURL = Federated.createURLResolver({
+    containers: {
+      sleeper: `${sleeper}[name][ext]`,
+    } 
+  });
+  const bundleLocation = resolveURL(scriptId, caller);
+
+  return bundleLocation;
+}

package/src/types/index.ts

@@ -1,12 +1,11 @@
 export * from '../../declarations/types/index.d';
 export { default as Context } from '../../declarations/sleeper_context.d';
+export { default as SocketMessage } from '../../declarations/sleeper_message.d';
 
 export type Config = {
   name: string,
   displayName: string,
   remoteIP: string,
-  localSocketPort: number,
-  remoteSocketPort: number,
-  remoteBundlePort: number,
-  release: boolean,
+  remoteSocketPort?: number,
+  dev?: boolean,
 };