@clicktap/state 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clicktap/state",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "author": "Clicktap",
   "description": "A state management library for Clicktap reference frontend.",
@@ -11,7 +11,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "type": "commonjs",
+  "type": "module",
   "dependencies": {
     "cookie": "^0.5.0"
   },
@@ -26,5 +26,8 @@
     "@xstate/immer": "^0.3.3",
     "@xstate/inspect": "^0.8.0",
     "@xstate/react": "^3.2.2"
-  }
+  },
+  "module": "./index.js",
+  "main": "./index.js",
+  "types": "./src/index.d.ts"
 }

package/src/auth/AuthProvider.d.ts

@@ -0,0 +1,49 @@
+import type { InterpreterFrom } from 'xstate';
+import type { ReactNode } from 'react';
+import type { NextPageContext } from 'next';
+import { authMachine } from './auth';
+export declare const AuthContext: import("react").Context<import("xstate").Interpreter<import("./auth").AuthMachineContext, any, import("./auth").AuthMachineEvents, {
+    value: any;
+    context: import("./auth").AuthMachineContext;
+}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("./auth").AuthMachineEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>>;
+export declare const useAuth: () => import("xstate").Interpreter<import("./auth").AuthMachineContext, any, import("./auth").AuthMachineEvents, {
+    value: any;
+    context: import("./auth").AuthMachineContext;
+}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("./auth").AuthMachineEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;
+export declare const useUser: () => {
+    email: string;
+    username: string;
+    firstName: string;
+    lastName: string;
+    birthdate?: Date | undefined;
+    gender?: string | undefined;
+    createdAt: Date;
+    updatedAt: Date;
+    role?: string | undefined;
+    locked: boolean;
+    affiliateId: string;
+    stripeId: string;
+} | null;
+type AuthOptions = {
+    devTools: boolean;
+    endpoints: {
+        login: string;
+        logout: string;
+        refresh: string;
+        ssrRefresh: string;
+    };
+};
+/**
+ * this will run on the server side as part of app.getInitialProps
+ * @todo is it possible to share state from client to server? headers? cookies?
+ */
+export declare const getAuth: (context: NextPageContext, options: AuthOptions) => Promise<import("xstate").Interpreter<import("./auth").AuthMachineContext, any, import("./auth").AuthMachineEvents, {
+    value: any;
+    context: import("./auth").AuthMachineContext;
+}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("./auth").AuthMachineEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>>;
+type Props = {
+    children: ReactNode;
+    service: InterpreterFrom<typeof authMachine>;
+};
+export declare function AuthProvider({ children, service, }: Props): JSX.Element;
+export {};

package/src/auth/auth.d.ts

@@ -0,0 +1,52 @@
+import type { DoneInvokeEvent } from 'xstate';
+export interface AuthMachineContext {
+    user: {
+        email: string;
+        username: string;
+        firstName: string;
+        lastName: string;
+        birthdate?: Date;
+        gender?: string /** @todo use enum? */;
+        createdAt: Date;
+        updatedAt: Date;
+        role?: string /** @todo use enum? */;
+        locked: boolean;
+        affiliateId: string;
+        stripeId: string;
+    } | null;
+    accessToken: string;
+    refreshToken: string;
+    ignoreRefreshToken: boolean;
+    endpoints: {
+        login: string;
+        logout: string;
+        refresh: string;
+        ssrRefresh: string;
+    };
+}
+export interface RefreshTokenEvent {
+    type: 'REFRESH_TOKEN';
+    accessToken: AuthMachineContext['accessToken'];
+}
+export interface LoginEvent {
+    type: 'LOGIN';
+    username: string;
+    password: string;
+}
+export interface LogoutEvent {
+    type: 'LOGOUT';
+}
+export interface AuthenticateSuccessEvent {
+    type: 'AUTHENTICATE_SUCCESS';
+    user: AuthMachineContext['user'];
+    accessToken: AuthMachineContext['accessToken'];
+}
+export interface RefreshTokenSuccessEvent {
+    type: 'REFRESH_TOKEN_SUCCESS';
+    accessToken: AuthMachineContext['accessToken'];
+}
+export type AuthMachineEvents = RefreshTokenEvent | LoginEvent | LogoutEvent | DoneInvokeEvent<AuthenticateSuccessEvent> | DoneInvokeEvent<RefreshTokenSuccessEvent>;
+export declare const authMachine: import("xstate").StateMachine<AuthMachineContext, any, AuthMachineEvents, {
+    value: any;
+    context: AuthMachineContext;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, AuthMachineEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/src/toast/ToastProvider.d.ts

@@ -0,0 +1,17 @@
+import type { InterpreterFrom } from 'xstate';
+import type { ReactNode } from 'react';
+import { toastMachine } from './toast';
+export declare const ToastContext: import("react").Context<import("xstate").Interpreter<import("./toast").ToastMachineContext, any, import("./toast").ToastMachineEvents, {
+    value: any;
+    context: import("./toast").ToastMachineContext;
+}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("./toast").ToastMachineEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>>;
+export declare const useToast: () => import("xstate").Interpreter<import("./toast").ToastMachineContext, any, import("./toast").ToastMachineEvents, {
+    value: any;
+    context: import("./toast").ToastMachineContext;
+}, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, import("./toast").ToastMachineEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;
+type Props = {
+    children: ReactNode;
+    service: InterpreterFrom<typeof toastMachine>;
+};
+export declare function ToastProvider({ children, service, }: Props): JSX.Element;
+export {};

package/src/toast/timer.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+export interface TimerContext {
+    elapsed: number;
+    duration: number;
+    interval: number;
+    intervalId: NodeJS.Timer | null;
+}
+export type TimerEvents = {
+    type: 'START_TIMER';
+} | {
+    type: 'RESUME_TIMER';
+} | {
+    type: 'PAUSE_TIMER';
+} | {
+    type: 'TICK';
+} | {
+    type: 'DURATION.UPDATE';
+    value: number;
+} | {
+    type: 'RESET_TIMER';
+};
+export declare const timerMachine: import("xstate").StateMachine<TimerContext, any, TimerEvents, {
+    value: any;
+    context: TimerContext;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, TimerEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;
+export default timerMachine;

package/src/toast/toast.d.ts

@@ -0,0 +1,46 @@
+import { ReactNode } from 'react';
+import type { ReactElement } from 'react';
+/** @todo figure out TS here */
+export type ToastItem = {
+    id: string | null;
+    duration: number;
+    element: ReactNode;
+};
+export interface ToastMachineContext {
+    /** @todo create proper type for Array items */
+    items: Array<ToastItem>;
+    order: 'asc' | 'desc';
+    duration: number;
+    activeItem: string | null;
+}
+export interface AddItemEvent {
+    type: 'ADD_ITEM';
+    item: ReactElement;
+    duration?: number;
+}
+export interface RemoveItemEvent {
+    type: 'REMOVE_ITEM';
+}
+export interface SetIdleEvent {
+    type: 'SET_IDLE';
+}
+export interface SetActiveEvent {
+    type: 'SET_ACTIVE';
+}
+export interface ResumeTimerEvent {
+    type: 'RESUME_TIMER';
+}
+export interface PauseTimerEvent {
+    type: 'PAUSE_TIMER';
+}
+export interface TimeoutEvent {
+    type: 'xstate.after(ITEM_TIMEOUT)#toast.active';
+}
+export interface TimerDoneEvent {
+    type: 'done.invoke.timer';
+}
+export type ToastMachineEvents = AddItemEvent | RemoveItemEvent | SetIdleEvent | SetActiveEvent | TimeoutEvent | ResumeTimerEvent | PauseTimerEvent | TimerDoneEvent;
+export declare const toastMachine: import("xstate").StateMachine<ToastMachineContext, any, ToastMachineEvents, {
+    value: any;
+    context: ToastMachineContext;
+}, import("xstate").BaseActionObject, import("xstate").ServiceMap, import("xstate").ResolveTypegenMeta<import("xstate").TypegenDisabled, ToastMachineEvents, import("xstate").BaseActionObject, import("xstate").ServiceMap>>;

package/.eslintrc.json

@@ -1,40 +0,0 @@
-{
-  "extends": [
-    "../../.eslintrc.json"
-  ],
-  "ignorePatterns": [
-    "!**/*",
-    "jest.config.ts",
-    "*.spec.ts"
-  ],
-  "overrides": [
-    {
-      "files": [
-        "*.ts",
-        "*.tsx",
-        "*.js",
-        "*.jsx"
-      ],
-      "rules": {}
-    },
-    {
-      "files": [
-        "*.ts",
-        "*.tsx"
-      ],
-      "rules": {},
-      "parserOptions": {
-        "project": [
-          "libs/state/tsconfig.lib.json"
-        ]
-      }
-    },
-    {
-      "files": [
-        "*.js",
-        "*.jsx"
-      ],
-      "rules": {}
-    }
-  ]
-}

package/jest.config.ts

@@ -1,10 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'state',
-  preset: '../../jest.preset.js',
-  transform: {
-    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
-  },
-  moduleFileExtensions: ['ts', 'js', 'html'],
-  coverageDirectory: '../../coverage/libs/state',
-};

package/project.json

@@ -1,40 +0,0 @@
-{
-  "name": "state",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/state/src",
-  "projectType": "library",
-  "targets": {
-    "build": {
-      "executor": "@nx/js:tsc",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/libs/state",
-        "main": "libs/state/src/index.ts",
-        "tsConfig": "libs/state/tsconfig.lib.json",
-        "assets": ["libs/state/*.md"]
-      }
-    },
-    "lint": {
-      "executor": "@nx/linter:eslint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": ["libs/state/**/*.ts"]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "outputs": ["{workspaceRoot}/coverage/{projectRoot}"],
-      "options": {
-        "jestConfig": "libs/state/jest.config.ts",
-        "passWithNoTests": true
-      },
-      "configurations": {
-        "ci": {
-          "ci": true,
-          "codeCoverage": true
-        }
-      }
-    }
-  },
-  "tags": []
-}

package/src/auth/AuthProvider.tsx

@@ -1,97 +0,0 @@
-import { createContext, useContext } from 'react';
-import { interpret } from 'xstate';
-import type { InterpreterFrom } from 'xstate';
-import cookie from 'cookie';
-import type { ReactNode } from 'react';
-import type { NextPageContext } from 'next';
-import { authMachine } from './auth';
-
-// removing dependencies on next, this should work regardless of platform
-// import type { NextPageContext } from 'next';
-// import { useRouter } from 'next/router';
-
-export const AuthContext = createContext(
-  {} as InterpreterFrom<typeof authMachine>
-);
-
-export const useAuth = () => {
-  // console.log('useAuth');
-  // console.log(useContext(AuthContext).getSnapshot().context);
-  return useContext(AuthContext);
-};
-
-export const useUser = () => {
-  return useContext(AuthContext).getSnapshot().context.user;
-};
-
-type AuthOptions = {
-  devTools: boolean;
-  endpoints: {
-    login: string;
-    logout: string;
-    refresh: string;
-    ssrRefresh: string;
-  };
-};
-
-/**
- * this will run on the server side as part of app.getInitialProps
- * @todo is it possible to share state from client to server? headers? cookies?
- */
-export const getAuth = async (
-  context: NextPageContext,
-  options: AuthOptions
-  // eslint-disable-next-line @typescript-eslint/require-await
-) => {
-  if (typeof window !== 'undefined') {
-    // eslint-disable-next-line no-console
-    console.warn(
-      'App.getInitialProps::getAuth should not be run on the frontend. You are probably missing getServerSideProps in your page.'
-    );
-    return interpret(authMachine, { devTools: options.devTools }).start();
-  }
-
-  const cookies = cookie.parse(
-    context?.req?.headers && context.req.headers.cookie
-      ? context.req.headers.cookie
-      : ''
-  );
-  if (typeof cookies['refresh_token'] !== 'undefined') {
-    const authContext = {
-      ...authMachine.initialState.context,
-      refreshToken: cookies['refresh_token'],
-      endpoints: { ...options.endpoints },
-    };
-    return interpret(authMachine.withContext(authContext), {
-      devTools: options.devTools,
-    }).start();
-  }
-
-  return interpret(authMachine, { devTools: options.devTools }).start();
-};
-
-type Props = {
-  children: ReactNode;
-  service: InterpreterFrom<typeof authMachine>;
-  // options: {
-  //   devTools: boolean;
-  // };
-  // state: StateConfig<AuthMachineContext, AuthMachineEvents>;
-};
-
-export function AuthProvider({
-  children,
-  service,
-}: // options = { devTools: false },
-// state
-Props) {
-  // console.log('AuthProvider::state');
-  // console.log(state.context);
-  // let authService = interpret(authMachine, { devTools: options.devTools }).start(state);
-  // console.log('AuthProvider::authService');
-  // console.log(authService.getSnapshot().context);
-
-  return (
-    <AuthContext.Provider value={service}>{children}</AuthContext.Provider>
-  );
-}

package/src/auth/auth.spec.ts

@@ -1,7 +0,0 @@
-import { authMachine } from './auth';
-
-describe('state', () => {
-  it('should work', () => {
-    expect(authMachine).toEqual('auth');
-  });
-});