extension-develop 2.0.0-alpha.1 → 2.0.0-alpha.10

package/dist/extensions/edge-manager-extension/reload-service.js

@@ -0,0 +1,145 @@
+const TEN_SECONDS_MS = 10 * 1000
+let webSocket = null
+
+export async function connect() {
+  if (webSocket) {
+    // If already connected, do nothing
+    return
+  }
+
+  webSocket = new WebSocket('ws://localhost:__RELOAD_PORT__')
+
+  webSocket.onerror = (event) => {
+    console.error(`[Reload Service] Connection error: ${JSON.stringify(event)}`)
+    webSocket.close()
+  }
+
+  webSocket.onopen = () => {
+    console.info(`[Reload Service] Connection opened.`)
+  }
+
+  webSocket.onmessage = async (event) => {
+    const message = JSON.parse(event.data)
+
+    if (message.status === 'serverReady') {
+      console.info('[Reload Service] Connection ready.')
+      await requestInitialLoadData()
+    }
+
+    if (message.changedFile) {
+      console.info(
+        `[Reload Service] Changes detected on ${message.changedFile}. Reloading extension...`
+      )
+
+      await messageAllExtensions(message.changedFile)
+    }
+  }
+
+  webSocket.onclose = () => {
+    console.info('[Reload Service] Connection closed.')
+    webSocket = null
+  }
+}
+
+export function disconnect() {
+  if (webSocket) {
+    webSocket.close()
+  }
+}
+
+async function getDevExtensions() {
+  const allExtensions = await new Promise((resolve) => {
+    chrome.management.getAll(resolve)
+  })
+
+  return allExtensions.filter((extension) => {
+    return (
+      // Do not include itself
+      extension.id !== chrome.runtime.id &&
+      // Manager extension
+      extension.id !== 'hkklidinfhnfidkjiknmmbmcloigimco' &&
+      // Show only unpackaged extensions
+      extension.installType === 'development'
+    )
+  })
+}
+
+async function messageAllExtensions(changedFile) {
+  // Check if the external extension is ready
+  const isExtensionReady = await checkExtensionReadiness()
+
+  if (isExtensionReady) {
+    const devExtensions = await getDevExtensions()
+    const reloadAll = devExtensions.map((extension) => {
+      chrome.runtime.sendMessage(extension.id, {changedFile}, (response) => {
+        if (response) {
+          console.info('[Reload Service] Extension reloaded and ready.')
+        }
+      })
+
+      return true
+    })
+
+    await Promise.all(reloadAll)
+  } else {
+    console.info('[Reload Service] External extension is not ready.')
+  }
+}
+
+async function requestInitialLoadData() {
+  const devExtensions = await getDevExtensions()
+
+  const messagePromises = devExtensions.map(async (extension) => {
+    return await new Promise((resolve) => {
+      chrome.runtime.sendMessage(
+        extension.id,
+        {initialLoadData: true},
+        (response) => {
+          if (chrome.runtime.lastError) {
+            console.error(
+              `Error sending message to ${extension.id}: ${chrome.runtime.lastError.message}`
+            )
+            resolve(null)
+          } else {
+            resolve(response)
+          }
+        }
+      )
+    })
+  })
+
+  const responses = await Promise.all(messagePromises)
+
+  // We received the info from the use extension.
+  // All good, client is ready. Inform the server.
+  if (webSocket && webSocket.readyState === WebSocket.OPEN) {
+    const message = JSON.stringify({
+      status: 'clientReady',
+      data: responses[0]
+    })
+
+    webSocket.send(message)
+  }
+}
+
+async function checkExtensionReadiness() {
+  // Delay for 1 second
+  await delay(1000)
+  // Assume the extension is ready
+  return true
+}
+
+async function delay(ms) {
+  return await new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export function keepAlive() {
+  const keepAliveIntervalId = setInterval(() => {
+    if (webSocket) {
+      webSocket.send(JSON.stringify({status: 'ping'}))
+      console.info('[Reload Service] Listening for changes...')
+    } else {
+      clearInterval(keepAliveIntervalId)
+    }
+  }, TEN_SECONDS_MS)
+}

package/dist/extensions/{manager-extension-firefox → firefox-manager-extension}/background.js

@@ -1,4 +1,4 @@
-import {createFirefoxAddonsTab, handleFirstRun} from './define-initial-tab.js'
+import {handleFirstRun} from './define-initial-tab.js'
 import {connect, disconnect} from './reload-service.js'
 
 function bgGreen(str) {
@@ -31,32 +31,21 @@ async function handleTabOnExtensionLoad() {
 ██████████████████████████    ████████████████████████████
 ██████████████████████████████████████████████████████████
 ██████████████████████████████████████████████████████████
+MIT (c) ${new Date().getFullYear()} - Cezar Augusto and the Extension.js Authors.
 `,
     bgGreen('')
   )
 
   try {
-    const [initialTab] = await browser.tabs.query({
-      active: true,
-      currentWindow: true
-    })
-
-    if (
-      initialTab.url === 'about:blank' ||
-      initialTab.url === 'about:welcome'
-    ) {
-      await handleFirstRun()
-    } else {
-      await createFirefoxAddonsTab(initialTab, 'about:blank')
-    }
+    await handleFirstRun()
   } catch (error) {
     console.error('Error handling tabs on extension load:', error)
   }
 }
 
-handleTabOnExtensionLoad().catch(console.error)
-
 browser.runtime.onInstalled.addListener(async () => {
+  await handleTabOnExtensionLoad()
+
   let isConnected = false
 
   if (isConnected) {

package/dist/extensions/{manager-extension-firefox → firefox-manager-extension}/define-initial-tab.js

@@ -3,19 +3,15 @@ async function getDevExtension() {
 
   return allExtensions.filter((extension) => {
     return (
-      // Do not include itself
-      extension.id !== browser.runtime.id &&
       // Reload extension
-      extension.name !== 'Reload Service' &&
+      extension.name !== 'Extension Manager' &&
       // Show only unpackaged extensions
       extension.installType === 'development'
     )
-  })
+  })[0]
 }
 
 // Create a new tab and set it to background.
-// We want the user-selected page to be active,
-// not about:blank.
 export async function createFirefoxAddonsTab(initialTab, url) {
   try {
     // Check if an about:blank tab is already open
@@ -41,17 +37,26 @@ export async function createFirefoxAddonsTab(initialTab, url) {
 
 // Function to handle first run logic
 export async function handleFirstRun() {
-  // browser.tabs.update({url: 'about://debugging/'})
+  try {
+    const devExtension = await getDevExtension()
+
+    if (!devExtension) {
+      console.warn('No development extensions found')
+      return
+    }
 
-  const devExtension = await getDevExtension()
+    const result = await browser.storage.local.get(devExtension.id)
 
-  browser.storage.local.get(devExtension.id, (result) => {
     if (result[devExtension.id] && result[devExtension.id].didRun) {
       return
     }
 
-    browser.tabs.create({url: './pages/welcome.html'})
+    // Open the welcome page
+    await browser.tabs.create({url: './pages/welcome.html'})
+
     // Ensure the welcome page shows only once per extension installation
-    browser.storage.local.set({[devExtension.id]: {didRun: true}})
-  })
+    await browser.storage.local.set({[devExtension.id]: {didRun: true}})
+  } catch (error) {
+    console.error('Error handling tabs on extension load:', error)
+  }
 }

package/dist/extensions/{manager-extension-firefox → firefox-manager-extension}/manifest.json

@@ -1,6 +1,6 @@
 {
-  "name": "Extension.js Developer Tools (Firefox)",
-  "description": "Utility for developers to manage their extensions using Firefox.",
+  "name": "Extension Manager",
+  "description": "Extension.js developer tools for tabs and reload management.",
   "version": "1.0",
   "manifest_version": 2,
   "background": {

package/dist/extensions/firefox-manager-extension/pages/sakura-dark.css

@@ -0,0 +1,268 @@
+/* $color-text: #dedce5; */
+/* Sakura.css v1.5.0
+ * ================
+ * Minimal css theme.
+ * Project: https://github.com/oxalorg/sakura/
+ */
+/* Body */
+html {
+  font-size: 62.5%;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto,
+    'Helvetica Neue', Arial, 'Noto Sans', sans-serif;
+}
+
+body {
+  font-size: 1.8rem;
+  line-height: 1.618;
+  max-width: 38em;
+  margin: auto;
+  color: #c9c9c9;
+  background-color: #222222;
+  padding: 13px;
+}
+
+@media (max-width: 684px) {
+  body {
+    font-size: 1.53rem;
+  }
+}
+@media (max-width: 382px) {
+  body {
+    font-size: 1.35rem;
+  }
+}
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  line-height: 1.1;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto,
+    'Helvetica Neue', Arial, 'Noto Sans', sans-serif;
+  font-weight: 700;
+  margin-top: 3rem;
+  margin-bottom: 1.5rem;
+  overflow-wrap: break-word;
+  word-wrap: break-word;
+  -ms-word-break: break-all;
+  word-break: break-word;
+}
+
+h1 {
+  font-size: 2.35em;
+}
+
+h2 {
+  font-size: 2em;
+}
+
+h3 {
+  font-size: 1.75em;
+}
+
+h4 {
+  font-size: 1.5em;
+}
+
+h5 {
+  font-size: 1.25em;
+}
+
+h6 {
+  font-size: 1em;
+}
+
+p {
+  margin-top: 0px;
+  margin-bottom: 2.5rem;
+}
+
+small,
+sub,
+sup {
+  font-size: 75%;
+}
+
+hr {
+  border-color: #ffffff;
+}
+
+a {
+  text-decoration: none;
+  color: #ffffff;
+}
+a:visited {
+  color: #e6e6e6;
+}
+a:hover {
+  color: #c9c9c9;
+  border-bottom: 2px solid #c9c9c9;
+}
+
+ul {
+  padding-left: 1.4em;
+  margin-top: 0px;
+  margin-bottom: 2.5rem;
+}
+
+li {
+  margin-bottom: 0.4em;
+}
+
+blockquote {
+  margin-left: 0px;
+  margin-right: 0px;
+  padding-left: 1em;
+  padding-top: 0.8em;
+  padding-bottom: 0.8em;
+  padding-right: 0.8em;
+  border-left: 5px solid #ffffff;
+  margin-bottom: 2.5rem;
+  background-color: #4a4a4a;
+}
+
+blockquote p {
+  margin-bottom: 0;
+}
+
+img,
+video {
+  height: auto;
+  max-width: 100%;
+  margin-top: 0px;
+  margin-bottom: 2.5rem;
+}
+
+/* Pre and Code */
+pre {
+  background-color: #4a4a4a;
+  display: block;
+  padding: 1em;
+  overflow-x: auto;
+  margin-top: 0px;
+  margin-bottom: 2.5rem;
+  font-size: 0.9em;
+}
+
+code,
+kbd,
+samp {
+  font-size: 0.9em;
+  padding: 0 0.5em;
+  background-color: #4a4a4a;
+  white-space: pre-wrap;
+}
+
+pre > code {
+  padding: 0;
+  background-color: transparent;
+  white-space: pre;
+  font-size: 1em;
+}
+
+/* Tables */
+table {
+  text-align: justify;
+  width: 100%;
+  border-collapse: collapse;
+  margin-bottom: 2rem;
+}
+
+td,
+th {
+  padding: 0.5em;
+  border-bottom: 1px solid #4a4a4a;
+}
+
+/* Buttons, forms and input */
+input,
+textarea {
+  border: 1px solid #c9c9c9;
+}
+input:focus,
+textarea:focus {
+  border: 1px solid #ffffff;
+}
+
+textarea {
+  width: 100%;
+}
+
+.button,
+button,
+input[type='submit'],
+input[type='reset'],
+input[type='button'],
+input[type='file']::file-selector-button {
+  display: inline-block;
+  padding: 5px 10px;
+  text-align: center;
+  text-decoration: none;
+  white-space: nowrap;
+  background-color: #ffffff;
+  color: #222222;
+  border-radius: 1px;
+  border: 1px solid #ffffff;
+  cursor: pointer;
+  box-sizing: border-box;
+}
+.button[disabled],
+button[disabled],
+input[type='submit'][disabled],
+input[type='reset'][disabled],
+input[type='button'][disabled],
+input[type='file']::file-selector-button[disabled] {
+  cursor: default;
+  opacity: 0.5;
+}
+.button:hover,
+button:hover,
+input[type='submit']:hover,
+input[type='reset']:hover,
+input[type='button']:hover,
+input[type='file']::file-selector-button:hover {
+  background-color: #c9c9c9;
+  color: #222222;
+  outline: 0;
+}
+.button:focus-visible,
+button:focus-visible,
+input[type='submit']:focus-visible,
+input[type='reset']:focus-visible,
+input[type='button']:focus-visible,
+input[type='file']::file-selector-button:focus-visible {
+  outline-style: solid;
+  outline-width: 2px;
+}
+
+textarea,
+select,
+input {
+  color: #c9c9c9;
+  padding: 6px 10px; /* The 6px vertically centers text on FF, ignored by Webkit */
+  margin-bottom: 10px;
+  background-color: #4a4a4a;
+  border: 1px solid #4a4a4a;
+  border-radius: 4px;
+  box-shadow: none;
+  box-sizing: border-box;
+}
+textarea:focus,
+select:focus,
+input:focus {
+  border: 1px solid #ffffff;
+  outline: 0;
+}
+
+input[type='checkbox']:focus {
+  outline: 1px dotted #ffffff;
+}
+
+label,
+legend,
+fieldset {
+  display: block;
+  margin-bottom: 0.5rem;
+  font-weight: 600;
+}