Migrate to a monorepo structure (#2909)

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useContextScopeId.ts

@@ -0,0 +1,16 @@
+import { Context, useContext } from 'react';
+
+/**
+ * @deprecated use a custom scope instead and desctructure the scope id from the scope context
+ * Get the scope context with useScopeInternalContext
+ */
+export const useContextScopeId = (SpecificContext: Context<string | null>) => {
+  const recoilScopeId = useContext(SpecificContext);
+
+  if (!recoilScopeId)
+    throw new Error(
+      `Using useContextScopedId outside of the specified context : ${SpecificContext.displayName}, verify that you are using a RecoilScope with the specific context you want to use.`,
+    );
+
+  return recoilScopeId;
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useRecoilScopeId.ts

@@ -0,0 +1,17 @@
+import { useContext } from 'react';
+
+import { RecoilScopeContext } from '@/types/RecoilScopeContext';
+
+/**
+ * @deprecated Use a custom scope instead and desctructure the scope id from the scope context
+ */
+export const useRecoilScopeId = (RecoilScopeContext: RecoilScopeContext) => {
+  const recoilScopeId = useContext(RecoilScopeContext);
+
+  if (!recoilScopeId)
+    throw new Error(
+      `Using useRecoilScopeId outside of the specified context : ${RecoilScopeContext.displayName}, verify that you are using a RecoilScope with the specific context you want to use.`,
+    );
+
+  return recoilScopeId;
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useRecoilScopedFamilyState.ts

@@ -0,0 +1,27 @@
+import { RecoilState, SerializableParam, useRecoilState } from 'recoil';
+
+import { ScopedFamilyStateKey } from '../scopes-internal/types/ScopedFamilyStateKey';
+
+export const useRecoilScopedFamilyState = <
+  StateType,
+  FamilyKey extends SerializableParam,
+>(
+  recoilState: (
+    scopedFamilyKey: ScopedFamilyStateKey<FamilyKey>,
+  ) => RecoilState<StateType>,
+  scopeId: string,
+  familyKey?: FamilyKey,
+) => {
+  const familyState = useRecoilState<StateType>(
+    recoilState({
+      scopeId,
+      familyKey: familyKey || ('' as FamilyKey),
+    }),
+  );
+
+  if (!familyKey) {
+    return [undefined, undefined];
+  }
+
+  return familyState;
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useRecoilScopedState.ts

@@ -0,0 +1,22 @@
+import { Context, useContext } from 'react';
+import { RecoilState, useRecoilState } from 'recoil';
+
+import { RecoilScopeContext } from '../states/RecoilScopeContext';
+
+export const useRecoilScopedState = <StateType>(
+  recoilState: (param: string) => RecoilState<StateType>,
+  CustomRecoilScopeContext?: Context<string | null>,
+) => {
+  const recoilScopeId = useContext(
+    CustomRecoilScopeContext ?? RecoilScopeContext,
+  );
+
+  if (!recoilScopeId)
+    throw new Error(
+      `Using a scoped atom without a RecoilScope : ${
+        recoilState('').key
+      }, verify that you are using a RecoilScope with a specific context if you intended to do so.`,
+    );
+
+  return useRecoilState<StateType>(recoilState(recoilScopeId));
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useRecoilScopedStateV2.ts

@@ -0,0 +1,14 @@
+import { RecoilState, useRecoilState } from 'recoil';
+
+import { ScopedStateKey } from '../scopes-internal/types/ScopedStateKey';
+
+export const useRecoilScopedStateV2 = <StateType>(
+  recoilState: (scopedKey: ScopedStateKey) => RecoilState<StateType>,
+  scopeId: string,
+) => {
+  return useRecoilState<StateType>(
+    recoilState({
+      scopeId,
+    }),
+  );
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useRecoilScopedValue.ts

@@ -0,0 +1,25 @@
+import { Context, useContext } from 'react';
+import { RecoilState, RecoilValueReadOnly, useRecoilValue } from 'recoil';
+
+import { RecoilScopeContext } from '../states/RecoilScopeContext';
+
+/**
+ * @deprecated use useRecoilScopedStateV2 instead
+ */
+export const useRecoilScopedValue = <T>(
+  recoilState: (param: string) => RecoilState<T> | RecoilValueReadOnly<T>,
+  CustomRecoilScopeContext?: Context<string | null>,
+) => {
+  const recoilScopeId = useContext(
+    CustomRecoilScopeContext ?? RecoilScopeContext,
+  );
+
+  if (!recoilScopeId)
+    throw new Error(
+      `Using a scoped atom without a RecoilScope : ${
+        recoilState('').key
+      }, verify that you are using a RecoilScope with a specific context if you intended to do so.`,
+    );
+
+  return useRecoilValue<T>(recoilState(recoilScopeId));
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useRecoilScopedValueV2.ts

@@ -0,0 +1,14 @@
+import { RecoilState, useRecoilValue } from 'recoil';
+
+import { ScopedStateKey } from '../scopes-internal/types/ScopedStateKey';
+
+export const useRecoilScopedValueV2 = <StateType>(
+  recoilState: (scopedKey: ScopedStateKey) => RecoilState<StateType>,
+  scopeId: string,
+) => {
+  return useRecoilValue<StateType>(
+    recoilState({
+      scopeId,
+    }),
+  );
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useSetRecoilScopedFamilyState.ts

@@ -0,0 +1,27 @@
+import { RecoilState, SerializableParam, useSetRecoilState } from 'recoil';
+
+import { ScopedFamilyStateKey } from '../scopes-internal/types/ScopedFamilyStateKey';
+
+export const useSetRecoilScopedFamilyState = <
+  StateType,
+  FamilyKey extends SerializableParam,
+>(
+  recoilState: (
+    scopedFamilyKey: ScopedFamilyStateKey<FamilyKey>,
+  ) => RecoilState<StateType>,
+  scopeId: string,
+  familyKey?: FamilyKey,
+) => {
+  const familyState = useSetRecoilState<StateType>(
+    recoilState({
+      scopeId,
+      familyKey: familyKey || ('' as FamilyKey),
+    }),
+  );
+
+  if (!familyKey) {
+    return;
+  }
+
+  return familyState;
+};

packages/twenty-front/src/modules/ui/utilities/recoil-scope/hooks/useSetRecoilScopedStateV2.ts

@@ -0,0 +1,14 @@
+import { RecoilState, useSetRecoilState } from 'recoil';
+
+import { ScopedStateKey } from '../scopes-internal/types/ScopedStateKey';
+
+export const useSetRecoilScopedStateV2 = <StateType>(
+  recoilState: (scopedKey: ScopedStateKey) => RecoilState<StateType>,
+  scopeId: string,
+) => {
+  return useSetRecoilState<StateType>(
+    recoilState({
+      scopeId,
+    }),
+  );
+};