mustafadalga

function watch(obj, prop, cb) {
  const callback = arguments.length == 3 ? cb : prop;

  if (arguments.length == 3) {

    if (typeof obj[prop] === 'object') {
      return watch(obj[prop], callback);
    }

    return defineProperty(obj, prop, callback);

mustafadalga

import { NextRequest, NextResponse } from "next/server";
import { AxiosInstance } from "axios";
import { CookieKeys } from "@/_enums";
import createAuthenticatedApiServiceV2 from "@/_services/createAuthenticatedApiServiceV2";
import handleAxiosError from "@/_utilities/handleAxiosError";

export async function GET(request: NextRequest) {

    try {
        const jwt: string | undefined = request.cookies.get(CookieKeys.Jwt)?.value;

mustafadalga

import { lazy, Suspense, useEffect } from "react";
import useModalStore from "@/hooks/useModalStore.ts";

const Modal = lazy(() => import("@/components/Modal.tsx"))

function Loading() {
    return <h2>🌀 Loading...</h2>;
}

function App() {

mustafadalga

/**
 * This Gist demonstrates a simple yet effective implementation of a memoization function in JavaScript.
 * Memoization is an optimization technique used to speed up computer programs by storing the results of expensive function
 * calls and returning the cached result when the same inputs occur again.
 */

const memoMap = new Map();

const complexFunction = (a1: number[], a2: number[]): number => {
  // Simulate heavy calculations

mustafadalga

<template>
  <div class="app">
    <button @click="store.mutations.open()">Open Modal </button>
     <Modal v-if="store.state.isModalOpen"/>
  </div>
</template>

<script setup>
import store from "./store";
import Modal from "./Modal.vue";

mustafadalga

<template>
  <div class="app">
    <button @click="store.mutations.open()">Open Modal </button>
     <Modal v-if="store.state.isModalOpen"/>
  </div>
</template>

<script setup>
import store from "./store";
import Modal from "./Modal.vue";

mustafadalga

import { createStore } from "vuex";
import type { Post } from "@/types";

export interface ApisLoadState {
    isCalled: boolean;
    isLoaded: boolean;
}

export interface ApiLoadState extends ApisLoadState {
    api: string;

mustafadalga

declare global {
    interface AmplitudeInstance {
        logEvent(eventName: string, eventProperties?: object): void;
        identify(identifyObject: object): void;
        setUserId(userId: string | null): void;
        init(apiKey: string, userId?: string, options?: object, callback?: () => void): void;
    }

    interface Amplitude {
        getInstance(): AmplitudeInstance;

mustafadalga

import { expect, describe, it, beforeAll, afterEach, afterAll, beforeEach } from "vitest";
import { QueryClientProvider } from "react-query";
import { ReactNode } from "react";
import { http, HttpResponse } from "msw";
import { useCommonStore } from "@/_store/useCommonStore";
import { act, renderHook, waitFor } from "@testing-library/react";
import { createTestServer, queryClient } from "@/__tests__/utilities";
import useFetchCustomVariables from "@/_hooks/useFetchCustomVariables";

const successResponse = [

mustafadalga

import { describe, it, expect } from "vitest";
import { renderHook } from "@testing-library/react";
import useDeepCompareMemoize from "./useDeepCompareMemoize";

describe("useDeepCompareMemoize", () => {
    it('should return a memoized version of the input value based on deep comparison', () => {
        const initialData = { user: { name: 'John', age: 25, city: 'New York' } };
        const newData = { user: { name: 'Alice', age: 30, city: 'San Francisco' } };
        const identicalData = { user: { name: 'John', age: 25, city: 'New York' } };