@wix/origami-site 0.1.32 → 0.1.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/origami-site",
-  "version": "0.1.32",
+  "version": "0.1.33",
   "description": "Runs an exported Wix origami site: file-based routing, Wix dynamic pages, popups and build checks. Use with @wix/origami-site-astro or @wix/origami-site-express.",
   "type": "module",
   "files": [
@@ -93,5 +93,5 @@
       "optional": true
     }
   },
-  "falconPackageHash": "521196d96b89520b98a02f6d8f882dd74e393b1728ef2943a0dc2e7a"
+  "falconPackageHash": "f699993cd6dc0b08545a5b50b04d801776a7b77e10c81bd7ac6cd6e7"
 }

package/src/build/index.js

@@ -2,6 +2,7 @@ import { transforms } from './transforms.js'
 import { globalImports } from './globalImports.js'
 import { pageList } from './pageList.js'
 import { sharedPackages } from './sharedPackages.js'
+import { wrapperAliases } from './wrapperAliases.js'
 
 /** @param {import('./index.js').OrigamiVitePluginsOptions} options
  * @returns {import('vite').Plugin[]} */
@@ -11,5 +12,6 @@ export function origamiVitePlugins({ root, siteTree }) {
         pageList(siteTree),
         ...transforms({ root }),
         sharedPackages(),
+        wrapperAliases(root),
     ]
 }

package/src/build/wrapperAliases.js

@@ -0,0 +1,79 @@
+// Raw components import each other by module specifier, such as a store component importing its hook from
+// `@wix/stores/product-list-context-provider`. The Wix viewer resolves these with an import map. Here each wrapper
+// package (`@origami-wrappers/*`) lists them under `origami.aliases`, and they become `resolve.alias` entries, which
+// Vite also applies while pre-bundling dependencies, where these imports sit.
+
+import { existsSync, readFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { resolve } from 'node:path'
+
+const WRAPPERS_SCOPE = '@origami-wrappers/'
+
+/** @param {string} text */
+const escapeRegExp = text => text.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+
+/** @param {string} path */
+const readJson = path => JSON.parse(readFileSync(path, 'utf8'))
+
+/**
+ * A wrapper package's `package.json`, or undefined for one that has nothing to read: one from before the aliases
+ * does not export its `package.json`, and one not installed yet has none.
+ *
+ * @param {NodeJS.Require} require
+ * @param {string} name
+ */
+const readWrapperPackageJson = (require, name) => {
+    try {
+        return readJson(require.resolve(`${name}/package.json`))
+    } catch (error) {
+        const { code } = /** @type {NodeJS.ErrnoException} */ (error)
+        if (code === 'ERR_PACKAGE_PATH_NOT_EXPORTED' || code === 'MODULE_NOT_FOUND') return undefined
+        throw error
+    }
+}
+
+/**
+ * Every alias the site's wrapper packages declare. A `./` target is in the package itself, which the site installs
+ * under a name of its own, so the name goes in front; any other target is an npm import, kept as is. Each alias
+ * matches the whole import, not longer paths that start with it. Two packages pointing one specifier at different
+ * modules fail, rather than leave it to the order of the dependencies.
+ *
+ * @param {string} root the site app folder, whose `package.json` lists the wrapper packages
+ * @returns {{ find: RegExp, replacement: string }[]}
+ */
+export const collectWrapperAliases = root => {
+    const packageJsonPath = resolve(root, 'package.json')
+    if (!existsSync(packageJsonPath)) return []
+    const require = createRequire(packageJsonPath)
+    const wrapperNames = Object.keys(readJson(packageJsonPath).dependencies ?? {}).filter(name =>
+        name.startsWith(WRAPPERS_SCOPE)
+    )
+
+    /** @type {Map<string, { name: string, replacement: string }>} */
+    const claims = new Map()
+    for (const name of wrapperNames) {
+        /** @type {Record<string, string>} */
+        const aliases = readWrapperPackageJson(require, name)?.origami?.aliases ?? {}
+        for (const [specifier, target] of Object.entries(aliases)) {
+            const replacement = target.startsWith('./') ? `${name}/${target.slice(2)}` : target
+            const claim = claims.get(specifier)
+            if (claim && claim.replacement !== replacement)
+                throw new Error(
+                    `${claim.name} and ${name} both alias ${specifier}, to ${claim.replacement} and ${replacement}`
+                )
+            claims.set(specifier, { name, replacement })
+        }
+    }
+
+    return [...claims].map(([specifier, { replacement }]) => ({
+        find: new RegExp(`^${escapeRegExp(specifier)}$`),
+        replacement,
+    }))
+}
+
+/** @param {string} root
+ * @returns {import('vite').Plugin} */
+export const wrapperAliases = root => ({
+    name: 'origami:wrapper-aliases',
+    config: () => ({ resolve: { alias: collectWrapperAliases(root) } }),
+})