effect-start 0.31.0 → 0.33.0

package/src/tailwind/TailwindPlugin.ts

@@ -191,109 +191,136 @@ const CSS_IMPORT_REGEX = /@import\s+(?:url\()?["']?([^"')]+)["']?\)?\s*[^;]*;/
 const HTML_COMMENT_REGEX = /<!--[\s\S]*?-->/g
 const TEMPLATE_EXPRESSION_REGEX = /\$\{[^}]*\}/g
 const TAILWIND_CLASS_REGEX = /^[a-zA-Z0-9_:-]+(\[[^\]]*\])?$/
-const CLASS_NAME_PATTERNS = [
-  // HTML class attributes with double quotes: <div class="bg-blue-500 text-white">
-  '<[^>]*?\\sclass\\s*=\\s*"([^"]+)"',
+const CLASS_ATTRIBUTE_PATTERNS = [
+  '\\sclass\\s*=\\s*"([^"]+)"',
+  "\\sclass\\s*=\\s*'([^']+)'",
+  '\\sclassName\\s*=\\s*"([^"]+)"',
+  "\\sclassName\\s*=\\s*'([^']+)'",
+  '\\sclassName\\s*=\\s*\\{\\s*"([^"]+)"\\s*\\}',
+  "\\sclassName\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
+  "\\sclassName\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
+  "\\sclass\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
+  "\\sdata-class:([a-zA-Z0-9_:\\-]+(?:\\[[^\\]]*\\])?)\\s*=",
+]
 
-  // HTML class attributes with single quotes: <div class='bg-blue-500 text-white'>
-  "<[^>]*?\\sclass\\s*=\\s*'([^']+)'",
+const CLASS_ATTRIBUTE_REGEX = new RegExp(
+  CLASS_ATTRIBUTE_PATTERNS.map((pattern) => `(?:${pattern})`).join("|"),
+  "g",
+)
 
-  // JSX className attributes with double quotes: <div className="bg-blue-500 text-white">
-  '<[^>]*?\\sclassName\\s*=\\s*"([^"]+)"',
+function hasCssImport(css: string, specifier?: string): boolean {
+  const [, importPath] = css.match(CSS_IMPORT_REGEX) ?? []
 
-  // JSX className attributes with single quotes: <div className='bg-blue-500 text-white'>
-  "<[^>]*?\\sclassName\\s*=\\s*'([^']+)'",
+  if (!importPath) return false
 
-  // JSX className with braces and double quotes: <div className={"bg-blue-500 text-white"}>
-  '<[^>]*?\\sclassName\\s*=\\s*\\{\\s*"([^"]+)"\\s*\\}',
+  return specifier === undefined || importPath.includes(specifier)
+}
 
-  // JSX className with braces and single quotes: <div className={'bg-blue-500 text-white'}>
-  "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
+export function extractClassNames(source: string): Set<string> {
+  const candidates = new Set<string>()
+  const sourceWithoutComments = source.replace(HTML_COMMENT_REGEX, "")
 
-  // JSX className with template literals: <div className={`bg-blue-500 ${variable}`}>
-  "<[^>]*?\\sclassName\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
+  for (const tag of extractTagLikeSegments(sourceWithoutComments)) {
+    for (const match of tag.matchAll(CLASS_ATTRIBUTE_REGEX)) {
+      let classString = ""
+      for (let i = 1; i < match.length; i++) {
+        if (match[i] !== undefined) {
+          classString = match[i]
+          break
+        }
+      }
 
-  // HTML class with template literals: <div class={`bg-blue-500 ${variable}`}>
-  "<[^>]*?\\sclass\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
+      if (!classString) {
+        continue
+      }
 
-  // HTML class at start of tag with double quotes: <div class="bg-blue-500">
-  '<\\w+\\s+class\\s*=\\s*"([^"]+)"',
+      if (classString.includes("${")) {
+        const staticParts = classString.split(TEMPLATE_EXPRESSION_REGEX)
+
+        for (const part of staticParts) {
+          const names = part
+            .trim()
+            .split(/\s+/)
+            .filter((name) => {
+              if (name.length === 0) return false
+              if (name.endsWith("-") || name.startsWith("-")) return false
+              return TAILWIND_CLASS_REGEX.test(name)
+            })
+          names.forEach((name) => candidates.add(name))
+        }
+      } else {
+        const names = classString.split(/\s+/).filter((name) => name.length > 0)
+        names.forEach((name) => candidates.add(name))
+      }
+    }
 
-  // HTML class at start of tag with single quotes: <div class='bg-blue-500'>
-  "<\\w+\\s+class\\s*=\\s*'([^']+)'",
+  }
 
-  // JSX className at start of tag with double quotes: <div className="bg-blue-500">
-  '<\\w+\\s+className\\s*=\\s*"([^"]+)"',
+  return candidates
+}
 
-  // JSX className at start of tag with single quotes: <div className='bg-blue-500'>
-  "<\\w+\\s+className\\s*=\\s*'([^']+)'",
+function extractTagLikeSegments(source: string): Array<string> {
+  const tags: Array<string> = []
 
-  // JSX className at start with braces and double quotes: <div className={"bg-blue-500"}>
-  '<\\w+\\s+className\\s*=\\s*\\{\\s*"([^"]+)"\\s*\\}',
+  for (let i = 0; i < source.length; i++) {
+    if (source[i] !== "<") {
+      continue
+    }
 
-  // JSX className at start with braces and single quotes: <div className={'bg-blue-500'}>
-  "<\\w+\\s+className\\s*=\\s*\\{\\s*'([^']+)'\\s*\\}",
+    const next = source[i + 1]
+    if (!next || next === "/" || next === "!" || /\s/.test(next)) {
+      continue
+    }
 
-  // JSX className at start with template literals: <div className={`bg-blue-500 ${variable}`}>
-  "<\\w+\\s+className\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
+    let quote: '"' | "'" | "`" | null = null
+    let escaped = false
+    let braceDepth = 0
 
-  // HTML class at start with template literals: <div class={`bg-blue-500 ${variable}`}>
-  "<\\w+\\s+class\\s*=\\s*\\{\\s*`([^`]*)`\\s*\\}",
-]
+    for (let j = i + 1; j < source.length; j++) {
+      const char = source[j]
 
-const CLASS_NAME_REGEX = new RegExp(
-  CLASS_NAME_PATTERNS.map((pattern) => `(?:${pattern})`).join("|"),
-  "g",
-)
+      if (quote !== null) {
+        if (escaped) {
+          escaped = false
+          continue
+        }
 
-function hasCssImport(css: string, specifier?: string): boolean {
-  const [, importPath] = css.match(CSS_IMPORT_REGEX) ?? []
+        if (char === "\\") {
+          escaped = true
+          continue
+        }
 
-  if (!importPath) return false
+        if (char === quote) {
+          quote = null
+        }
 
-  return specifier === undefined || importPath.includes(specifier)
-}
+        continue
+      }
 
-export function extractClassNames(source: string): Set<string> {
-  const candidates = new Set<string>()
-  const sourceWithoutComments = source.replace(HTML_COMMENT_REGEX, "")
+      if (char === '"' || char === "'" || char === "`") {
+        quote = char
+        continue
+      }
 
-  for (const match of sourceWithoutComments.matchAll(CLASS_NAME_REGEX)) {
-    // Find the first non-undefined capture group (skip match[0] which is full match)
-    let classString = ""
-    for (let i = 1; i < match.length; i++) {
-      if (match[i] !== undefined) {
-        classString = match[i]
-        break
+      if (char === "{") {
+        braceDepth++
+        continue
       }
-    }
 
-    if (!classString) {
-      continue
-    }
+      if (char === "}" && braceDepth > 0) {
+        braceDepth--
+        continue
+      }
 
-    if (classString.includes("${")) {
-      const staticParts = classString.split(TEMPLATE_EXPRESSION_REGEX)
-
-      for (const part of staticParts) {
-        const names = part
-          .trim()
-          .split(/\s+/)
-          .filter((name) => {
-            if (name.length === 0) return false
-            if (name.endsWith("-") || name.startsWith("-")) return false
-            return TAILWIND_CLASS_REGEX.test(name)
-          })
-        names.forEach((name) => candidates.add(name))
+      if (char === ">" && braceDepth === 0) {
+        tags.push(source.slice(i, j + 1))
+        i = j
+        break
       }
-    } else {
-      // Simple case: regular class string without expressions
-      const names = classString.split(/\s+/).filter((name) => name.length > 0)
-      names.forEach((name) => candidates.add(name))
     }
   }
 
-  return candidates
+  return tags
 }
 
 async function scanFiles(dir: string): Promise<Set<string>> {

package/src/RouteTrie.ts

@@ -1,205 +0,0 @@
-import * as PathPattern from "./_PathPattern.ts"
-import * as Route from "./Route.ts"
-
-export interface Node {
-  children: Record<string, Node>
-  paramChild: Node | null
-  paramName: string | null
-  requiredWildcardChild: Node | null
-  requiredWildcardName: string | null
-  optionalWildcardChild: Node | null
-  optionalWildcardName: string | null
-  routes: Array<Route.Route.Route>
-}
-
-export interface RouteTrie {
-  readonly methods: Record<string, Node>
-}
-
-export interface LookupResult {
-  route: Route.Route.Route
-  params: Record<string, string>
-}
-
-function createNode(): Node {
-  return {
-    children: {},
-    paramChild: null,
-    paramName: null,
-    requiredWildcardChild: null,
-    requiredWildcardName: null,
-    optionalWildcardChild: null,
-    optionalWildcardName: null,
-    routes: [],
-  }
-}
-
-function insertRoute(node: Node, segments: Array<string>, route: Route.Route.Route): void {
-  if (segments.length === 0) {
-    node.routes.push(route)
-    return
-  }
-
-  const segment = segments[0]
-  const rest = segments.slice(1)
-
-  if (segment.startsWith(":")) {
-    const name = segment.slice(1)
-
-    if (name.endsWith("+")) {
-      if (!node.requiredWildcardChild) {
-        node.requiredWildcardChild = createNode()
-      }
-      node.requiredWildcardChild.requiredWildcardName = name.slice(0, -1)
-      node.requiredWildcardChild.routes.push(route)
-    } else if (name.endsWith("*")) {
-      if (!node.optionalWildcardChild) {
-        node.optionalWildcardChild = createNode()
-      }
-      node.optionalWildcardChild.optionalWildcardName = name.slice(0, -1)
-      node.optionalWildcardChild.routes.push(route)
-    } else if (name.endsWith("?")) {
-      if (!node.paramChild) {
-        node.paramChild = createNode()
-      }
-      node.paramChild.paramName = name.slice(0, -1)
-      insertRoute(node.paramChild, rest, route)
-      insertRoute(node, rest, route)
-    } else {
-      if (!node.paramChild) {
-        node.paramChild = createNode()
-      }
-      node.paramChild.paramName = name
-      insertRoute(node.paramChild, rest, route)
-    }
-  } else {
-    if (!node.children[segment]) {
-      node.children[segment] = createNode()
-    }
-    insertRoute(node.children[segment], rest, route)
-  }
-}
-
-interface CollectedRoute {
-  route: Route.Route.Route
-  method: string
-  path: string
-}
-
-function collectRoutes(
-  items: Route.Route.Tuple,
-  parentPath: string,
-  parentMethod: string,
-): Array<CollectedRoute> {
-  const results: Array<CollectedRoute> = []
-
-  for (const item of items) {
-    const desc = Route.descriptor(item) as { path?: string; method?: string }
-    const currentPath = typeof desc?.path === "string" ? parentPath + desc.path : parentPath
-    const currentMethod = desc?.method ?? parentMethod
-
-    if (Route.isRoute(item)) {
-      if (currentPath !== "") {
-        results.push({
-          route: item,
-          method: currentMethod,
-          path: currentPath,
-        })
-      }
-    } else {
-      const nestedItems = Route.items(item)
-      results.push(...collectRoutes(nestedItems, currentPath, currentMethod))
-    }
-  }
-
-  return results
-}
-
-export function make(set: Route.RouteSet.Any): RouteTrie {
-  const methods: Record<string, Node> = {}
-  const collected = collectRoutes(Route.items(set), "", "*")
-
-  for (const { route, method, path } of collected) {
-    if (!methods[method]) {
-      methods[method] = createNode()
-    }
-    const result = PathPattern.validate(path)
-    if (!result.ok) {
-      throw new Error(result.error)
-    }
-    insertRoute(methods[method], result.segments, route)
-  }
-
-  return { methods }
-}
-
-function lookupNode(
-  node: Node,
-  segments: Array<string>,
-  params: Record<string, string>,
-): Array<LookupResult> {
-  const results: Array<LookupResult> = []
-
-  if (segments.length === 0) {
-    for (const route of node.routes) {
-      results.push({ route, params })
-    }
-    if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-      for (const route of node.optionalWildcardChild.routes) {
-        results.push({ route, params })
-      }
-    }
-    return results
-  }
-
-  const segment = segments[0]
-  const rest = segments.slice(1)
-
-  if (node.children[segment]) {
-    results.push(...lookupNode(node.children[segment], rest, params))
-  }
-
-  if (node.paramChild && node.paramChild.paramName) {
-    const newParams = { ...params, [node.paramChild.paramName]: segment }
-    results.push(...lookupNode(node.paramChild, rest, newParams))
-  }
-
-  if (node.requiredWildcardChild && node.requiredWildcardChild.requiredWildcardName) {
-    const wildcardValue = segments.join("/")
-    const newParams = {
-      ...params,
-      [node.requiredWildcardChild.requiredWildcardName]: wildcardValue,
-    }
-    for (const route of node.requiredWildcardChild.routes) {
-      results.push({ route, params: newParams })
-    }
-  }
-
-  if (node.optionalWildcardChild && node.optionalWildcardChild.optionalWildcardName) {
-    const wildcardValue = segments.join("/")
-    const newParams = {
-      ...params,
-      [node.optionalWildcardChild.optionalWildcardName]: wildcardValue,
-    }
-    for (const route of node.optionalWildcardChild.routes) {
-      results.push({ route, params: newParams })
-    }
-  }
-
-  return results
-}
-
-export function lookup(trie: RouteTrie, method: string, path: string): Array<LookupResult> {
-  const segments = path.split("/").filter(Boolean)
-  const results: Array<LookupResult> = []
-
-  if (trie.methods[method]) {
-    results.push(...lookupNode(trie.methods[method], segments, {}))
-  }
-
-  if (method !== "*" && trie.methods["*"]) {
-    results.push(...lookupNode(trie.methods["*"], segments, {}))
-  }
-
-  return results
-}

package/src/experimental/index.ts

@@ -1 +0,0 @@
-export * as EncryptedCookies from "./EncryptedCookies.ts"