Chrometober बनाया जा रहा है!

इस Chrometober में, स्क्रोल करने वाली किताब को मज़ेदार और डरावने सुझाव और तरकीबें शेयर करने के लिए कैसे इस्तेमाल किया गया.

Designcember के बाद, हम इस साल आपके लिए Chrometober बनाना चाहते थे. इसका मकसद, कम्यूनिटी और Chrome टीम के वेब कॉन्टेंट को हाइलाइट और शेयर करना था. Designcember में, कंटेनर क्वेरी के इस्तेमाल को दिखाया गया था. हालांकि, इस साल हम सीएसएस स्क्रोल-लिंक किए गए ऐनिमेशन एपीआई को दिखा रहे हैं.

web.dev/chrometober-2022 पर जाकर, स्क्रोल करके पढ़ी जाने वाली किताब का अनुभव देखें.

खास जानकारी

इस प्रोजेक्ट का मकसद, स्क्रोल-लिंक किए गए ऐनिमेशन एपीआई को हाइलाइट करते हुए, एक मज़ेदार अनुभव देना था. हालांकि, इस अनुभव को मज़ेदार बनाने के साथ-साथ, रिस्पॉन्सिव और ऐक्सेस करने लायक बनाना भी ज़रूरी था. इस प्रोजेक्ट की मदद से, एपीआई polyfill को टेस्ट करने का भी मौका मिला. इस पर अब भी डेवलपमेंट का काम चल रहा है. साथ ही, अलग-अलग तकनीकों और टूल को एक साथ इस्तेमाल करने का भी मौका मिला. इन सभी को हैलोवीन की थीम के साथ आज़माएं!

हमारी टीम का स्ट्रक्चर कुछ ऐसा था:

स्क्रॉलीटेलिंग अनुभव का ड्राफ़्ट तैयार करना

Chrometober के आइडिया, मई 2022 में हमारी टीम की पहली ऑफ़साइट मीटिंग में आने शुरू हुए. स्क्रैचपैड पर बनाए गए कई स्केच को देखकर, हमें यह आइडिया आया कि उपयोगकर्ता को किसी स्टोरीबोर्ड पर स्क्रोल करने का विकल्प दिया जा सकता है. वीडियो गेम से प्रेरित होकर, हमने कब्रिस्तान और भूतिया घर जैसे सीन के ज़रिए स्क्रोल करने का अनुभव देने के बारे में सोचा.

डेस्क पर एक नोटबुक रखी है, जिसमें प्रोजेक्ट से जुड़े कई डूडल और स्क्रिबल हैं.

मुझे अपने पहले Google प्रोजेक्ट को एक अलग दिशा में ले जाने की क्रिएटिव आज़ादी मिली, जो मेरे लिए काफ़ी रोमांचक था. यह एक शुरुआती प्रोटोटाइप था, जिससे पता चलता था कि कोई उपयोगकर्ता कॉन्टेंट को कैसे नेविगेट कर सकता है.

जब उपयोगकर्ता साइड में स्क्रोल करता है, तो ब्लॉक घूमते हैं और बड़े हो जाते हैं. हालांकि, मैंने इस आइडिया को छोड़ दिया, क्योंकि मुझे इस बात की चिंता थी कि हम हर साइज़ के डिवाइसों पर उपयोगकर्ताओं को बेहतर अनुभव कैसे दे सकते हैं. इसके बजाय, मैंने पहले बनाए गए किसी डिज़ाइन का इस्तेमाल किया. साल 2020 में, मुझे रिलीज़ डेमो बनाने के लिए GreenSock के ScrollTrigger का ऐक्सेस मिला.

मैंने जो डेमो बनाए थे उनमें से एक 3D-CSS बुक थी. इसमें स्क्रोल करने पर पेज पलटते थे. यह Chrometober के लिए हमारी ज़रूरत के हिसाब से ज़्यादा सही था. स्क्रोल-लिंक्ड ऐनिमेशन एपीआई, इस सुविधा का एक बेहतरीन विकल्प है. यह scroll-snap के साथ भी अच्छी तरह से काम करता है, जैसा कि आपको दिखेगा!

इस प्रोजेक्ट के लिए हमारे इलस्ट्रेटर, टायलर रीड ने हमारे आइडिया के हिसाब से डिज़ाइन में बदलाव करने में बेहतरीन काम किया. टायलर ने सभी क्रिएटिव आइडिया को हकीकत में बदलने का शानदार काम किया. साथ मिलकर आइडिया पर सोच-विचार करना बहुत मज़ेदार था. हम चाहते थे कि इस सुविधा को इस तरह से डिज़ाइन किया जाए कि इसके अलग-अलग फ़ंक्शन, अलग-अलग ब्लॉक में बंटे हों. इस तरह, हम उन्हें सीन में कंपोज़ कर सकते थे. इसके बाद, हम चुन सकते थे कि हमें क्या दिखाना है.

एक सीन में सांप, एक ताबूत जिससे हाथ बाहर निकल रहे हैं, एक लोमड़ी जिसके हाथ में छड़ी है और वह कड़ाही के पास खड़ी है, एक डरावने चेहरे वाला पेड़, और एक गार्गोयल जिसके हाथ में कद्दू वाली लालटेन है.

इसके पीछे मुख्य आइडिया यह था कि जैसे-जैसे उपयोगकर्ता किताब को पढ़ता जाए, वैसे-वैसे उसे कॉन्टेंट के ब्लॉक का ऐक्सेस मिलता जाए. वे मज़ेदार चीज़ों के साथ भी इंटरैक्ट कर सकते थे. इनमें ईस्टर एग भी शामिल थे, जिन्हें हमने इस अनुभव में शामिल किया था. उदाहरण के लिए, किसी भूतिया घर में मौजूद एक पोर्ट्रेट, जिसकी आंखें आपके पॉइंटर को फ़ॉलो करती थीं या मीडिया क्वेरी से ट्रिगर होने वाले छोटे-छोटे ऐनिमेशन. स्क्रोल करने पर, ये आइडिया और सुविधाएं ऐनिमेट होंगी. शुरुआती आइडिया में, एक ज़ॉम्बी बनी को दिखाया गया था. यह बनी, उपयोगकर्ता के स्क्रोल करने पर ऊपर की ओर बढ़ता था और x-ऐक्सिस के साथ-साथ आगे बढ़ता था.

एपीआई के बारे में जानकारी

अलग-अलग सुविधाओं और ईस्टर एग के साथ खेलने से पहले, हमें एक किताब की ज़रूरत थी. इसलिए, हमने इसे एक मौके के तौर पर इस्तेमाल करने का फ़ैसला किया. हमने सीएसएस स्क्रोल-लिंक्ड ऐनिमेशन एपीआई के लिए, सुविधाओं के सेट को टेस्ट किया. यह एपीआई, अब काफ़ी लोकप्रिय हो रहा है. फ़िलहाल, स्क्रोल-लिंक किए गए ऐनिमेशन एपीआई का इस्तेमाल किसी भी ब्राउज़र में नहीं किया जा सकता. हालांकि, एपीआई को डेवलप करते समय, इंटरैक्शन टीम के इंजीनियर पॉलीफ़िल पर काम कर रहे हैं. इससे एपीआई के डेवलपमेंट के दौरान, उसके आकार को टेस्ट करने का तरीका मिलता है. इसका मतलब है कि हम इस एपीआई का इस्तेमाल आज ही कर सकते हैं. इस तरह के मज़ेदार प्रोजेक्ट, एक्सपेरिमेंट के तौर पर उपलब्ध सुविधाओं को आज़माने और सुझाव देने के लिए बेहतरीन जगह होते हैं. इस लेख में आगे जानें कि हमने क्या सीखा और हम क्या सुझाव दे पाए.

इस एपीआई का इस्तेमाल करके, ऐनिमेशन को स्क्रोल से लिंक किया जा सकता है. यह ध्यान रखना ज़रूरी है कि स्क्रोल करने पर ऐनिमेशन ट्रिगर नहीं किया जा सकता. हालांकि, यह सुविधा बाद में उपलब्ध हो सकती है. स्क्रोल-लिंक किए गए ऐनिमेशन भी दो मुख्य कैटगरी में आते हैं:

  1. स्क्रोल पोज़िशन पर प्रतिक्रिया देने वाले एलिमेंट.
  2. ऐसे ऐनिमेशन जो स्क्रोलिंग कंटेनर में किसी एलिमेंट की पोज़िशन के हिसाब से ट्रिगर होते हैं.

इसे बनाने के लिए, हम animation-timeline प्रॉपर्टी की मदद से लागू किए गए ViewTimeline का इस्तेमाल करते हैं.

यहां एक उदाहरण दिया गया है, जिसमें सीएसएस में ViewTimeline का इस्तेमाल किया गया है:

.element-moving-in-viewport {
  view-timeline-name: foo;
  view-timeline-axis: block;
}

.element-scroll-linked {
  animation: rotate both linear;
  animation-timeline: foo;
  animation-delay: enter 0%;
  animation-end-delay: cover 50%;
}

@keyframes rotate {
 to {
   rotate: 360deg;
 }
}

हम view-timeline-name का इस्तेमाल करके ViewTimeline बनाते हैं और इसके लिए ऐक्सिस तय करते हैं. इस उदाहरण में, block का मतलब लॉजिकल block से है. animation-timeline प्रॉपर्टी की मदद से, ऐनिमेशन को स्क्रोल से लिंक किया जाता है. animation-delay और animation-end-delay (इस लेख को लिखे जाने के समय) के हिसाब से, हम फ़ेज़ तय करते हैं.

इन फ़ेज़ से पता चलता है कि स्क्रोलिंग कंटेनर में किसी एलिमेंट की पोज़िशन के हिसाब से, ऐनिमेशन को किन पॉइंट पर लिंक किया जाना चाहिए. हमारे उदाहरण में, हम कह रहे हैं कि जब एलिमेंट, स्क्रोलिंग कंटेनर (enter 0%) में शामिल हो, तब ऐनिमेशन शुरू करें. जब स्क्रोलिंग कंटेनर का 50% (cover 50%) हिस्सा कवर हो जाए, तब इसे खत्म करें.

यहां हमारा डेमो देखें:

व्यूपोर्ट में मूव होने वाले एलिमेंट से, किसी ऐनिमेशन को भी लिंक किया जा सकता है. ऐसा करने के लिए, animation-timeline को एलिमेंट के view-timeline के तौर पर सेट करें. यह तरीका, सूची वाले ऐनिमेशन जैसी स्थितियों के लिए अच्छा है. यह तरीका, IntersectionObserver का इस्तेमाल करके, एंट्री के समय एलिमेंट को ऐनिमेट करने के तरीके से मिलता-जुलता है.

element-moving-in-viewport {
  view-timeline-name: foo;
  view-timeline-axis: block;
  animation: scale both linear;
  animation-delay: enter 0%;
  animation-end-delay: cover 50%;
  animation-timeline: foo;
}

@keyframes scale {
  0% {
    scale: 0;
  }
}

इससे, व्यूपोर्ट में आते ही "Mover" का साइज़ बढ़ जाता है. इससे "Spinner" घूमने लगता है.

एक्सपेरिमेंट करने पर मुझे पता चला कि यह एपीआई, scroll-snap के साथ बहुत अच्छी तरह से काम करता है. ViewTimeline के साथ स्क्रोल-स्नैप का इस्तेमाल करने से, किसी किताब के पेज पलटने में आसानी होगी.

गेम के मैकेनिक्स का प्रोटोटाइप बनाना

कुछ प्रयोगों के बाद, मैं किताब का प्रोटोटाइप बनाने में कामयाब रहा. किताब के पेज पलटने के लिए, हॉरिज़ॉन्टल तौर पर स्क्रोल किया जाता है.

डेमो में, आपको डैश वाली बॉर्डर से हाइलाइट किए गए अलग-अलग ट्रिगर दिखेंगे.

मार्कअप कुछ ऐसा दिखता है:

<body>
  <div class="book-placeholder">
    <ul class="book" style="--count: 7;">
      <li
        class="page page--cover page--cover-front"
        data-scroll-target="1"
        style="--index: 0;"
      >
        <div class="page__paper">
          <div class="page__side page__side--front"></div>
          <div class="page__side page__side--back"></div>
        </div>
      </li>
      <!-- Markup for other pages here -->
    </ul>
  </div>
  <div>
    <p>intro spacer</p>
  </div>
  <div data-scroll-intro>
    <p>scale trigger</p>
  </div>
  <div data-scroll-trigger="1">
    <p>page trigger</p>
  </div>
  <!-- Markup for other triggers here -->
</body>

स्क्रोल करने पर, किताब के पेज पलटते हैं. हालांकि, वे स्नैप होकर खुलते या बंद होते हैं. यह ट्रिगर के स्क्रोल-स्नैप अलाइनमेंट पर निर्भर करता है.

html {
  scroll-snap-type: x mandatory;
}

body {
  grid-template-columns: repeat(var(--trigger-count), auto);
  overflow-y: hidden;
  overflow-x: scroll;
  display: grid;
}

body > [data-scroll-trigger] {
  height: 100vh;
  width: clamp(10rem, 10vw, 300px);
}

body > [data-scroll-trigger] {
  scroll-snap-align: end;
}

इस बार, हम सीएसएस में ViewTimeline को कनेक्ट नहीं करेंगे. इसके बजाय, JavaScript में Web Animations API का इस्तेमाल करेंगे. इसका एक और फ़ायदा यह है कि हम एलिमेंट के सेट को लूप करके, अपनी ज़रूरत के मुताबिक ViewTimeline जनरेट कर सकते हैं. इसके लिए, हमें हर एलिमेंट को मैन्युअल तरीके से बनाने की ज़रूरत नहीं पड़ती.

const triggers = document.querySelectorAll("[data-scroll-trigger]")

const commonProps = {
  delay: { phase: "enter", percent: CSS.percent(0) },
  endDelay: { phase: "enter", percent: CSS.percent(100) },
  fill: "both"
}

const setupPage = (trigger, index) => {
  const target = document.querySelector(
    `[data-scroll-target="${trigger.getAttribute("data-scroll-trigger")}"]`
  );

  const viewTimeline = new ViewTimeline({
    subject: trigger,
    axis: 'inline',
  });

  target.animate(
    [
      {
        transform: `translateZ(${(triggers.length - index) * 2}px)`
      },
      {
        transform: `translateZ(${(triggers.length - index) * 2}px)`,
        offset: 0.75
      },
      {
        transform: `translateZ(${(triggers.length - index) * -1}px)`
      }
    ],
    {
      timeline: viewTimeline,
      …commonProps,
    }
  );
  target.querySelector(".page__paper").animate(
    [
      {
        transform: "rotateY(0deg)"
      },
      {
        transform: "rotateY(-180deg)"
      }
    ],
    {
      timeline: viewTimeline,
      …commonProps,
    }
  );
};

const triggers = document.querySelectorAll('[data-scroll-trigger]')
triggers.forEach(setupPage);

हम हर ट्रिगर के लिए, एक ViewTimeline जनरेट करते हैं. इसके बाद, हम उस ViewTimeline का इस्तेमाल करके, ट्रिगर से जुड़े पेज को ऐनिमेट करते हैं. इससे पेज के ऐनिमेशन को स्क्रोल से लिंक किया जाता है. ऐनिमेशन के लिए, हम पेज के किसी एलिमेंट को y-ऐक्सिस पर घुमा रहे हैं, ताकि पेज को पलटा जा सके. हम पेज को z-ऐक्सिस पर भी ट्रांसलेट करते हैं, ताकि वह किताब की तरह काम करे.

जानकारी को एक जगह इकट्ठा किया जा रहा है

किताब का मैकेनिज़्म तैयार करने के बाद, मैंने टायलर के इलस्ट्रेशन को जीवंत बनाने पर ध्यान दिया.

एस्ट्रो

टीम ने 2021 में Designcember के लिए Astro का इस्तेमाल किया था. मैं Chrometober के लिए भी इसका इस्तेमाल करना चाहता था. डेवलपर के लिए, चीज़ों को कॉम्पोनेंट में बांटने का अनुभव इस प्रोजेक्ट के लिए काफ़ी सही है.

किताब खुद एक कॉम्पोनेंट है. यह पेज के कॉम्पोनेंट का कलेक्शन भी है. हर पेज के दो साइड होते हैं और उनमें बैकड्रॉप होते हैं. पेज साइड के चाइल्ड कॉम्पोनेंट को आसानी से जोड़ा, हटाया, और पोज़िशन किया जा सकता है.

किताब बनाना

मेरे लिए यह ज़रूरी था कि ब्लॉक को मैनेज करना आसान हो. मैं यह भी चाहती थी कि टीम के बाकी सदस्यों के लिए, योगदान देना आसान हो.

हाई लेवल पर पेजों को कॉन्फ़िगरेशन कलेक्शन से तय किया जाता है. कलेक्शन में मौजूद हर पेज ऑब्जेक्ट, किसी पेज के कॉन्टेंट, बैकड्रॉप, और अन्य मेटाडेटा के बारे में बताता है.

const pages = [
  {
    front: {
      marked: true,
      content: PageTwo,
      backdrop: spreadOne,
      darkBackdrop: spreadOneDark
    },
    back: {
      content: PageThree,
      backdrop: spreadTwo,
      darkBackdrop: spreadTwoDark
    },
    aria: `page 1`
  },
  /* Obfuscated page objects */
]

इन्हें Book कॉम्पोनेंट को पास किया जाता है.

<Book pages={pages} />

Book कॉम्पोनेंट में स्क्रोल करने का तरीका लागू किया जाता है और किताब के पेज बनाए जाते हैं. प्रोटोटाइप वाला तरीका ही इस्तेमाल किया जाता है. हालांकि, हम दुनिया भर में बनाए गए ViewTimeline के कई इंस्टेंस शेयर करते हैं.

window.CHROMETOBER_TIMELINES.push(viewTimeline);

इस तरह, हम टाइमलाइन को फिर से बनाने के बजाय, उन्हें कहीं और इस्तेमाल करने के लिए शेयर कर सकते हैं. इस विषय पर ज़्यादा जानकारी बाद में.

पेज कंपोज़िशन

हर पेज, सूची में मौजूद एक आइटम होता है:

<ul class="book">
  {
    pages.map((page, index) => {
      const FrontSlot = page.front.content
      const BackSlot = page.back.content
      return (
        <Page
          index={index}
          cover={page.cover}
          aria={page.aria}
          backdrop={
            {
              front: {
                light: page.front.backdrop,
                dark: page.front.darkBackdrop
              },
              back: {
                light: page.back.backdrop,
                dark: page.back.darkBackdrop
              }
            }
          }>
          {page.front.content && <FrontSlot slot="front" />}    
          {page.back.content && <BackSlot slot="back" />}    
        </Page>
      )
    })
  }
</ul>

साथ ही, तय किया गया कॉन्फ़िगरेशन हर Page इंस्टेंस को पास कर दिया जाता है. हर पेज में कॉन्टेंट डालने के लिए, Astro की स्लॉट सुविधा का इस्तेमाल किया जाता है.

<li
  class={className}
  data-scroll-target={target}
  style={`--index:${index};`}
  aria-label={aria}
>
  <div class="page__paper">
    <div
      class="page__side page__side--front"
      aria-label={`Right page of ${index}`}
    >
      <picture>
        <source
          srcset={darkFront}
          media="(prefers-color-scheme: dark)"
          height="214"
          width="150"
        >
        <img
          src={lightFront}
          class="page__background page__background--right"
          alt=""
          aria-hidden="true"
          height="214"
          width="150"
        >
      </picture>
      <div class="page__content">
        <slot name="front" />
      </div>
    </div>
    <!-- Markup for back page -->
  </div>
</li>

यह कोड, ज़्यादातर स्ट्रक्चर सेट अप करने के लिए होता है. योगदान देने वाले लोग, इस कोड में बदलाव किए बिना ही किताब के कॉन्टेंट पर काम कर सकते हैं.

बैकड्रॉप

किताब के फ़ॉर्मैट में बदलाव करने से, सेक्शन को बांटना काफ़ी आसान हो गया. साथ ही, किताब के हर स्प्रेड में ओरिजनल डिज़ाइन से लिया गया एक सीन है.

किताब के पेज स्प्रेड का इलस्ट्रेशन, जिसमें कब्रिस्तान में सेब का पेड़ दिखाया गया है. कब्रिस्तान में कई हेडस्टोन हैं. साथ ही, आसमान में एक बड़ा चांद है और उसके सामने एक चमगादड़ है.

हमने किताब के लिए एक आसपेक्ट रेशियो (लंबाई-चौड़ाई का अनुपात) तय किया था. इसलिए, हर पेज के बैकड्रॉप में एक पिक्चर एलिमेंट हो सकता था. उस एलिमेंट की चौड़ाई को 200% पर सेट करने और पेज के साइड के हिसाब से object-position का इस्तेमाल करने से, यह समस्या हल हो जाती है.

.page__background {
  height: 100%;
  width: 200%;
  object-fit: cover;
  object-position: 0 0;
  position: absolute;
  top: 0;
  left: 0;
}

.page__background--right {
  object-position: 100% 0;
}

पेज का कॉन्टेंट

आइए, एक पेज बनाने का तरीका देखते हैं. तीसरे पेज पर एक उल्लू है, जो पेड़ से पॉप-अप होता है.

कॉन्फ़िगरेशन में तय किए गए तरीके के मुताबिक, इसमें PageThree कॉम्पोनेंट अपने-आप भर जाता है. यह एक Astro कॉम्पोनेंट (PageThree.astro) है. ये कॉम्पोनेंट, एचटीएमएल फ़ाइलों की तरह दिखते हैं. हालांकि, इनमें सबसे ऊपर एक कोड फ़ेंस होता है, जो फ़्रंटमैटर जैसा होता है. इससे हम अन्य कॉम्पोनेंट इंपोर्ट करने जैसे काम कर पाते हैं. तीसरे पेज का कॉम्पोनेंट कुछ ऐसा दिखेगा:

---
import TreeOwl from '../TreeOwl/TreeOwl.astro'
import { contentBlocks } from '../../assets/content-blocks.json'
import ContentBlock from '../ContentBlock/ContentBlock.astro'
---
<TreeOwl/>
<ContentBlock {...contentBlocks[3]} id="four" />

<style is:global>
  .content-block--four {
    left: 30%;
    bottom: 10%;
  }
</style>

पेज, ऐटॉमिक होते हैं. इन्हें कई सुविधाओं को मिलाकर बनाया जाता है. तीसरे पेज पर एक कॉन्टेंट ब्लॉक और इंटरैक्टिव उल्लू है. इसलिए, हर एक के लिए एक कॉम्पोनेंट है.

कॉन्टेंट ब्लॉक, किताब में मौजूद कॉन्टेंट के लिंक होते हैं. ये भी कॉन्फ़िगरेशन ऑब्जेक्ट से कंट्रोल होते हैं.

{
 "contentBlocks": [
    {
      "id": "one",
      "title": "New in Chrome",
      "blurb": "Lift your spirits with a round up of all the tools and features in Chrome.",
      "link": "https://www.youtube.com/watch?v=qwdN1fJA_d8&list=PLNYkxOF6rcIDfz8XEA3loxY32tYh7CI3m"
    },
    …otherBlocks
  ]
}

यह कॉन्फ़िगरेशन वहां इंपोर्ट किया जाता है जहां कॉन्टेंट ब्लॉक की ज़रूरत होती है. इसके बाद, ब्लॉक का ज़रूरी कॉन्फ़िगरेशन ContentBlock कॉम्पोनेंट को पास कर दिया जाता है.

<ContentBlock {...contentBlocks[3]} id="four" />

यहां एक उदाहरण भी दिया गया है, जिसमें बताया गया है कि हम कॉन्टेंट को दिखाने के लिए, पेज के कॉम्पोनेंट का इस्तेमाल कैसे करते हैं. यहां कॉन्टेंट ब्लॉक को रखा जाता है.

<style is:global>
  .content-block--four {
    left: 30%;
    bottom: 10%;
  }
</style>

हालांकि, कॉन्टेंट ब्लॉक की सामान्य स्टाइल, कॉम्पोनेंट कोड के साथ ही मौजूद होती हैं.

.content-block {
  background: hsl(0deg 0% 0% / 70%);
  color: var(--gray-0);
  border-radius:  min(3vh, var(--size-4));
  padding: clamp(0.75rem, 2vw, 1.25rem);
  display: grid;
  gap: var(--size-2);
  position: absolute;
  cursor: pointer;
  width: 50%;
}

उल्लू की बात करें, तो यह एक इंटरैक्टिव सुविधा है. इस प्रोजेक्ट में ऐसी कई सुविधाएं हैं. यह एक छोटा सा उदाहरण है, जिससे पता चलता है कि हमने शेयर किए गए ViewTimeline का इस्तेमाल कैसे किया.

हाई लेवल पर, हमारा उल्लू कॉम्पोनेंट कुछ SVG इंपोर्ट करता है और Astro के फ़्रैगमेंट का इस्तेमाल करके उन्हें इनलाइन करता है.

---
import { default as Owl } from '../Features/Owl.svg?raw'
---
<Fragment set:html={Owl} />

उल्लू की पोज़िशनिंग के लिए स्टाइल, कॉम्पोनेंट कोड के साथ ही मौजूद हैं.

.owl {
  width: 34%;
  left: 10%;
  bottom: 34%;
}

स्टाइलिंग का एक और हिस्सा है, जो उल्लू के लिए transform के व्यवहार को तय करता है.

.owl__owl {
  transform-origin: 50% 100%;
  transform-box: fill-box;
}

transform-box का इस्तेमाल करने से, transform-origin पर असर पड़ता है. यह एसवीजी में ऑब्जेक्ट के बाउंडिंग बॉक्स के हिसाब से होता है. उल्लू, नीचे के बीच वाले हिस्से से बड़ा होता है. इसलिए, transform-origin: 50% 100% का इस्तेमाल किया गया है.

मज़ेदार बात यह है कि जब हम उल्लू को जनरेट किए गए ViewTimeline से लिंक करते हैं, तो:

const setUpOwl = () => {
   const owl = document.querySelector('.owl__owl');

   owl.animate([
     {
       translate: '0% 110%',
     },
     {
       translate: '0% 10%',
     },
   ], {
     timeline: CHROMETOBER_TIMELINES[1],
     delay: { phase: "enter", percent: CSS.percent(80) },
     endDelay: { phase: "enter", percent: CSS.percent(90) },
     fill: 'both' 
   });
 }

 if (window.matchMedia('(prefers-reduced-motion: no-preference)').matches)
   setUpOwl()

कोड के इस ब्लॉक में, हम दो काम करते हैं:

  1. उपयोगकर्ता की मोशन से जुड़ी प्राथमिकताओं की जांच करें.
  2. अगर उन्हें कोई विकल्प नहीं चुनना है, तो उल्लू के ऐनिमेशन को स्क्रोल करने के लिए लिंक करें.

दूसरे हिस्से के लिए, उल्लू को Web Animations API का इस्तेमाल करके, y-ऐक्सिस पर ऐनिमेट किया जाता है. अलग-अलग ट्रांसफ़ॉर्म प्रॉपर्टी translate का इस्तेमाल किया गया है और इसे एक ViewTimeline से लिंक किया गया है. यह timeline प्रॉपर्टी के ज़रिए CHROMETOBER_TIMELINES[1] से लिंक है. यह एक ViewTimeline है, जो पेज पलटने के लिए जनरेट किया जाता है. इससे उल्लू का ऐनिमेशन, enter फ़ेज़ का इस्तेमाल करके पेज पलटने से लिंक हो जाता है. इससे यह तय होता है कि जब पेज 80% पलट जाए, तब उल्लू को मूव करना शुरू करें. 90% पर, उल्लू को अनुवाद पूरा कर लेना चाहिए.

किताब की सुविधाएं

अब आपने पेज बनाने का तरीका और प्रोजेक्ट आर्किटेक्चर के काम करने का तरीका देख लिया है. इससे योगदान देने वाले लोग, अपनी पसंद के पेज या सुविधा पर काम कर सकते हैं. किताब की कई सुविधाओं के ऐनिमेशन, किताब के पेज पलटने से जुड़े होते हैं. उदाहरण के लिए, पेज पलटने पर चमगादड़ का उड़ना और वापस आना.

इसमें ऐसे एलिमेंट भी होते हैं जो सीएसएस ऐनिमेशन की मदद से काम करते हैं.

किताब में कॉन्टेंट ब्लॉक जोड़ने के बाद, अन्य सुविधाओं का इस्तेमाल करके क्रिएटिविटी दिखाने का समय था. इससे हमें कुछ अलग तरह के इंटरैक्शन जनरेट करने और चीज़ों को लागू करने के अलग-अलग तरीके आज़माने का मौका मिला.

रिस्पॉन्सिव डिज़ाइन का इस्तेमाल करना

रिस्पॉन्सिव व्यूपोर्ट यूनिट, किताब और उसकी सुविधाओं का साइज़ तय करती हैं. हालांकि, फ़ॉन्ट को रिस्पॉन्सिव बनाए रखना एक दिलचस्प चुनौती थी. यहां कंटेनर क्वेरी यूनिट का इस्तेमाल करना सही रहेगा. हालांकि, फ़िलहाल ये हर जगह उपलब्ध नहीं हैं. किताब का साइज़ सेट है, इसलिए हमें कंटेनर क्वेरी की ज़रूरत नहीं है. CSS calc() की मदद से, इनलाइन कंटेनर क्वेरी यूनिट जनरेट की जा सकती है. इसका इस्तेमाल, फ़ॉन्ट का साइज़ तय करने के लिए किया जा सकता है.


.book-placeholder {
  --size: clamp(12rem, 72vw, 80vmin);
  --aspect-ratio: 360 / 504;
  --cqi: calc(0.01 * (var(--size) * (var(--aspect-ratio))));
}

.content-block h2 {
  color: var(--gray-0);
  font-size: clamp(0.6rem, var(--cqi) * 4, 1.5rem);
}

.content-block :is(p, a) {
  font-size: clamp(0.6rem, var(--cqi) * 3, 1.5rem);
}

रात में चमकते कद्दू

अगर आपने ध्यान दिया हो, तो पेज के बैकड्रॉप के बारे में बात करते समय, हमने <source> एलिमेंट का इस्तेमाल किया था. Una को एक ऐसा इंटरैक्शन चाहिए था जो कलर स्कीम की प्राथमिकता के हिसाब से काम करे. इस वजह से, बैकड्रॉप अलग-अलग वैरिएंट के साथ हल्के और गहरे रंग वाले मोड, दोनों के साथ काम करते हैं. <picture> एलिमेंट के साथ मीडिया क्वेरी का इस्तेमाल किया जा सकता है. इसलिए, यह बैकड्रॉप की दो स्टाइल देने का एक बेहतरीन तरीका है. <source> एलिमेंट, कलर स्कीम की प्राथमिकता के बारे में क्वेरी करता है और सही बैकड्रॉप दिखाता है.

<picture>
  <source srcset={darkFront} media="(prefers-color-scheme: dark)" height="214" width="150">
  <img src={lightFront} class="page__background page__background--right" alt="" aria-hidden="true" height="214" width="150">
</picture>

पसंद की गई कलर स्कीम के आधार पर, अन्य बदलाव भी किए जा सकते हैं. दूसरे पेज पर मौजूद कद्दू, उपयोगकर्ता की कलर स्कीम की सेटिंग के हिसाब से रंग बदलते हैं. इस्तेमाल किए गए एसवीजी में सर्कल हैं, जो आग की लपटों को दिखाते हैं. ये गहरे रंग वाले मोड में बड़े होते हैं और ऐनिमेट होते हैं.

.pumpkin__flame,
 .pumpkin__flame circle {
   transform-box: fill-box;
   transform-origin: 50% 100%;
 }

 .pumpkin__flame {
   scale: 0.8;
 }

 .pumpkin__flame circle {
   transition: scale 0.2s;
   scale: 0;
 }

@media(prefers-color-scheme: dark) {
   .pumpkin__flame {
     animation: pumpkin-flicker 3s calc(var(--index, 0) * -1s) infinite linear;
   }

   .pumpkin__flame circle {
     scale: 1;
   }

   @keyframes pumpkin-flicker {
     50% {
       scale: 1;
     }
   }
 }

क्या यह पोर्ट्रेट आपको देख रहा है?

अगर आप पेज 10 देखें, तो आपको कुछ दिख सकता है. आप पर नज़र रखी जा रही है! पेज पर इधर-उधर जाने पर, पोर्ट्रेट की आंखें आपके पॉइंटर को फ़ॉलो करेंगी. यहां ट्रिक यह है कि पॉइंटर की जगह को ट्रांसलेट वैल्यू पर मैप करें और उसे सीएसएस में पास करें.

const mapRange = (inputLower, inputUpper, outputLower, outputUpper, value) => {
   const INPUT_RANGE = inputUpper - inputLower
   const OUTPUT_RANGE = outputUpper - outputLower
   return outputLower + (((value - inputLower) / INPUT_RANGE) * OUTPUT_RANGE || 0)
 }

यह कोड, इनपुट और आउटपुट रेंज लेता है और दी गई वैल्यू को मैप करता है. उदाहरण के लिए, इस फ़ंक्शन का इस्तेमाल करने पर 625 वैल्यू मिलेगी.

mapRange(0, 100, 250, 1000, 50) // 625

पोर्ट्रेट के लिए, इनपुट वैल्यू हर आंख का सेंटर पॉइंट होती है. इसमें कुछ पिक्सल की दूरी को जोड़ा या घटाया जाता है. आउटपुट रेंज से पता चलता है कि आंखें, पिक्सल में कितना ट्रांसलेट कर सकती हैं. इसके बाद, x या y ऐक्सिस पर पॉइंटर की पोज़िशन को वैल्यू के तौर पर पास किया जाता है. आंखों को मूव करते समय उनके सेंटर पॉइंट को पाने के लिए, आंखों को डुप्लीकेट किया जाता है. ओरिजनल इमेज अपनी जगह से नहीं हटती हैं, पारदर्शी होती हैं, और रेफ़रंस के लिए इस्तेमाल की जाती हैं.

इसके बाद, इसे एक साथ जोड़ें और आंखों पर सीएसएस कस्टम प्रॉपर्टी की वैल्यू अपडेट करें, ताकि आंखें हिल सकें. window के लिए, pointermove इवेंट से एक फ़ंक्शन बाउंड है. इसके ट्रिगर होने पर, हर आंख के बाउंड का इस्तेमाल करके सेंटर पॉइंट का हिसाब लगाया जाता है. इसके बाद, पॉइंटर की पोज़िशन को उन वैल्यू पर मैप किया जाता है जो आंखों पर कस्टम प्रॉपर्टी वैल्यू के तौर पर सेट की गई हैं.

const RANGE = 15
const LIMIT = 80
const interact = ({ x, y }) => {
   // map a range against the eyes and pass in via custom properties
   const LEFT_EYE_BOUNDS = LEFT_EYE.getBoundingClientRect()
   const RIGHT_EYE_BOUNDS = RIGHT_EYE.getBoundingClientRect()

   const CENTERS = {
     lx: LEFT_EYE_BOUNDS.left + LEFT_EYE_BOUNDS.width * 0.5,
     rx: RIGHT_EYE_BOUNDS.left + RIGHT_EYE_BOUNDS.width * 0.5,
     ly: LEFT_EYE_BOUNDS.top + LEFT_EYE_BOUNDS.height * 0.5,
     ry: RIGHT_EYE_BOUNDS.top + RIGHT_EYE_BOUNDS.height * 0.5,
   }

   Object.entries(CENTERS)
     .forEach(([key, value]) => {
       const result = mapRange(value - LIMIT, value + LIMIT, -RANGE, RANGE)(key.indexOf('x') !== -1 ? x : y)
       EYES.style.setProperty(`--${key}`, result)
     })
 }

सीएसएस में वैल्यू पास होने के बाद, स्टाइल के हिसाब से उनका इस्तेमाल किया जा सकता है. यहां सबसे अच्छी बात यह है कि सीएसएस clamp() का इस्तेमाल करके, हर आंख के लिए अलग-अलग व्यवहार बनाया जा सकता है. इससे, JavaScript को फिर से छुए बिना, हर आंख को अलग-अलग व्यवहार करने के लिए बनाया जा सकता है.

.portrait__eye--mover {
   transition: translate 0.2s;
 }

 .portrait__eye--mover.portrait__eye--left {
   translate:
     clamp(-10px, var(--lx, 0) * 1px, 4px)
     clamp(-4px, var(--ly, 0) * 0.5px, 10px);
 }

 .portrait__eye--mover.portrait__eye--right {
   translate:
     clamp(-4px, var(--rx, 0) * 1px, 10px)
     clamp(-4px, var(--ry, 0) * 0.5px, 10px);
 }

जादू करना

क्या छठे पेज को देखकर आपको मंत्रमुग्ध होने का एहसास होता है? इस पेज पर, हमारी जादुई लोमड़ी का शानदार डिज़ाइन है. पॉइंटर को इधर-उधर ले जाने पर, आपको कर्सर ट्रेल का कस्टम इफ़ेक्ट दिख सकता है. इसमें कैनवस ऐनिमेशन का इस्तेमाल किया जाता है. <canvas> एलिमेंट, पेज के बाकी कॉन्टेंट के ऊपर मौजूद होता है. इसमें pointer-events: none शामिल होता है. इसका मतलब है कि उपयोगकर्ता अब भी नीचे मौजूद कॉन्टेंट ब्लॉक पर क्लिक कर सकते हैं.

.wand-canvas {
  height: 100%;
  width: 200%;
  pointer-events: none;
  right: 0;
  position: fixed;
}

जिस तरह हमारा पोर्ट्रेट, window पर pointermove इवेंट को सुनता है उसी तरह हमारा <canvas> एलिमेंट भी सुनता है. हालांकि, हर बार इवेंट ट्रिगर होने पर, हम <canvas> एलिमेंट पर ऐनिमेशन के लिए एक ऑब्जेक्ट बना रहे हैं. ये ऑब्जेक्ट, कर्सर ट्रेल में इस्तेमाल किए गए आकार दिखाते हैं. इनमें कोऑर्डिनेट और कोई भी रंग होता है.

पहले इस्तेमाल किए गए mapRange फ़ंक्शन का फिर से इस्तेमाल किया जाता है, क्योंकि हम इसका इस्तेमाल करके पॉइंटर डेल्टा को size और rate पर मैप कर सकते हैं. ऑब्जेक्ट को एक कलेक्शन में सेव किया जाता है. जब ऑब्जेक्ट को <canvas> एलिमेंट में ड्रॉ किया जाता है, तब यह कलेक्शन लूप में चलता है. हर ऑब्जेक्ट की प्रॉपर्टी, हमारे <canvas> एलिमेंट को बताती हैं कि चीज़ें कहां बनाई जानी चाहिए.

const blocks = []
  const createBlock = ({ x, y, movementX, movementY }) => {
    const LOWER_SIZE = CANVAS.height * 0.05
    const UPPER_SIZE = CANVAS.height * 0.25
    const size = mapRange(0, 100, LOWER_SIZE, UPPER_SIZE, Math.max(Math.abs(movementX), Math.abs(movementY)))
    const rate = mapRange(LOWER_SIZE, UPPER_SIZE, 1, 5, size)
    const { left, top, width, height } = CANVAS.getBoundingClientRect()
    
    const block = {
      hue: Math.random() * 359,
      x: x - left,
      y: y - top,
      size,
      rate,
    }
    
    blocks.push(block)
  }
window.addEventListener('pointermove', createBlock)

कैनवस पर ड्रॉ करने के लिए, requestAnimationFrame का इस्तेमाल करके एक लूप बनाया जाता है. कर्सर ट्रेल सिर्फ़ तब रेंडर होना चाहिए, जब पेज दिख रहा हो. हमारे पास एक IntersectionObserver है, जो अपडेट करता है और तय करता है कि कौनसे पेज दिख रहे हैं. अगर कोई पेज व्यू में है, तो ऑब्जेक्ट कैनवस पर सर्कल के तौर पर रेंडर होते हैं.

इसके बाद, हम blocks कलेक्शन को लूप करते हैं और ट्रेल के हर हिस्से को ड्रॉ करते हैं. हर फ़्रेम, ऑब्जेक्ट के साइज़ को कम करता है और उसकी पोज़िशन को rate से बदलता है. इससे गिरने और स्केल करने का इफ़ेक्ट मिलता है. अगर ऑब्जेक्ट पूरी तरह से छोटा हो जाता है, तो उसे blocks कलेक्शन से हटा दिया जाता है.

let wandFrame
const drawBlocks = () => {
   ctx.clearRect(0, 0, CANVAS.width, CANVAS.height)
  
   if (PAGE_SIX.className.indexOf('in-view') === -1 && wandFrame) {
     blocks.length = 0
     cancelAnimationFrame(wandFrame)
     document.body.removeEventListener('pointermove', createBlock)
     document.removeEventListener('resize', init)
   }
  
   for (let b = 0; b < blocks.length; b++) {
     const block = blocks[b]
     ctx.strokeStyle = ctx.fillStyle = `hsla(${block.hue}, 80%, 80%, 0.5)`
     ctx.beginPath()
     ctx.arc(block.x, block.y, block.size * 0.5, 0, 2 * Math.PI)
     ctx.stroke()
     ctx.fill()

     block.size -= block.rate
     block.y += block.rate

     if (block.size <= 0) {
       blocks.splice(b, 1)
     }

   }
   wandFrame = requestAnimationFrame(drawBlocks)
 }

अगर पेज व्यू से बाहर हो जाता है, तो इवेंट लिसनर हटा दिए जाते हैं और ऐनिमेशन फ़्रेम लूप रद्द कर दिया जाता है. blocks कलेक्शन भी मिटा दिया जाता है.

यहां कर्सर ट्रेल की सुविधा को काम करते हुए देखा जा सकता है!

सुलभता सुविधाओं की समीक्षा

एक्सप्लोर करने के लिए मज़ेदार अनुभव बनाना अच्छी बात है, लेकिन अगर उपयोगकर्ता इसे ऐक्सेस नहीं कर सकते, तो यह किसी काम का नहीं है. इस क्षेत्र में एडम की विशेषज्ञता, Chrometober को रिलीज़ करने से पहले सुलभता की समीक्षा के लिए तैयार करने में काफ़ी मददगार साबित हुई.

इनमें से कुछ खास विषयों के बारे में यहां बताया गया है:

  • यह पक्का करना कि इस्तेमाल किया गया एचटीएमएल, सिमैंटिक हो. इसमें किताब के लिए <main> जैसे सही लैंडमार्क एलिमेंट शामिल हैं. साथ ही, हर कॉन्टेंट ब्लॉक के लिए <article> एलिमेंट और जहां संक्षिप्त नाम इस्तेमाल किए गए हैं वहां <abbr> एलिमेंट का इस्तेमाल शामिल है. किताब बनाते समय, आगे की सोच रखने से चीज़ें ज़्यादा सुलभ हो गईं. हेडिंग और लिंक का इस्तेमाल करने से, उपयोगकर्ता के लिए नेविगेट करना आसान हो जाता है. पेजों के लिए सूची का इस्तेमाल करने का मतलब यह भी है कि सहायक टेक्नोलॉजी, पेजों की संख्या की जानकारी देती है.
  • यह पक्का करना कि सभी इमेज में सही alt एट्रिब्यूट का इस्तेमाल किया गया हो. इनलाइन एसवीजी के लिए, जहां ज़रूरी हो वहां title एलिमेंट मौजूद हो.
  • aria एट्रिब्यूट का इस्तेमाल वहां करना जहां वे अनुभव को बेहतर बनाते हैं. पेजों और उनके किनारों के लिए aria-label का इस्तेमाल करने से, उपयोगकर्ता को पता चलता है कि वह किस पेज पर है. "ज़्यादा पढ़ें" लिंक पर aria-describedBy का इस्तेमाल करने से, कॉन्टेंट ब्लॉक के टेक्स्ट के बारे में पता चलता है. इससे यह साफ़ हो जाता है कि लिंक पर क्लिक करने से उपयोगकर्ता को किस पेज पर रीडायरेक्ट किया जाएगा.
  • कॉन्टेंट ब्लॉक के मामले में, "ज़्यादा पढ़ें" लिंक के अलावा, पूरे कार्ड पर क्लिक करने की सुविधा उपलब्ध है.
  • कौनसे पेज व्यू में हैं, यह ट्रैक करने के लिए IntersectionObserver का इस्तेमाल करने के बारे में पहले बताया गया था. इसके कई फ़ायदे हैं. ये फ़ायदे सिर्फ़ परफ़ॉर्मेंस से जुड़े नहीं हैं. जो पेज नहीं दिख रहे हैं उनमें कोई भी ऐनिमेशन या इंटरैक्शन रोक दिया जाएगा. हालांकि, इन पेजों पर inert एट्रिब्यूट भी लागू होता है. इसका मतलब है कि स्क्रीन रीडर का इस्तेमाल करने वाले लोग भी उसी कॉन्टेंट को एक्सप्लोर कर सकते हैं जिसे देख सकने वाले लोग एक्सप्लोर करते हैं. फ़ोकस, व्यू में मौजूद पेज पर ही रहता है. साथ ही, उपयोगकर्ता टैब करके दूसरे पेज पर नहीं जा सकते.
  • आखिर में, हम मीडिया क्वेरी का इस्तेमाल करते हैं, ताकि मोशन के लिए उपयोगकर्ता की पसंद का ध्यान रखा जा सके.

यहां समीक्षा का एक स्क्रीनशॉट दिया गया है. इसमें, लागू किए गए कुछ उपायों को हाइलाइट किया गया है.

एलिमेंट की पहचान पूरी किताब के आस-पास के तौर पर की जाती है. इससे पता चलता है कि सहायक टेक्नोलॉजी का इस्तेमाल करने वाले लोगों के लिए, यह मुख्य लैंडमार्क होना चाहिए. स्क्रीनशॉट में ज़्यादा जानकारी दी गई है." width="800" height="465">

Chrometober बुक के खुले होने का स्क्रीनशॉट. यूज़र इंटरफ़ेस (यूआई) के अलग-अलग पहलुओं के आस-पास हरे रंग के आउटलाइन वाले बॉक्स दिए गए हैं. इनमें सुलभता से जुड़ी सुविधाओं और उपयोगकर्ता अनुभव के नतीजों के बारे में बताया गया है. उदाहरण के लिए, इमेज में वैकल्पिक टेक्स्ट होता है. इसका एक और उदाहरण है, सुलभता लेबल. इससे यह पता चलता है कि जो पेज नहीं दिख रहे हैं वे इनऐक्टिव हैं. स्क्रीनशॉट में ज़्यादा जानकारी दी गई है.

हमने क्या सीखा

Chrometober का मकसद, कम्यूनिटी के वेब कॉन्टेंट को हाइलाइट करना था. साथ ही, यह हमारे लिए स्क्रोल-लिंक किए गए ऐनिमेशन एपीआई के पॉलीफ़िल को टेस्ट करने का एक तरीका था. यह एपीआई अभी डेवलपमेंट के फ़ेज़ में है.

न्यूयॉर्क में हुई हमारी टीम समिट के दौरान, हमने प्रोजेक्ट की जांच करने और सामने आई समस्याओं को हल करने के लिए एक सेशन रखा. टीम का योगदान बहुत अहम था. यह उन सभी चीज़ों की सूची बनाने का भी एक बेहतरीन मौका था जिन्हें लाइव होने से पहले ठीक करना ज़रूरी था.

सीएसएस, यूज़र इंटरफ़ेस (यूआई), और DevTools की टीम, कॉन्फ़्रेंस रूम में टेबल के आस-पास बैठी है. ऊना एक व्हाइटबोर्ड के पास खड़ी हैं, जिस पर स्टिकी नोट लगे हैं. टीम के अन्य सदस्य, टेबल के आस-पास बैठे हैं. उनके पास लैपटॉप और खाने-पीने की चीज़ें हैं.

उदाहरण के लिए, डिवाइसों पर किताब की जांच करने से, रेंडरिंग से जुड़ी समस्या का पता चला. हमारी किताब, iOS डिवाइसों पर उम्मीद के मुताबिक रेंडर नहीं होगी. व्यूपोर्ट यूनिट, पेज का साइज़ तय करती हैं. हालांकि, नॉच होने पर किताब पर असर पड़ता था. इसका समाधान, meta व्यूपोर्ट में viewport-fit=cover का इस्तेमाल करना था:

<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover" />

इस सेशन में, एपीआई पॉलीफ़िल से जुड़ी कुछ समस्याएं भी सामने आईं. Bramus ने इन समस्याओं को polyfill रिपॉज़िटरी में उठाया. इसके बाद, उन्होंने उन समस्याओं के समाधान ढूंढे और उन्हें पॉलीफ़िल में मर्ज कर दिया. उदाहरण के लिए, इस पुल अनुरोध ने पॉलीफ़िल के कुछ हिस्से में कैश मेमोरी जोड़कर, परफ़ॉर्मेंस को बेहतर बनाया.

Chrome में खुले डेमो का स्क्रीनशॉट. डेवलपर टूल खुले हैं और बेसलाइन परफ़ॉर्मेंस मेज़रमेंट दिख रहा है.

Chrome में खुले डेमो का स्क्रीनशॉट. डेवलपर टूल खुले हैं और बेहतर परफ़ॉर्मेंस मेज़रमेंट दिखा रहे हैं.

हो गया!

इस प्रोजेक्ट पर काम करना वाकई मज़ेदार रहा. इससे हमें स्क्रोल करने का एक शानदार अनुभव मिला. इसमें कम्यूनिटी का बेहतरीन कॉन्टेंट हाइलाइट किया गया है. इतना ही नहीं, यह polyfill को टेस्ट करने के लिए भी बेहतरीन है. साथ ही, polyfill को बेहतर बनाने में मदद करने के लिए, इंजीनियरिंग टीम को सुझाव/राय देने या शिकायत करने के लिए भी यह बेहतरीन है.

Chrometober 2022 खत्म हो गया है.

हमें उम्मीद है कि आपको यह पसंद आया होगा! आपको कौनसी सुविधा सबसे ज़्यादा पसंद है? मुझे ट्वीट करें और हमें बताएं!

जे ने Chrometober के किरदारों की स्टिकर शीट पकड़ी हुई है.

अगर आप हमें किसी इवेंट में देखें, तो हो सकता है कि आपको टीम के किसी सदस्य से कुछ स्टिकर मिल जाएं.