{"version":3,"file":"static/js/506.15888891.chunk.js","mappings":"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","sources":["components/Separator.tsx","contents/Home.tsx","../node_modules/@apollo/src/react/hooks/useSyncExternalStore.ts","../node_modules/@apollo/src/react/parser/index.ts","../node_modules/@apollo/src/react/hooks/useQuery.ts","../node_modules/@apollo/src/react/hooks/useApolloClient.ts"],"sourcesContent":["import styled from 'styled-components'\nimport { phone, pxToRem } from '../libs'\n\nconst SeparatorStyled = styled.div`\n  height: ${pxToRem(5)};\n  background: ${({ theme }) => theme.colors.primary};\n  max-width: ${pxToRem(365)};\n  width: 100%;\n  margin: ${pxToRem(48)} 0;\n  ${phone(`\n    margin: ${pxToRem(24)} 0;\n    width: 80%;\n    padding: ${pxToRem(2)};\n  `)}\n`\n\nexport const Separator: React.FC = () => <SeparatorStyled />\n","import { Loading } from '@components/Loading'\nimport { useHomapge } from '@hooks/useData'\nimport { useGlobalModal } from '@hooks/useGlobalModal'\nimport { useTranslation } from 'react-i18next'\nimport { Link } from 'react-router-dom'\nimport styled from 'styled-components'\nimport { FlexContainer } from '../components/BaseContainer'\nimport { CustomButton, CustomLink } from '../components/Button'\nimport { Separator } from '../components/Separator'\nimport { clampValues, phone, pxToRem, tablet } from '../libs'\n\nconst HeroTitle = styled.div`\n  text-transform: uppercase;\n  font-size: ${clampValues(75, 108)};\n\n  ${phone(`\n    font-size: ${pxToRem(50)};\n  `)}\n`\nconst HeroSubTitle = styled.div`\n  font-size: ${clampValues(28, 48)};\n  ${phone(`\n    font-size: ${pxToRem(20)};\n  `)}\n`\n\nconst HomeRecapContainer = styled.div`\n  margin-bottom: ${pxToRem(68)};\n`\nconst QuestionContainer = styled.div`\n  display: grid;\n  grid-template-columns: auto 1fr;\n  line-height: ${pxToRem(38)};\n\n\t${tablet(`    \n    display: flex;\n    flex-direction: column;\n    margin-bottom: ${pxToRem(16)};\n    > span {\n      line-height: 1rem;\n    }\n  `)}\n`\n\nconst Question = styled.span`\n  margin-right: ${pxToRem(8)};\n  font-size: ${({ theme }) => clampValues(18, theme.fontSize)};\n  ${phone(`\n    font-size: ${pxToRem(14)}\n  `)}\n`\n\nconst Answer = styled.span`\n  color: ${({ theme }) => theme.colors.primary};\n  font-size: ${({ theme }) => clampValues(18, theme.fontSize)};\n  ${phone(`\n    font-size: ${pxToRem(14)}\n  `)}\n`\n\nconst ContactLink = styled.a`\ndisplay: inline-block;\ntext-decoration: underline;\ncursor: pointer;\n`\n\nconst CTAContainer = styled.div`\n  display: flex;\n  flex-wrap: wrap-reverse;\n  column-gap: ${pxToRem(48)};\n  row-gap: ${pxToRem(16)};\n  ${phone(`\n    flex-direction: column-reverse;\n  `)}\n`\n\nconst HomeContent = () => {\n  const { t } = useTranslation()\n  const { open } = useGlobalModal()\n  const {\n    loading, error, data\n  } = useHomapge()\n\n  if (loading) return <Loading />\n  if (error) return <div >error :( </div>\n\n  return (\n    <FlexContainer>\n      <HeroTitle>Nicholas Lazzerini</HeroTitle>\n      <HeroSubTitle\n        dangerouslySetInnerHTML={{\n          __html: t('home.heroSubTitle', {\n            develop: t('home.develop'),\n            design: t('home.design'),\n          }),\n        }}\n      />\n      <Separator />\n      <HomeRecapContainer>\n\n        <QuestionContainer>\n          <Question>{t('home.occupationQuestion')}</Question>\n          <Answer>{data.homepage.homepageFields.currentOccupation}</Answer>\n        </QuestionContainer>\n\n        <QuestionContainer>\n          <Question>{t('home.liveQuestion')}</Question>\n          <Answer>{data.homepage.homepageFields.currentResidence}</Answer>\n        </QuestionContainer>\n\n        <QuestionContainer>\n          <Question>{t('home.hireQuestion')}</Question>\n          <Answer>{data.homepage.homepageFields.availableForHire[0] === 'yes' ?\n            <ContactLink onClick={() => open()}>\n              {t('home.hireAnswerYes')}\n            </ContactLink>\n            : t('home.hireAnswerNo')}\n          </Answer>\n        </QuestionContainer>\n      </HomeRecapContainer>\n      <CTAContainer>\n        <Link to=\"/projects/all\">\n          <CustomButton>{t('home.showProjects')}</CustomButton>\n        </Link>\n        <div>\n          <CustomLink to={'/about'}>{t('home.showAbout')}</CustomLink>\n        </div>\n      </CTAContainer>\n    </FlexContainer >\n  )\n}\n\nexport default HomeContent","import { invariant } from '../../utilities/globals';\nimport * as React from 'react';\n\nimport { canUseLayoutEffect } from '../../utilities';\n\nlet didWarnUncachedGetSnapshot = false;\n\ntype RealUseSESHookType =\n  // This import depends only on the @types/use-sync-external-store package, not\n  // the actual use-sync-external-store package, which is not installed. It\n  // might be nice to get this type from React 18, but it still needs to work\n  // when only React 17 or earlier is installed.\n  typeof import(\"use-sync-external-store\").useSyncExternalStore;\n\n// Prevent webpack from complaining about our feature detection of the\n// useSyncExternalStore property of the React namespace, which is expected not\n// to exist when using React 17 and earlier, and that's fine.\nconst uSESKey = \"useSyncExternalStore\" as keyof typeof React;\nconst realHook = React[uSESKey] as RealUseSESHookType | undefined;\n\n// Adapted from https://www.npmjs.com/package/use-sync-external-store, with\n// Apollo Client deviations called out by \"// DEVIATION ...\" comments.\n\n// When/if React.useSyncExternalStore is defined, delegate fully to it.\nexport const useSyncExternalStore: RealUseSESHookType = realHook || ((\n  subscribe,\n  getSnapshot,\n  getServerSnapshot,\n) => {\n  // Read the current snapshot from the store on every render. Again, this\n  // breaks the rules of React, and only works here because of specific\n  // implementation details, most importantly that updates are\n  // always synchronous.\n  const value = getSnapshot();\n  if (\n    // DEVIATION: Using our own __DEV__ polyfill (from ../../utilities/globals).\n    __DEV__ &&\n    !didWarnUncachedGetSnapshot &&\n    // DEVIATION: Not using Object.is because we know our snapshots will never\n    // be exotic primitive values like NaN, which is !== itself.\n    value !== getSnapshot()\n  ) {\n    didWarnUncachedGetSnapshot = true;\n    // DEVIATION: Using invariant.error instead of console.error directly.\n    invariant.error(\n      'The result of getSnapshot should be cached to avoid an infinite loop',\n    );\n  }\n\n  // Because updates are synchronous, we don't queue them. Instead we force a\n  // re-render whenever the subscribed state changes by updating an some\n  // arbitrary useState hook. Then, during render, we call getSnapshot to read\n  // the current value.\n  //\n  // Because we don't actually use the state returned by the useState hook, we\n  // can save a bit of memory by storing other stuff in that slot.\n  //\n  // To implement the early bailout, we need to track some things on a mutable\n  // object. Usually, we would put that in a useRef hook, but we can stash it in\n  // our useState hook instead.\n  //\n  // To force a re-render, we call forceUpdate({inst}). That works because the\n  // new object always fails an equality check.\n  const [{inst}, forceUpdate] = React.useState({inst: {value, getSnapshot}});\n\n  // Track the latest getSnapshot function with a ref. This needs to be updated\n  // in the layout phase so we can access it during the tearing check that\n  // happens on subscribe.\n  if (canUseLayoutEffect) {\n    // DEVIATION: We avoid calling useLayoutEffect when !canUseLayoutEffect,\n    // which may seem like a conditional hook, but this code ends up behaving\n    // unconditionally (one way or the other) because canUseLayoutEffect is\n    // constant.\n    React.useLayoutEffect(() => {\n      Object.assign(inst, { value, getSnapshot });\n      // Whenever getSnapshot or subscribe changes, we need to check in the\n      // commit phase if there was an interleaved mutation. In concurrent mode\n      // this can happen all the time, but even in synchronous mode, an earlier\n      // effect may have mutated the store.\n      if (checkIfSnapshotChanged(inst)) {\n        // Force a re-render.\n        forceUpdate({inst});\n      }\n    }, [subscribe, value, getSnapshot]);\n  } else {\n    Object.assign(inst, { value, getSnapshot });\n  }\n\n  React.useEffect(() => {\n    // Check for changes right before subscribing. Subsequent changes will be\n    // detected in the subscription handler.\n    if (checkIfSnapshotChanged(inst)) {\n      // Force a re-render.\n      forceUpdate({inst});\n    }\n\n    // Subscribe to the store and return a clean-up function.\n    return subscribe(function handleStoreChange() {\n      // TODO: Because there is no cross-renderer API for batching updates, it's\n      // up to the consumer of this library to wrap their subscription event\n      // with unstable_batchedUpdates. Should we try to detect when this isn't\n      // the case and print a warning in development?\n\n      // The store changed. Check if the snapshot changed since the last time we\n      // read from the store.\n      if (checkIfSnapshotChanged(inst)) {\n        // Force a re-render.\n        forceUpdate({inst});\n      }\n    });\n  }, [subscribe]);\n\n  return value;\n});\n\nfunction checkIfSnapshotChanged<Snapshot>({\n  value,\n  getSnapshot,\n}: {\n  value: Snapshot;\n  getSnapshot: () => Snapshot;\n}): boolean {\n  try {\n    return value !== getSnapshot();\n  } catch {\n    return true;\n  }\n}\n","import { invariant } from '../../utilities/globals';\n\nimport {\n  DocumentNode,\n  DefinitionNode,\n  VariableDefinitionNode,\n  OperationDefinitionNode\n} from 'graphql';\n\nexport enum DocumentType {\n  Query,\n  Mutation,\n  Subscription\n}\n\nexport interface IDocumentDefinition {\n  type: DocumentType;\n  name: string;\n  variables: ReadonlyArray<VariableDefinitionNode>;\n}\n\nconst cache = new Map();\n\nexport function operationName(type: DocumentType) {\n  let name;\n  switch (type) {\n    case DocumentType.Query:\n      name = 'Query';\n      break;\n    case DocumentType.Mutation:\n      name = 'Mutation';\n      break;\n    case DocumentType.Subscription:\n      name = 'Subscription';\n      break;\n  }\n  return name;\n}\n\n// This parser is mostly used to safety check incoming documents.\nexport function parser(document: DocumentNode): IDocumentDefinition {\n  const cached = cache.get(document);\n  if (cached) return cached;\n\n  let variables, type, name;\n\n  invariant(\n    !!document && !!document.kind,\n    `Argument of ${document} passed to parser was not a valid GraphQL ` +\n      `DocumentNode. You may need to use 'graphql-tag' or another method ` +\n      `to convert your operation into a document`\n  );\n\n  const fragments: DefinitionNode[] = []\n  const queries: DefinitionNode[] = []\n  const mutations: DefinitionNode[] = []\n  const subscriptions: DefinitionNode[] = []\n\n  for (const x of document.definitions) {\n    if (x.kind === 'FragmentDefinition') {\n      fragments.push(x);\n      continue\n    }\n\n    if (x.kind === 'OperationDefinition') {\n      switch (x.operation) {\n        case 'query':\n          queries.push(x);\n          break;\n        case 'mutation':\n          mutations.push(x);\n          break;\n        case 'subscription':\n          subscriptions.push(x);\n          break;\n      }\n    }\n  }\n\n  invariant(\n    !fragments.length ||\n      (queries.length || mutations.length || subscriptions.length),\n    `Passing only a fragment to 'graphql' is not yet supported. ` +\n      `You must include a query, subscription or mutation as well`\n  );\n\n  invariant(\n    queries.length + mutations.length + subscriptions.length <= 1,\n    `react-apollo only supports a query, subscription, or a mutation per HOC. ` +\n      `${document} had ${queries.length} queries, ${subscriptions.length} ` +\n      `subscriptions and ${mutations.length} mutations. ` +\n      `You can use 'compose' to join multiple operation types to a component`\n  );\n\n  type = queries.length ? DocumentType.Query : DocumentType.Mutation;\n  if (!queries.length && !mutations.length) type = DocumentType.Subscription;\n\n  const definitions = queries.length\n    ? queries\n    : mutations.length\n    ? mutations\n    : subscriptions;\n\n  invariant(\n    definitions.length === 1,\n    `react-apollo only supports one definition per HOC. ${document} had ` +\n      `${definitions.length} definitions. ` +\n      `You can use 'compose' to join multiple operation types to a component`\n  );\n\n  const definition = definitions[0] as OperationDefinitionNode;\n  variables = definition.variableDefinitions || [];\n\n  if (definition.name && definition.name.kind === 'Name') {\n    name = definition.name.value;\n  } else {\n    name = 'data'; // fallback to using data if no name\n  }\n\n  const payload = { name, type, variables };\n  cache.set(document, payload);\n  return payload;\n}\n\nexport function verifyDocumentType(document: DocumentNode, type: DocumentType) {\n  const operation = parser(document);\n  const requiredOperationName = operationName(type);\n  const usedOperationName = operationName(operation.type);\n  invariant(\n    operation.type === type,\n    `Running a ${requiredOperationName} requires a graphql ` +\n      `${requiredOperationName}, but a ${usedOperationName} was used instead.`\n  );\n}\n\n","import { invariant } from '../../utilities/globals';\n\nimport {\n  useCallback,\n  useContext,\n  useMemo,\n  useRef,\n  useState,\n} from 'react';\nimport { useSyncExternalStore } from './useSyncExternalStore';\nimport { equal } from '@wry/equality';\n\nimport { mergeOptions, OperationVariables, WatchQueryFetchPolicy } from '../../core';\nimport { ApolloContextValue, getApolloContext } from '../context';\nimport { ApolloError } from '../../errors';\nimport {\n  ApolloClient,\n  ApolloQueryResult,\n  NetworkStatus,\n  ObservableQuery,\n  DocumentNode,\n  TypedDocumentNode,\n  WatchQueryOptions,\n} from '../../core';\nimport {\n  QueryHookOptions,\n  QueryResult,\n  ObservableQueryFields,\n} from '../types/types';\n\nimport { DocumentType, verifyDocumentType } from '../parser';\nimport { useApolloClient } from './useApolloClient';\nimport { canUseWeakMap, canUseWeakSet, compact, isNonEmptyArray, maybeDeepFreeze } from '../../utilities';\n\nconst {\n  prototype: {\n    hasOwnProperty,\n  },\n} = Object;\n\nexport function useQuery<\n  TData = any,\n  TVariables = OperationVariables,\n>(\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n  options: QueryHookOptions<TData, TVariables> = Object.create(null),\n): QueryResult<TData, TVariables> {\n  return useInternalState(\n    useApolloClient(options.client),\n    query,\n  ).useQuery(options);\n}\n\nexport function useInternalState<TData, TVariables>(\n  client: ApolloClient<any>,\n  query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n): InternalState<TData, TVariables> {\n  const stateRef = useRef<InternalState<TData, TVariables>>();\n  if (\n    !stateRef.current ||\n    client !== stateRef.current.client ||\n    query !== stateRef.current.query\n  ) {\n    stateRef.current = new InternalState(client, query, stateRef.current);\n  }\n  const state = stateRef.current;\n\n  // By default, InternalState.prototype.forceUpdate is an empty function, but\n  // we replace it here (before anyone has had a chance to see this state yet)\n  // with a function that unconditionally forces an update, using the latest\n  // setTick function. Updating this state by calling state.forceUpdate is the\n  // only way we trigger React component updates (no other useState calls within\n  // the InternalState class).\n  const [_tick, setTick] = useState(0);\n  state.forceUpdate = () => {\n    setTick(tick => tick + 1);\n  };\n\n  return state;\n}\n\nclass InternalState<TData, TVariables> {\n  constructor(\n    public readonly client: ReturnType<typeof useApolloClient>,\n    public readonly query: DocumentNode | TypedDocumentNode<TData, TVariables>,\n    previous?: InternalState<TData, TVariables>,\n  ) {\n    verifyDocumentType(query, DocumentType.Query);\n\n    // Reuse previousData from previous InternalState (if any) to provide\n    // continuity of previousData even if/when the query or client changes.\n    const previousResult = previous && previous.result;\n    const previousData = previousResult && previousResult.data;\n    if (previousData) {\n      this.previousData = previousData;\n    }\n  }\n\n  forceUpdate() {\n    // Replaced (in useInternalState) with a method that triggers an update.\n    invariant.warn(\"Calling default no-op implementation of InternalState#forceUpdate\");\n  }\n\n  asyncUpdate() {\n    return new Promise<QueryResult<TData, TVariables>>(resolve => {\n      this.asyncResolveFns.add(resolve);\n      this.optionsToIgnoreOnce.add(this.watchQueryOptions);\n      this.forceUpdate();\n    });\n  }\n\n  private asyncResolveFns = new Set<\n    (result: QueryResult<TData, TVariables>) => void\n  >();\n\n  private optionsToIgnoreOnce = new (canUseWeakSet ? WeakSet : Set)<\n    WatchQueryOptions<TVariables, TData>\n  >();\n\n  // Methods beginning with use- should be called according to the standard\n  // rules of React hooks: only at the top level of the calling function, and\n  // without any dynamic conditional logic.\n  useQuery(options: QueryHookOptions<TData, TVariables>) {\n    // The renderPromises field gets initialized here in the useQuery method, at\n    // the beginning of everything (for a given component rendering, at least),\n    // so we can safely use this.renderPromises in other/later InternalState\n    // methods without worrying it might be uninitialized. Even after\n    // initialization, this.renderPromises is usually undefined (unless SSR is\n    // happening), but that's fine as long as it has been initialized that way,\n    // rather than left uninitialized.\n    this.renderPromises = useContext(getApolloContext()).renderPromises;\n\n    this.useOptions(options);\n\n    const obsQuery = this.useObservableQuery();\n\n    const result = useSyncExternalStore(\n      useCallback(() => {\n        if (this.renderPromises) {\n          return () => {};\n        }\n\n        const onNext = () => {\n          const previousResult = this.result;\n          // We use `getCurrentResult()` instead of the onNext argument because\n          // the values differ slightly. Specifically, loading results will have\n          // an empty object for data instead of `undefined` for some reason.\n          const result = obsQuery.getCurrentResult();\n          // Make sure we're not attempting to re-render similar results\n          if (\n            previousResult &&\n            previousResult.loading === result.loading &&\n            previousResult.networkStatus === result.networkStatus &&\n            equal(previousResult.data, result.data)\n          ) {\n            return;\n          }\n\n          this.setResult(result);\n        };\n\n        const onError = (error: Error) => {\n          const last = obsQuery[\"last\"];\n          subscription.unsubscribe();\n          // Unfortunately, if `lastError` is set in the current\n          // `observableQuery` when the subscription is re-created,\n          // the subscription will immediately receive the error, which will\n          // cause it to terminate again. To avoid this, we first clear\n          // the last error/result from the `observableQuery` before re-starting\n          // the subscription, and restore it afterwards (so the subscription\n          // has a chance to stay open).\n          try {\n            obsQuery.resetLastResults();\n            subscription = obsQuery.subscribe(onNext, onError);\n          } finally {\n            obsQuery[\"last\"] = last;\n          }\n\n          if (!hasOwnProperty.call(error, 'graphQLErrors')) {\n            // The error is not a GraphQL error\n            throw error;\n          }\n\n          const previousResult = this.result;\n          if (\n            !previousResult ||\n            (previousResult && previousResult.loading) ||\n            !equal(error, previousResult.error)\n          ) {\n            this.setResult({\n              data: (previousResult && previousResult.data) as TData,\n              error: error as ApolloError,\n              loading: false,\n              networkStatus: NetworkStatus.error,\n            });\n          }\n        };\n\n        let subscription = obsQuery.subscribe(onNext, onError);\n\n        return () => subscription.unsubscribe();\n      }, [\n        // We memoize the subscribe function using useCallback and the following\n        // dependency keys, because the subscribe function reference is all that\n        // useSyncExternalStore uses internally as a dependency key for the\n        // useEffect ultimately responsible for the subscription, so we are\n        // effectively passing this dependency array to that useEffect buried\n        // inside useSyncExternalStore, as desired.\n        obsQuery,\n        this.renderPromises,\n        this.client.disableNetworkFetches,\n      ]),\n\n      () => this.getCurrentResult(),\n      () => this.getCurrentResult(),\n    );\n\n    // TODO Remove this method when we remove support for options.partialRefetch.\n    this.unsafeHandlePartialRefetch(result);\n\n    const queryResult = this.toQueryResult(result);\n\n    if (!queryResult.loading && this.asyncResolveFns.size) {\n      this.asyncResolveFns.forEach(resolve => resolve(queryResult));\n      this.asyncResolveFns.clear();\n    }\n\n    return queryResult;\n  }\n\n  // These members (except for renderPromises) are all populated by the\n  // useOptions method, which is called unconditionally at the beginning of the\n  // useQuery method, so we can safely use these members in other/later methods\n  // without worrying they might be uninitialized.\n  private renderPromises: ApolloContextValue[\"renderPromises\"];\n  private queryHookOptions: QueryHookOptions<TData, TVariables>;\n  private watchQueryOptions: WatchQueryOptions<TVariables, TData>;\n\n  private useOptions(\n    options: QueryHookOptions<TData, TVariables>,\n  ) {\n    const watchQueryOptions = this.createWatchQueryOptions(\n      this.queryHookOptions = options,\n    );\n\n    // Update this.watchQueryOptions, but only when they have changed, which\n    // allows us to depend on the referential stability of\n    // this.watchQueryOptions elsewhere.\n    const currentWatchQueryOptions = this.watchQueryOptions;\n\n    // To force this equality test to \"fail,\" thereby reliably triggering\n    // observable.reobserve, add any current WatchQueryOptions object(s) you\n    // want to be ignored to this.optionsToIgnoreOnce. A similar effect could be\n    // achieved by nullifying this.watchQueryOptions so the equality test\n    // immediately fails because currentWatchQueryOptions is null, but this way\n    // we can promise a truthy this.watchQueryOptions at all times.\n    if (\n      this.optionsToIgnoreOnce.has(currentWatchQueryOptions) ||\n      !equal(watchQueryOptions, currentWatchQueryOptions)\n    ) {\n      this.watchQueryOptions = watchQueryOptions;\n\n      if (currentWatchQueryOptions && this.observable) {\n        // As advertised in the -Once of this.optionsToIgnoreOnce, this trick is\n        // only good for one forced execution of observable.reobserve per\n        // ignored WatchQueryOptions object, though it is unlikely we will ever\n        // see this exact currentWatchQueryOptions object again here, since we\n        // just replaced this.watchQueryOptions with watchQueryOptions.\n        this.optionsToIgnoreOnce.delete(currentWatchQueryOptions);\n\n        // Though it might be tempting to postpone this reobserve call to the\n        // useEffect block, we need getCurrentResult to return an appropriate\n        // loading:true result synchronously (later within the same call to\n        // useQuery). Since we already have this.observable here (not true for\n        // the very first call to useQuery), we are not initiating any new\n        // subscriptions, though it does feel less than ideal that reobserve\n        // (potentially) kicks off a network request (for example, when the\n        // variables have changed), which is technically a side-effect.\n        this.observable.reobserve(this.getObsQueryOptions());\n\n        // Make sure getCurrentResult returns a fresh ApolloQueryResult<TData>,\n        // but save the current data as this.previousData, just like setResult\n        // usually does.\n        this.previousData = this.result?.data || this.previousData;\n        this.result = void 0;\n      }\n    }\n\n    // Make sure state.onCompleted and state.onError always reflect the latest\n    // options.onCompleted and options.onError callbacks provided to useQuery,\n    // since those functions are often recreated every time useQuery is called.\n    // Like the forceUpdate method, the versions of these methods inherited from\n    // InternalState.prototype are empty no-ops, but we can override them on the\n    // base state object (without modifying the prototype).\n    this.onCompleted = options.onCompleted || InternalState.prototype.onCompleted;\n    this.onError = options.onError || InternalState.prototype.onError;\n\n    if (\n      (this.renderPromises || this.client.disableNetworkFetches) &&\n      this.queryHookOptions.ssr === false &&\n      !this.queryHookOptions.skip\n    ) {\n      // If SSR has been explicitly disabled, and this function has been called\n      // on the server side, return the default loading state.\n      this.result = this.ssrDisabledResult;\n    } else if (\n      this.queryHookOptions.skip ||\n      this.watchQueryOptions.fetchPolicy === 'standby'\n    ) {\n      // When skipping a query (ie. we're not querying for data but still want to\n      // render children), make sure the `data` is cleared out and `loading` is\n      // set to `false` (since we aren't loading anything).\n      //\n      // NOTE: We no longer think this is the correct behavior. Skipping should\n      // not automatically set `data` to `undefined`, but instead leave the\n      // previous data in place. In other words, skipping should not mandate that\n      // previously received data is all of a sudden removed. Unfortunately,\n      // changing this is breaking, so we'll have to wait until Apollo Client 4.0\n      // to address this.\n      this.result = this.skipStandbyResult;\n    } else if (\n      this.result === this.ssrDisabledResult ||\n      this.result === this.skipStandbyResult\n    ) {\n      this.result = void 0;\n    }\n  }\n\n  private getObsQueryOptions(): WatchQueryOptions<TVariables, TData> {\n    const toMerge: Array<\n      Partial<WatchQueryOptions<TVariables, TData>>\n    > = [];\n\n    const globalDefaults = this.client.defaultOptions.watchQuery;\n    if (globalDefaults) toMerge.push(globalDefaults);\n\n    if (this.queryHookOptions.defaultOptions) {\n      toMerge.push(this.queryHookOptions.defaultOptions);\n    }\n\n    // We use compact rather than mergeOptions for this part of the merge,\n    // because we want watchQueryOptions.variables (if defined) to replace\n    // this.observable.options.variables whole. This replacement allows\n    // removing variables by removing them from the variables input to\n    // useQuery. If the variables were always merged together (rather than\n    // replaced), there would be no way to remove existing variables.\n    // However, the variables from options.defaultOptions and globalDefaults\n    // (if provided) should be merged, to ensure individual defaulted\n    // variables always have values, if not otherwise defined in\n    // observable.options or watchQueryOptions.\n    toMerge.push(compact(\n      this.observable && this.observable.options,\n      this.watchQueryOptions,\n    ));\n\n    return toMerge.reduce(\n      mergeOptions\n    ) as WatchQueryOptions<TVariables, TData>;\n  }\n\n  private ssrDisabledResult = maybeDeepFreeze({\n    loading: true,\n    data: void 0 as unknown as TData,\n    error: void 0,\n    networkStatus: NetworkStatus.loading,\n  });\n\n  private skipStandbyResult = maybeDeepFreeze({\n    loading: false,\n    data: void 0 as unknown as TData,\n    error: void 0,\n    networkStatus: NetworkStatus.ready,\n  });\n\n  // A function to massage options before passing them to ObservableQuery.\n  private createWatchQueryOptions({\n    skip,\n    ssr,\n    onCompleted,\n    onError,\n    displayName,\n    defaultOptions,\n    // The above options are useQuery-specific, so this ...otherOptions spread\n    // makes otherOptions almost a WatchQueryOptions object, except for the\n    // query property that we add below.\n    ...otherOptions\n  }: QueryHookOptions<TData, TVariables> = {}): WatchQueryOptions<TVariables, TData> {\n    // This Object.assign is safe because otherOptions is a fresh ...rest object\n    // that did not exist until just now, so modifications are still allowed.\n    const watchQueryOptions: WatchQueryOptions<TVariables, TData> =\n      Object.assign(otherOptions, { query: this.query });\n\n    if (\n      this.renderPromises &&\n      (\n        watchQueryOptions.fetchPolicy === 'network-only' ||\n        watchQueryOptions.fetchPolicy === 'cache-and-network'\n      )\n    ) {\n      // this behavior was added to react-apollo without explanation in this PR\n      // https://github.com/apollographql/react-apollo/pull/1579\n      watchQueryOptions.fetchPolicy = 'cache-first';\n    }\n\n    if (!watchQueryOptions.variables) {\n      watchQueryOptions.variables = {} as TVariables;\n    }\n\n    if (skip) {\n      const {\n        fetchPolicy = this.getDefaultFetchPolicy(),\n        initialFetchPolicy = fetchPolicy,\n      } = watchQueryOptions;\n\n      // When skipping, we set watchQueryOptions.fetchPolicy initially to\n      // \"standby\", but we also need/want to preserve the initial non-standby\n      // fetchPolicy that would have been used if not skipping.\n      Object.assign(watchQueryOptions, {\n        initialFetchPolicy,\n        fetchPolicy: 'standby',\n      });\n    } else if (!watchQueryOptions.fetchPolicy) {\n      watchQueryOptions.fetchPolicy =\n        this.observable?.options.initialFetchPolicy ||\n        this.getDefaultFetchPolicy();\n    }\n\n    return watchQueryOptions;\n  }\n\n  getDefaultFetchPolicy(): WatchQueryFetchPolicy {\n    return (\n      this.queryHookOptions.defaultOptions?.fetchPolicy ||\n      this.client.defaultOptions.watchQuery?.fetchPolicy ||\n      \"cache-first\"\n    );\n  }\n\n  // Defining these methods as no-ops on the prototype allows us to call\n  // state.onCompleted and/or state.onError without worrying about whether a\n  // callback was provided.\n  private onCompleted(data: TData) {}\n  private onError(error: ApolloError) {}\n\n  private observable: ObservableQuery<TData, TVariables>;\n  private obsQueryFields: Omit<\n    ObservableQueryFields<TData, TVariables>,\n    \"variables\"\n  >;\n\n  private useObservableQuery() {\n    // See if there is an existing observable that was used to fetch the same\n    // data and if so, use it instead since it will contain the proper queryId\n    // to fetch the result set. This is used during SSR.\n    const obsQuery = this.observable =\n      this.renderPromises\n        && this.renderPromises.getSSRObservable(this.watchQueryOptions)\n        || this.observable // Reuse this.observable if possible (and not SSR)\n        || this.client.watchQuery(this.getObsQueryOptions());\n\n    this.obsQueryFields = useMemo(() => ({\n      refetch: obsQuery.refetch.bind(obsQuery),\n      reobserve: obsQuery.reobserve.bind(obsQuery),\n      fetchMore: obsQuery.fetchMore.bind(obsQuery),\n      updateQuery: obsQuery.updateQuery.bind(obsQuery),\n      startPolling: obsQuery.startPolling.bind(obsQuery),\n      stopPolling: obsQuery.stopPolling.bind(obsQuery),\n      subscribeToMore: obsQuery.subscribeToMore.bind(obsQuery),\n    }), [obsQuery]);\n\n    const ssrAllowed = !(\n      this.queryHookOptions.ssr === false ||\n      this.queryHookOptions.skip\n    );\n\n    if (this.renderPromises && ssrAllowed) {\n      this.renderPromises.registerSSRObservable(obsQuery);\n\n      if (obsQuery.getCurrentResult().loading) {\n        // TODO: This is a legacy API which could probably be cleaned up\n        this.renderPromises.addObservableQueryPromise(obsQuery);\n      }\n    }\n\n    return obsQuery;\n  }\n\n  // These members are populated by getCurrentResult and setResult, and it's\n  // okay/normal for them to be initially undefined.\n  private result: undefined | ApolloQueryResult<TData>;\n  private previousData: undefined | TData;\n\n  private setResult(nextResult: ApolloQueryResult<TData>) {\n    const previousResult = this.result;\n    if (previousResult && previousResult.data) {\n      this.previousData = previousResult.data;\n    }\n    this.result = nextResult;\n    // Calling state.setResult always triggers an update, though some call sites\n    // perform additional equality checks before committing to an update.\n    this.forceUpdate();\n    this.handleErrorOrCompleted(nextResult);\n  }\n\n  private handleErrorOrCompleted(result: ApolloQueryResult<TData>) {\n    if (!result.loading) {\n      if (result.error) {\n        this.onError(result.error);\n      } else if (result.data) {\n        this.onCompleted(result.data);\n      }\n    }\n  }\n\n  private getCurrentResult(): ApolloQueryResult<TData> {\n    // Using this.result as a cache ensures getCurrentResult continues returning\n    // the same (===) result object, unless state.setResult has been called, or\n    // we're doing server rendering and therefore override the result below.\n    if (!this.result) {\n      this.handleErrorOrCompleted(\n        this.result = this.observable.getCurrentResult()\n      );\n    }\n    return this.result;\n  }\n\n  // This cache allows the referential stability of this.result (as returned by\n  // getCurrentResult) to translate into referential stability of the resulting\n  // QueryResult object returned by toQueryResult.\n  private toQueryResultCache = new (canUseWeakMap ? WeakMap : Map)<\n    ApolloQueryResult<TData>,\n    QueryResult<TData, TVariables>\n  >();\n\n  toQueryResult(\n    result: ApolloQueryResult<TData>,\n  ): QueryResult<TData, TVariables> {\n    let queryResult = this.toQueryResultCache.get(result);\n    if (queryResult) return queryResult;\n\n    const { data, partial, ...resultWithoutPartial } = result;\n    this.toQueryResultCache.set(result, queryResult = {\n      data, // Ensure always defined, even if result.data is missing.\n      ...resultWithoutPartial,\n      ...this.obsQueryFields,\n      client: this.client,\n      observable: this.observable,\n      variables: this.observable.variables,\n      called: !this.queryHookOptions.skip,\n      previousData: this.previousData,\n    });\n\n    if (!queryResult.error && isNonEmptyArray(result.errors)) {\n      // Until a set naming convention for networkError and graphQLErrors is\n      // decided upon, we map errors (graphQLErrors) to the error options.\n      // TODO: Is it possible for both result.error and result.errors to be\n      // defined here?\n      queryResult.error = new ApolloError({ graphQLErrors: result.errors });\n    }\n\n    return queryResult;\n  }\n\n  private unsafeHandlePartialRefetch(result: ApolloQueryResult<TData>) {\n    // WARNING: SIDE-EFFECTS IN THE RENDER FUNCTION\n    //\n    // TODO: This code should be removed when the partialRefetch option is\n    // removed. I was unable to get this hook to behave reasonably in certain\n    // edge cases when this block was put in an effect.\n    if (\n      result.partial &&\n      this.queryHookOptions.partialRefetch &&\n      !result.loading &&\n      (!result.data || Object.keys(result.data).length === 0) &&\n      this.observable.options.fetchPolicy !== 'cache-only'\n    ) {\n      Object.assign(result, {\n        loading: true,\n        networkStatus: NetworkStatus.refetch,\n      });\n      this.observable.refetch();\n    }\n  }\n}\n","import { invariant } from '../../utilities/globals';\nimport { useContext } from 'react';\nimport { ApolloClient } from '../../core';\nimport { getApolloContext } from '../context';\n\nexport function useApolloClient(\n  override?: ApolloClient<object>,\n): ApolloClient<object> {\n  const context = useContext(getApolloContext());\n  const client = override || context.client;\n  invariant(\n    !!client,\n    'Could not find \"client\" in the context or passed in as an option. ' +\n    'Wrap the root component in an <ApolloProvider>, or pass an ApolloClient ' +\n    'instance in via options.',\n  );\n\n  return client;\n}\n"],"names":["SeparatorStyled","styled","pxToRem","theme","colors","primary","phone","Separator","HeroTitle","clampValues","HeroSubTitle","HomeRecapContainer","QuestionContainer","tablet","Question","fontSize","Answer","ContactLink","CTAContainer","t","useTranslation","open","useGlobalModal","loading","error","data","useHomapge","dangerouslySetInnerHTML","__html","develop","design","homepage","homepageFields","currentOccupation","currentResidence","availableForHire","onClick","to","didWarnUncachedGetSnapshot","useSyncExternalStore","React","subscribe","getSnapshot","getServerSnapshot","value","__DEV__","invariant","inst","forceUpdate","canUseLayoutEffect","Object","assign","checkIfSnapshotChanged","_a","DocumentType","cache","Map","operationName","type","name","Query","Mutation","Subscription","verifyDocumentType","document","operation","variables","cached","get","concat","fragments","queries","mutations","subscriptions","definitions","_i","x","kind","push","length","definition","variableDefinitions","payload","requiredOperationName","hasOwnProperty","useQuery","query","options","create","client","stateRef","useRef","current","InternalState","state","useState","setTick","tick","useInternalState","override","context","useContext","getApolloContext","useApolloClient","previous","asyncResolveFns","Set","optionsToIgnoreOnce","canUseWeakSet","WeakSet","ssrDisabledResult","maybeDeepFreeze","networkStatus","NetworkStatus","skipStandbyResult","toQueryResultCache","canUseWeakMap","WeakMap","previousResult","result","previousData","this","Promise","resolve","_this","add","watchQueryOptions","renderPromises","useOptions","obsQuery","useObservableQuery","useCallback","onNext","getCurrentResult","equal","setResult","onError","last","subscription","unsubscribe","resetLastResults","call","disableNetworkFetches","unsafeHandlePartialRefetch","queryResult","toQueryResult","size","forEach","clear","createWatchQueryOptions","queryHookOptions","currentWatchQueryOptions","has","observable","delete","reobserve","getObsQueryOptions","onCompleted","prototype","ssr","skip","fetchPolicy","toMerge","globalDefaults","defaultOptions","watchQuery","compact","reduce","mergeOptions","otherOptions","getDefaultFetchPolicy","_c","_d","initialFetchPolicy","_b","getSSRObservable","obsQueryFields","useMemo","refetch","bind","fetchMore","updateQuery","startPolling","stopPolling","subscribeToMore","ssrAllowed","registerSSRObservable","addObservableQueryPromise","nextResult","handleErrorOrCompleted","resultWithoutPartial","set","called","isNonEmptyArray","errors","ApolloError","graphQLErrors","partial","partialRefetch","keys"],"sourceRoot":""}