@tamagui/cli 1.74.3 → 1.74.5

package/src/dev/clientInjectPlugin.ts

@@ -1,112 +0,0 @@
-import path from 'node:path'
-
-import type { HmrOptions, Plugin, ResolvedConfig, UserConfig } from 'vite'
-
-const process_env_NODE_ENV_RE = /(\bglobal(This)?\.)?\bprocess\.env\.NODE_ENV\b/g
-
-const isObject = (x: any): x is Object => x && typeof x === 'object'
-
-/**
- * some values used by the client needs to be dynamically injected by the server
- * @server-only
- */
-export function clientInjectionsPlugin(config: ResolvedConfig): Plugin {
-  let injectConfigValues: (code: string) => string
-
-  return {
-    name: 'vite:client-inject',
-
-    async buildStart() {
-      const resolvedServerHostname = '127.0.0.1'
-      const resolvedServerPort = config.server!.port! || 5173
-      const devBase = config.base || '/'
-
-      const serverHost = `${resolvedServerHostname}:${resolvedServerPort}${devBase}`
-
-      let hmrConfig = config.server!.hmr
-      hmrConfig = isObject(hmrConfig) ? (hmrConfig as HmrOptions) : undefined
-
-      const host = hmrConfig?.host || null
-      const protocol = hmrConfig?.protocol || null
-      const timeout = hmrConfig?.timeout || 30000
-      const overlay = hmrConfig?.overlay !== false
-      const isHmrServerSpecified = !!hmrConfig?.server
-
-      // hmr.clientPort -> hmr.port
-      // -> (24678 if middleware mode and HMR server is not specified) -> new URL(import.meta.url).port
-      let port = hmrConfig?.clientPort || hmrConfig?.port || null
-      if (config.server.middlewareMode && !isHmrServerSpecified) {
-        port ||= 24678
-      }
-
-      let directTarget = hmrConfig?.host || resolvedServerHostname
-      directTarget += `:${hmrConfig?.port || resolvedServerPort}`
-      directTarget += devBase
-
-      let hmrBase = devBase
-      if (hmrConfig?.path) {
-        hmrBase = path.posix.join(hmrBase, hmrConfig.path)
-      }
-
-      const serializedDefines = serializeDefine(config.define || {})
-
-      const modeReplacement = escapeReplacement(config.mode!)
-      const baseReplacement = escapeReplacement(devBase)
-      const definesReplacement = () => serializedDefines
-      const serverHostReplacement = escapeReplacement(serverHost)
-      const hmrProtocolReplacement = escapeReplacement(protocol)
-      const hmrHostnameReplacement = escapeReplacement(host)
-      const hmrPortReplacement = escapeReplacement(port)
-      const hmrDirectTargetReplacement = escapeReplacement(directTarget)
-      const hmrBaseReplacement = escapeReplacement(hmrBase)
-      const hmrTimeoutReplacement = escapeReplacement(timeout)
-      const hmrEnableOverlayReplacement = escapeReplacement(overlay)
-
-      injectConfigValues = (code: string) => {
-        return code
-          .replace(`__MODE__`, modeReplacement)
-          .replace(/__BASE__/g, baseReplacement)
-          .replace(`__DEFINES__`, definesReplacement)
-          .replace(`__SERVER_HOST__`, serverHostReplacement)
-          .replace(`__HMR_PROTOCOL__`, hmrProtocolReplacement)
-          .replace(`__HMR_HOSTNAME__`, hmrHostnameReplacement)
-          .replace(`__HMR_PORT__`, hmrPortReplacement)
-          .replace(`__HMR_DIRECT_TARGET__`, hmrDirectTargetReplacement)
-          .replace(`__HMR_BASE__`, hmrBaseReplacement)
-          .replace(`__HMR_TIMEOUT__`, hmrTimeoutReplacement)
-          .replace(`__HMR_ENABLE_OVERLAY__`, hmrEnableOverlayReplacement)
-      }
-    },
-
-    transform(code, id, options) {
-      if (id.endsWith('vite-native-client/dist/esm/client.js')) {
-        return injectConfigValues(code)
-      } else if (!options?.ssr && code.includes('process.env.NODE_ENV')) {
-        // replace process.env.NODE_ENV instead of defining a global
-        // for it to avoid shimming a `process` object during dev,
-        // avoiding inconsistencies between dev and build
-        // return code.replace(
-        //   process_env_NODE_ENV_RE,
-        //   config.define?.['process.env.NODE_ENV'] ||
-        //     JSON.stringify(process.env.NODE_ENV || config.mode)
-        // )
-      }
-    },
-  }
-}
-
-function escapeReplacement(value: string | number | boolean | null) {
-  const jsonValue = JSON.stringify(value)
-  return () => jsonValue
-}
-
-function serializeDefine(define: Record<string, any>): string {
-  let res = `{`
-  for (const key in define) {
-    const val = define[key]
-    res += `${JSON.stringify(key)}: ${
-      typeof val === 'string' ? `(${val})` : JSON.stringify(val)
-    }, `
-  }
-  return res + `}`
-}

package/src/dev/createDevServer.ts

@@ -1,250 +0,0 @@
-import { CLIResolvedOptions } from '@tamagui/types'
-import mime from 'mime/lite'
-
-import { DEFAULT_PORT } from '../utils/constants'
-import { Server, createServer } from '../vendor/repack/dev-server/src'
-import { HMRListener } from './types'
-
-export async function createDevServer(
-  options: CLIResolvedOptions,
-  {
-    indexJson,
-    listenForHMR,
-    getIndexBundle,
-    hotUpdatedCJSFiles,
-  }: {
-    indexJson: Object
-    getIndexBundle: () => Promise<string>
-    listenForHMR: (cb: HMRListener) => void
-    hotUpdatedCJSFiles: Map<string, string>
-  }
-) {
-  const { start, stop } = await createServer({
-    options: {
-      rootDir: options.root,
-      host: options.host,
-      port: options.port ?? DEFAULT_PORT,
-      // https: args.https
-      //   ? {
-      //       cert: args.cert,
-      //       key: args.key,
-      //     }
-      //   : undefined,
-    },
-
-    delegate: (ctx): Server.Delegate => {
-      // if (args.interactive) {
-      //   bindKeypressInput(ctx)
-      // }
-
-      // if (reversePort && args.port) {
-      //   runAdbReverse(ctx, args.port)
-      // }
-
-      // let lastStats: webpack.StatsCompilation | undefined
-
-      // compiler.on('watchRun', ({ platform }) => {
-      //   ctx.notifyBuildStart(platform)
-      //   if (platform === 'android') {
-      //     runAdbReverse(ctx, args.port ?? DEFAULT_PORT)
-      //   }
-      // })
-
-      // compiler.on('invalid', ({ platform }) => {
-      //   ctx.notifyBuildStart(platform)
-      //   ctx.broadcastToHmrClients({ action: 'building' }, platform)
-      // })
-
-      const platform = 'ios'
-      listenForHMR((update) => {
-        ctx.notifyBuildEnd(platform)
-        ctx.broadcastToHmrClients(
-          {
-            action: 'built',
-            body: createHmrBody({
-              errors: [],
-              warnings: [],
-              hash: `${Math.random()}`,
-              modules: {},
-              name: '',
-              time: 0,
-            }),
-          },
-          platform
-        )
-      })
-
-      return {
-        hotFiles: {
-          getSource: (path) => {
-            const next = hotUpdatedCJSFiles.get(path)
-            // hotUpdatedCJSFiles.delete(path) // memory leak prevent
-            return next || ''
-          },
-        },
-
-        compiler: {
-          getAsset: async (filename, platform, sendProgress) => {
-            console.log('[GET] - ', filename)
-            if (filename === 'index.bundle') {
-              return await getIndexBundle()
-            }
-            return ''
-            // return (await compiler.getAsset(filename, platform, sendProgress)).data
-          },
-
-          getMimeType: (filename) => {
-            return mime.getType(filename) || 'application/javascript'
-          },
-
-          inferPlatform: (uri) => {
-            return 'ios'
-
-            const url = new URL(uri, 'protocol://domain')
-            if (!url.searchParams.get('platform')) {
-              const [, platform] = /^\/(.+)\/.+$/.exec(url.pathname) ?? []
-              return platform
-            }
-
-            return undefined
-          },
-        },
-
-        symbolicator: {
-          getSource: async (fileUrl) => {
-            console.log('get source', fileUrl)
-            // const { filename, platform } = parseFileUrl(fileUrl)
-            // return compiler.getSource(filename, platform)
-            return ''
-          },
-          getSourceMap: async (fileUrl) => {
-            // const { filename, platform } = parseFileUrl(fileUrl)
-            // if (!platform) {
-            //   throw new Error('Cannot infer platform for file URL')
-            // }
-
-            // return compiler.getSourceMap(filename, platform)
-            return ''
-          },
-          shouldIncludeFrame: (frame) => {
-            // If the frame points to internal bootstrap/module system logic, skip the code frame.
-            return !/webpack[/\\]runtime[/\\].+\s/.test(frame.file)
-          },
-        },
-
-        hmr: {
-          getUriPath: () => '/__hmr',
-          onClientConnected: (platform, clientId) => {
-            // biome-ignore lint/suspicious/noConsoleLog: <explanation>
-            // todo
-            // const lastStats = {}
-            // ctx.broadcastToHmrClients(
-            //   { action: 'sync', body: createHmrBody(lastStats) },
-            //   platform,
-            //   [clientId]
-            // )
-          },
-        },
-
-        messages: {
-          getHello: () => indexJson,
-          getStatus: () => 'packager-status:running',
-        },
-
-        logger: {
-          onMessage: (log) => {
-            const logEntry = makeLogEntryFromFastifyLog(log)
-            logEntry.issuer = 'DevServer'
-
-            // ignore for now
-            if (logEntry.type === 'debug') return
-
-            // error DevServer, warn DevServer
-            // biome-ignore lint/suspicious/noConsoleLog: <explanation>
-            console.log(
-              '[logger]',
-              logEntry.type === 'info' ? '' : logEntry.type,
-              logEntry.message
-                .map((m) => {
-                  return `${m.msg}`
-                })
-                .join(', ')
-            )
-            // reporter.process(logEntry)
-          },
-        },
-
-        api: {
-          // getPlatforms: async () => Object.keys(compiler.workers),
-          getPlatforms: async () => ['ios'],
-          getAssets: async (platform) => {
-            console.log('get assets', platform)
-            return []
-            // return Object.entries(compiler.assetsCache[platform] ?? {}).map(([name, asset]) => ({
-            //   name,
-            //   size: asset.info.size,
-            // })),
-          },
-          getCompilationStats: async (platform) => {
-            return null
-            // return compiler.statsCache[platform] ?? null
-          },
-        },
-      }
-    },
-  })
-
-  await start()
-
-  return async () => {
-    await stop()
-  }
-}
-
-function createHmrBody(body: HMRMessageBody): HMRMessageBody | null {
-  return body
-}
-
-/**
- * Represent Hot Module Replacement Update body.
- *
- * @internal
- */
-export interface HMRMessageBody {
-  name: string
-  time: number
-  hash: string
-  warnings: any
-  errors: any
-  modules: Record<string, string>
-}
-
-/**
- * Represent Hot Module Replacement Update message.
- *
- * @internal
- */
-export interface HMRMessage {
-  action: 'building' | 'built' | 'sync'
-  body: HMRMessageBody | null
-}
-
-function makeLogEntryFromFastifyLog(data: any): any {
-  const { level, time, pid, hostname, ...rest } = data
-
-  const levelToTypeMapping: Record<number, any> = {
-    10: 'debug',
-    20: 'debug',
-    30: 'info',
-    40: 'warn',
-    50: 'error',
-    60: 'error',
-  }
-
-  return {
-    type: levelToTypeMapping[level],
-    timestamp: time,
-    issuer: '',
-    message: [rest],
-  }
-}

package/src/dev/types.ts

@@ -1 +0,0 @@
-export type HMRListener = (update: { file: string; contents: string }) => void