i18n - docs translations (#16779)

Created by Github action

---------

Co-authored-by: github-actions <github-actions@twenty.com>

packages/twenty-docs/l/cs/developers/contribute/capabilities/backend-development/feature-flags.mdx

@@ -18,7 +18,7 @@ Také jej přidejte do výčtu v `feature-flag.entity.ts`:
 
 ```ts
 enum FeatureFlagKeys {
-    IsFeatureNameEnabled = 'IS_FUNKCEPOVOLENA',
+    IsFeatureNameEnabled = 'IS_FEATURENAME_ENABLED',
     ...
 }
 ```

packages/twenty-docs/l/cs/developers/contribute/capabilities/frontend-development/best-practices-front.mdx

@@ -19,7 +19,7 @@ Je dobrým zvykem vytvořit tolik atomů, kolik potřebujete ke správě stavu.
 ```tsx
 export const myAtomState = atom({
   key: 'myAtomState',
-  výchozí: 'výchozí hodnota',
+  default: 'default value',
 });
 
 export const MyComponent = () => {
@@ -40,7 +40,7 @@ export const MyComponent = () => {
 
 Vyhněte se používání `useRef` k ukládání stavu.
 
-Pokud chcete ukládat stav, měli byste použít `useState` nebo `useRecoilState`.
+If you want to store state, you should use `useState` or `useRecoilState`.
 
 Podívejte se, jak spravovat překreslení, pokud máte pocit, že potřebujete `useRef`, abyste zabránili některým překreslením.
 
@@ -56,23 +56,23 @@ Pamatujte, že můžete **vždy** zabránit opakovanému renderování pochopen
 
 Vyhýbání se překreslení v nových funkcích je nyní snadné tím, že je eliminujete na úrovni kořene.
 
-Komponenta sidecar `PageChangeEffect` obsahuje pouze jedno `useEffect`, kde drží veškerou logiku vykonávanou při změně stránky.
+The `PageChangeEffect` sidecar component contains just one `useEffect` that holds all the logic to execute on a page change.
 
 Tímto způsobem víte, že existuje pouze jedno místo, které může spustit překreslování.
 
-### Vždy přemýšlejte dvakrát, než přidáte `useEffect` do svého kódu
+### Always think twice before adding `useEffect` in your codebase
 
-Překreslování je často způsobeno zbytečným `useEffect`.
+Re-renders are often caused by unnecessary `useEffect`.
 
-Měli byste přemýšlet, zda potřebujete `useEffect`, nebo jestli můžete logiku přesunout do funkce obsluhy událostí.
+You should think whether you need `useEffect`, or if you can move the logic in a event handler function.
 
-Obecně budete snadno moci přesunout logiku do funkce `handleClick` nebo `handleChange`.
+You'll find it generally easy to move the logic in a `handleClick` or `handleChange` function.
 
 Můžete je také najít v knihovnách jako Apollo: `onCompleted`, `onError` atd.
 
-### Použijte sourozenou komponentu k extrakci logiky `useEffect` nebo získávání dat
+### Use a sibling component to extract `useEffect` or data fetching logic
 
-Pokud máte pocit, že potřebujete přidat `useEffect` do svého základního komponentu, měli byste zvážit jeho extrakci do sidecar komponenty.
+If you feel like you need to add a `useEffect` in your root component, you should consider extracting it in a sidecar component.
 
 Stejný postup můžete aplikovat na logiku získávání dat pomocí Apollo hooks.
 
@@ -168,12 +168,13 @@ Jména proměnných by měla přesně zobrazovat účel nebo funkci proměnné.
 Generická jména v programování nejsou ideální, protože postrádají specifikaci, což vede k nejednoznačnosti a snižuje čitelnost kódu. Taková jména neposkytnou informace o účelu proměnné nebo funkce, čímž ztěžují vývojářům pochopení záměru kódu bez hlubšího zkoumání. To může vést ke zvýšené době ladění, vyšší náchylnosti k chybám a obtížím při údržbě a spolupráci. Mezitím, použití popisných jmen činí kód samozřejmým a snadněji navigovatelným, čímž se zvyšuje jeho kvalita a produktivita vývojáře.
 
 ```tsx
-// ❌ Špatně, používá generický název, který jasně nekomunikuje svůj účel ani obsah
+// ❌ Bad, uses a generic name that doesn't communicate its
+//    purpose or content clearly
 const [value, setValue] = useState('');
 ```
 
 ```tsx
-// ✅ Dobře, používá popisný název
+// ✅ Good, uses a descriptive name
 const [email, setEmail] = useState('');
 ```
 
@@ -186,14 +187,14 @@ const [email, setEmail] = useState('');
 Jména obsluhovačů událostí by měla začínat `handle`, zatímco `on` je prefix používaný k pojmenování událostí v komponentech props.
 
 ```tsx
-// ❌ Špatně
+// ❌ Bad
 const onEmailChange = (val: string) => {
   // ...
 };
 ```
 
 ```tsx
-// ✅ Dobře
+// ✅ Good
 const handleEmailChange = (val: string) => {
   // ...
 };
@@ -221,12 +222,12 @@ const EmailField = ({ value, disabled = false }: EmailFieldProps) => (
 **Použití**
 
 ```tsx
-// ❌ Špatně, předání stejné hodnoty jako výchozí nepřidává žádnou hodnotu
+// ❌ Bad, passing in the same value as the default value adds no value
 const Form = () => <EmailField value="username@email.com" disabled={false} />;
 ```
 
 ```tsx
-// ✅ Dobře, předpokládá výchozí hodnotu
+// ✅ Good, assumes the default value
 const Form = () => <EmailField value="username@email.com" />;
 ```
 
@@ -284,7 +285,7 @@ Při importu, upřednostněte určené aliasy před upřesňováním úplných
 **Použití**
 
 ```tsx
-// ❌ Špatně, specifikuje celou relativní cestu
+// ❌ Bad, specifies the entire relative path
 import {
   CatalogDecorator
 } from '../../../../../testing/decorators/CatalogDecorator';
@@ -309,10 +310,10 @@ const validationSchema = z
     exist: z.boolean(),
     email: z
       .string()
-      .email('Email musí být platný email'),
+      .email('Email must be a valid email'),
     password: z
       .string()
-      .regex(PASSWORD_REGEX, 'Heslo musí obsahovat alespoň 8 znaků'),
+      .regex(PASSWORD_REGEX, 'Password must contain at least 8 characters'),
   })
   .required();
 

packages/twenty-docs/l/cs/developers/contribute/capabilities/frontend-development/frontend-commands.mdx

@@ -73,7 +73,7 @@ Projekt má čistý a jednoduchý stack s minimálním počtem šablonových kó
 
 [React Router](https://reactrouter.com/) zajišťuje směrování.
 
-Aby se předešlo zbytečnému [překreslování](/l/cs/developers/contribute/capabilities/frontend-development/best-practices-front#managing-re-renders) je veškerá logika směrování v `useEffect` v `PageChangeEffect`.
+To avoid unnecessary [re-renders](/l/cs/developers/contribute/capabilities/frontend-development/best-practices-front#managing-re-renders) all the routing logic is in a `useEffect` in `PageChangeEffect`.
 
 ### Správa stavu
 

packages/twenty-docs/l/cs/developers/contribute/capabilities/frontend-development/hotkeys.mdx

@@ -45,29 +45,29 @@ const PageListeningEnter = () => {
     goBackToPreviousHotkeyScope,
   } = usePreviousHotkeyScope();
 
-  // 1. Nastavte rozsah klávesových zkratek v useEffect
+  // 1. Set the hotkey scope in a useEffect
   useEffect(() => {
     setHotkeyScopeAndMemorizePreviousScope(
       ExampleHotkeyScopes.ExampleEnterPage,
     );
 
-    // Vraťte se k předchozímu rozsahu klávesových zkratek, když se komponenta odpojí
+    // Revert to the previous hotkey scope when the component is unmounted
     return () => {
       goBackToPreviousHotkeyScope();
     };
   }, [goBackToPreviousHotkeyScope, setHotkeyScopeAndMemorizePreviousScope]);
 
-  // 2. Použijte hook useScopedHotkeys
+  // 2. Use the useScopedHotkeys hook
   useScopedHotkeys(
     Key.Enter,
     () => {
-      // Nějaká logika vykonaná na této stránce, když uživatel stiskne Enter
+      // Some logic executed on this page when the user presses Enter
       // ...
     },
     ExampleHotkeyScopes.ExampleEnterPage,
   );
 
-  return <div>Moje stránka, která poslouchá Enter</div>;
+  return <div>My page that listens for Enter</div>;
 };
 ```
 
@@ -87,7 +87,7 @@ const ExamplePageWithModal = () => {
   } = usePreviousHotkeyScope();
 
   const handleOpenModalClick = () => {
-    // 1. Nastavte rozsah klávesových zkratek, když uživatel otevře modal
+    // 1. Set the hotkey scope when user opens the modal
     setShowModal(true);
     setHotkeyScopeAndMemorizePreviousScope(
       ExampleHotkeyScopes.ExampleModal,
@@ -95,14 +95,14 @@ const ExamplePageWithModal = () => {
   };
 
   const handleModalClose = () => {
-    // 1. Vraťte se k předchozímu rozsahu klávesových zkratek, když se modal zavře
+    // 1. Revert to the previous hotkey scope when the modal is closed
     setShowModal(false);
     goBackToPreviousHotkeyScope();
   };
 
   return <div>
-    <h1>Moje stránka s modálem</h1>
-    <button onClick={handleOpenModalClick}>Otevřít modal</button>
+    <h1>My page with a modal</h1>
+    <button onClick={handleOpenModalClick}>Open modal</button>
     {showModal && <MyModalComponent onClose={handleModalClose} />}
   </div>;
 };
@@ -112,9 +112,9 @@ Pak v komponentě modalu :
 
 ```tsx
 const MyDropdownComponent = ({ onClose }: { onClose: () => void }) => {
-  // 2. Použijte hook useScopedHotkeys k poslouchání Escape.
-  // Všimněte si, že escape je běžná klávesová zkratka, kterou může použít mnoho jiných komponent
-  // Je tedy důležité používat rozsah klávesových zkratek, aby se předešlo konfliktům
+  // 2. Use the useScopedHotkeys hook to listen for Escape.
+  // Note that escape is a common hotkey that could be used by many other components
+  // So it's important to use a hotkey scope to avoid conflicts
   useScopedHotkeys(
     Key.Escape,
     () => {
@@ -123,13 +123,13 @@ const MyDropdownComponent = ({ onClose }: { onClose: () => void }) => {
     ExampleHotkeyScopes.ExampleModal,
   );
 
-  return <div>Moje komponenta modalu</div>;
+  return <div>My modal component</div>;
 };
 ```
 
-Je důležité používat tento vzor, když si nejste jisti, že samotné použití useEffect pro nastavení a odebrání bude dostatečné k zabránění konfliktům.
+It's important to use this pattern when you're not sure that just using a useEffect with mount/unmount will be enough to avoid conflicts.
 
-Tyto konflikty mohou být těžké ladit a mohou se vyskytovat častěji než ne u useEffects.
+Those conflicts can be hard to debug, and it might happen more often than not with useEffects.
 
 ## Co je to hotkey scope?
 
@@ -143,20 +143,20 @@ Například rozsahy klávesových zkratek pro každou stránku jsou definovány
 
 ```tsx
 export enum PageHotkeyScope {
-  Nastavení = 'settings',
-  VytvořitPracovníProstor = 'create-workspace',
-  PřihlášeníRegistrace = 'sign-in-up',
-  VytvořitProfil = 'create-profile',
-  PožadovánoPlán = 'plan-required',
-  ZobrazitStránku = 'show-page',
-  OsobníZobrazitStránku = 'person-show-page',
-  FiremníZobrazitStránku = 'company-show-page',
-  FirmyStránka = 'companies-page',
-  LidéStránka = 'people-page',
-  PříležitostiStránka = 'opportunities-page',
-  ProfilStránka = 'profile-page',
-  ČlenPracovníhoProstoruStránka = 'workspace-member-page',
-  ÚkolStránka = 'task-page',
+  Settings = 'settings',
+  CreateWorkspace = 'create-workspace',
+  SignInUp = 'sign-in-up',
+  CreateProfile = 'create-profile',
+  PlanRequired = 'plan-required',
+  ShowPage = 'show-page',
+  PersonShowPage = 'person-show-page',
+  CompanyShowPage = 'company-show-page',
+  CompaniesPage = 'companies-page',
+  PeoplePage = 'people-page',
+  OpportunitiesPage = 'opportunities-page',
+  ProfilePage = 'profile-page',
+  WorkspaceMemberPage = 'workspace-member-page',
+  TaskPage = 'task-page',
 }
 ```
 

packages/twenty-docs/l/cs/developers/contribute/capabilities/frontend-development/style-guide.mdx

@@ -21,16 +21,16 @@ Vždy používejte funkcionální komponenty TSX.
 Nepoužívejte implicitní `import` s `const`, protože je obtížnější číst a importovat s automatickým dokončováním kódu.
 
 ```tsx
-// ❌ Špatné, obtížnější číst a importovat s automatickým doplňkem kódu
+// ❌ Bad, harder to read, harder to import with code completion
 const MyComponent = () => {
-  return <div>Ahoj světe</div>;
+  return <div>Hello World</div>;
 };
 
 export default MyComponent;
 
-// ✅ Dobré, snadné čtení a import s automatickým dokončováním kódu
+// ✅ Good, easy to read, easy to import with code completion
 export function MyComponent() {
-  return <div>Ahoj světe</div>;
+  return <div>Hello World</div>;
 };
 ```
 
@@ -41,25 +41,25 @@ Create the type of the props and call it `(ComponentName)Props` if there's no ne
 Use props destructuring.
 
 ```tsx
-// ❌ Špatné, žádný typ
-export const MyComponent = (props) => <div>Ahoj {props.name}</div>;
+// ❌ Bad, no type
+export const MyComponent = (props) => <div>Hello {props.name}</div>;
 
-// ✅ Dobré, typ
+// ✅ Good, type
 type MyComponentProps = {
   name: string;
 };
 
-export const MyComponent = ({ name }: MyComponentProps) => <div>Ahoj {name}</div>;
+export const MyComponent = ({ name }: MyComponentProps) => <div>Hello {name}</div>;
 ```
 
 #### Upusťte od používání `React.FC` nebo `React.FunctionComponent` k definování typů rekvizit
 
 ```tsx
-/* ❌ - Špatné, definuje anotace typů komponent s `FC`
- *   - S `React.FC` komponent implicitně přijímá rekvizitu `children`
- *     i když není definována v typu rekvizity. To nemusí být vždy
- *     žádoucí, zejména pokud komponenta nemá v úmyslu vykreslovat
- *     podřízené komponenty.
+/* ❌ - Bad, defines the component type annotations with `FC`
+ *    - With `React.FC`, the component implicitly accepts a `children` prop
+ *      even if it's not defined in the prop type. This might not always be
+ *      desirable, especially if the component doesn't intend to render
+ *      children.
  */
 const EmailField: React.FC<{
   value: string;
@@ -86,7 +86,7 @@ const EmailField = ({ value }: EmailFieldProps) => (
 Avoid using single variable prop spreading in JSX elements, like `{...props}`. Tato praxe často vede k tomu, že kód je méně čitelný a obtížnější udržovat, protože není jasné, které rekvizity komponenta přijímá.
 
 ```tsx
-/* ❌ - Špatné, šíří jedinou proměnnou prop do základní komponenty
+/* ❌ - Bad, spreads a single variable prop into the underlying component
  */
 const MyComponent = (props: OwnProps) => {
   return <OtherComponent {...props} />;
@@ -137,12 +137,12 @@ onClick?.();
 Vždy používejte `type` místo `interface`, protože se téměř vždy překrývají a `type` je flexibilnější.
 
 ```tsx
-// ❌ Špatné
+// ❌ Bad
 interface MyInterface {
   name: string;
 }
 
-// ✅ Dobré
+// ✅ Good
 type MyType = {
   name: string;
 };
@@ -155,7 +155,7 @@ type MyType = {
 Proč TypeScript doporučuje vyhnout se výčtům zjistíte [zde](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#enums).
 
 ```tsx
-// ❌ Špatné, využívá výčet
+// ❌ Bad, utilizes an enum
 enum Color {
   Red = "red",
   Green = "green",
@@ -263,13 +263,13 @@ const StyledButton = styled.button`
 Vyhýbejte se typovým importům. K prosazení tohoto standardu pravidlo ESLint kontroluje a hlásí jakékoli typové importy. To pomáhá udržovat konzistenci a čitelnost v TypeScript kódu.
 
 ```tsx
-// ❌ Špatné
+// ❌ Bad
 import { type Meta, type StoryObj } from '@storybook/react';
 
-// ❌ Špatné
+// ❌ Bad
 import type { Meta, StoryObj } from '@storybook/react';
 
-// ✅ Dobré
+// ✅ Good
 import { Meta, StoryObj } from '@storybook/react';
 ```