Upload ui_gradio_extensions.py

ui_gradio_extensions.py

@@ -0,0 +1,322 @@
+import html
+import json
+import os
+import gradio as gr
+
+from modules import localization, shared, scripts, util
+from modules.paths import script_path, data_path
+
+
+# JS load policy:
+#   core  : always sync (A1111 core, needed for set_theme/onUiLoaded/gradioApp)
+#   fix   : always sync (safety/diagnostics layer should initialize early)
+#   builtin extension: sync by default for compatibility
+#   user extension   : sync by default for compatibility; mixed/defer are opt-in
+#
+# Environment overrides:
+#   A1111_EXTENSION_JS_MODE = sync|mixed|safe|compat|defer
+#   A1111_EXTENSION_JS_SYNC_NAMES = comma-separated substrings / basenames
+#   A1111_EXTENSION_JS_DEFER_NAMES = comma-separated substrings / basenames
+#
+# Notes:
+#   - default is `sync` because preserving stock-like execution order is safer.
+#   - this file preserves the original order from scripts.list_scripts() and only
+#     changes per-script loading attributes when explicitly requested.
+#   - unlike v4.0, loader diagnostics are seeded at injection time from a manifest,
+#     so "pending" reflects what was actually injected into the page, not only what
+#     later fired onload/onerror.
+
+DEFAULT_EXTENSION_JS_MODE = "sync"
+_VALID_EXTENSION_JS_MODES = {"mixed", "sync", "defer"}
+_FIX_MARKERS = (
+    "0000-a1111-fix",
+    "!0000-a1111-fix",
+    "fix.js",
+)
+
+
+def webpath(fn):
+    return f'file={util.truncate_path(fn)}?{os.path.getmtime(fn)}'
+
+
+def _env_csv(name):
+    raw = os.environ.get(name, "")
+    return [item.strip().lower() for item in raw.split(",") if item.strip()]
+
+
+def _normalized_lower_path(path):
+    return os.path.normpath(path).lower().replace("\\", "/")
+
+
+def _script_kind(script):
+    path = os.path.normpath(script.path)
+    basedir = os.path.normpath(getattr(script, "basedir", "") or "")
+    lower_path = _normalized_lower_path(path)
+    lower_basedir = _normalized_lower_path(basedir)
+
+    if basedir == os.path.normpath(script_path):
+        return "core"
+
+    if any(marker in lower_path or marker in lower_basedir for marker in _FIX_MARKERS):
+        return "fix_extension"
+
+    if "/extensions-builtin/" in lower_path or "/extensions-builtin/" in lower_basedir:
+        return "builtin_extension"
+
+    return "user_extension"
+
+
+def _matches_override(script, patterns):
+    if not patterns:
+        return False
+
+    haystacks = {
+        os.path.basename(script.path).lower(),
+        _normalized_lower_path(script.path),
+        _normalized_lower_path(getattr(script, "basedir", "") or ""),
+    }
+
+    return any(any(pattern in hay for hay in haystacks) for pattern in patterns)
+
+
+def _get_extension_mode():
+    mode = os.environ.get("A1111_EXTENSION_JS_MODE", DEFAULT_EXTENSION_JS_MODE).strip().lower()
+    aliases = {
+        "safe": "sync",
+        "compat": "sync",
+    }
+    mode = aliases.get(mode, mode or DEFAULT_EXTENSION_JS_MODE)
+    if mode not in _VALID_EXTENSION_JS_MODES:
+        return DEFAULT_EXTENSION_JS_MODE
+    return mode
+
+
+def _script_load_mode(script):
+    kind = _script_kind(script)
+    mode = _get_extension_mode()
+
+    if kind in {"core", "fix_extension"}:
+        return "sync", kind
+
+    sync_overrides = _env_csv("A1111_EXTENSION_JS_SYNC_NAMES")
+    defer_overrides = _env_csv("A1111_EXTENSION_JS_DEFER_NAMES")
+
+    if _matches_override(script, sync_overrides):
+        return "sync", kind
+
+    if _matches_override(script, defer_overrides):
+        return "defer", kind
+
+    if mode == "sync":
+        return "sync", kind
+
+    if mode == "defer":
+        return "defer", kind
+
+    # mixed (opt-in): builtin extensions stay sync, user extensions defer
+    if kind == "builtin_extension":
+        return "sync", kind
+
+    return "defer", kind
+
+
+def _build_script_entries():
+    entries = []
+
+    script_js = os.path.join(script_path, "script.js")
+    entries.append({
+        "src": webpath(script_js),
+        "role": "core",
+        "mode": "sync",
+        "path": script_js,
+        "basedir": script_path,
+        "module": False,
+    })
+
+    seen_script_paths = {os.path.normpath(script_js)}
+    for script in scripts.list_scripts("javascript", ".js"):
+        norm_path = os.path.normpath(script.path)
+        if norm_path in seen_script_paths:
+            continue
+        seen_script_paths.add(norm_path)
+
+        load_mode, role = _script_load_mode(script)
+        entries.append({
+            "src": webpath(script.path),
+            "role": role,
+            "mode": load_mode,
+            "path": script.path,
+            "basedir": getattr(script, "basedir", "") or "",
+            "module": False,
+        })
+
+    seen_module_paths = set()
+    for script in scripts.list_scripts("javascript", ".mjs"):
+        norm_path = os.path.normpath(script.path)
+        if norm_path in seen_module_paths:
+            continue
+        seen_module_paths.add(norm_path)
+
+        role = _script_kind(script)
+        entries.append({
+            "src": webpath(script.path),
+            "role": role,
+            "mode": "module",
+            "path": script.path,
+            "basedir": getattr(script, "basedir", "") or "",
+            "module": True,
+        })
+
+    return entries
+
+
+def _script_registry_bootstrap_html(entries):
+    manifest = {
+        "mode": _get_extension_mode(),
+        "scripts": {
+            entry["src"]: {
+                "role": entry["role"],
+                "mode": entry["mode"],
+                "path": entry["path"],
+                "basedir": entry["basedir"],
+                "injected": True,
+            }
+            for entry in entries
+        },
+        "loaded": {},
+        "errors": {},
+        "injected_order": [entry["src"] for entry in entries],
+    }
+
+    manifest_json = json.dumps(manifest, ensure_ascii=False)
+
+    return (
+        '<script type="text/javascript">\n'
+        '(function(){\n'
+        f'  var manifest = {manifest_json};\n'
+        '  var reg = window.__a1111ScriptRegistry = window.__a1111ScriptRegistry || manifest;\n'
+        '  reg.mode = manifest.mode;\n'
+        '  reg.scripts = reg.scripts || {};\n'
+        '  reg.loaded = reg.loaded || {};\n'
+        '  reg.errors = reg.errors || {};\n'
+        '  reg.injected_order = reg.injected_order || [];\n'
+        '  for (var src in manifest.scripts) {\n'
+        '    if (!Object.prototype.hasOwnProperty.call(manifest.scripts, src)) continue;\n'
+        '    reg.scripts[src] = reg.scripts[src] || manifest.scripts[src];\n'
+        '  }\n'
+        '  for (var i = 0; i < manifest.injected_order.length; i++) {\n'
+        '    var injectedSrc = manifest.injected_order[i];\n'
+        '    if (!reg.injected_order.includes(injectedSrc)) {\n'
+        '      reg.injected_order.push(injectedSrc);\n'
+        '    }\n'
+        '  }\n'
+        '  window.__a1111RegisterScript = window.__a1111RegisterScript || function(el){\n'
+        '    if (!el) return;\n'
+        '    var src = el.getAttribute("src") || "";\n'
+        '    reg.scripts[src] = reg.scripts[src] || {\n'
+        '      role: el.getAttribute("data-a1111-role") || "unknown",\n'
+        '      mode: el.getAttribute("data-a1111-mode") || "unknown",\n'
+        '      path: el.getAttribute("data-a1111-path") || src,\n'
+        '      basedir: el.getAttribute("data-a1111-basedir") || "",\n'
+        '      injected: true\n'
+        '    };\n'
+        '    if (!reg.injected_order.includes(src)) {\n'
+        '      reg.injected_order.push(src);\n'
+        '    }\n'
+        '  };\n'
+        '  window.__a1111MarkScriptLoaded = window.__a1111MarkScriptLoaded || function(el){\n'
+        '    if (!el) return;\n'
+        '    window.__a1111RegisterScript(el);\n'
+        '    var src = el.getAttribute("src") || "";\n'
+        '    reg.loaded[src] = true;\n'
+        '  };\n'
+        '  window.__a1111MarkScriptError = window.__a1111MarkScriptError || function(el){\n'
+        '    if (!el) return;\n'
+        '    window.__a1111RegisterScript(el);\n'
+        '    var src = el.getAttribute("src") || "";\n'
+        '    reg.errors[src] = true;\n'
+        '    console.error("[a1111-loader] script load failed:", el.getAttribute("data-a1111-path") || src);\n'
+        '  };\n'
+        '})();\n'
+        '</script>\n'
+    )
+
+
+def _script_tag(src, *, role, mode, path, basedir, module=False):
+    attrs = [
+        'type="module"' if module else 'type="text/javascript"',
+        f'src="{html.escape(src, quote=True)}"',
+        f'data-a1111-role="{html.escape(role, quote=True)}"',
+        f'data-a1111-mode="{html.escape(mode, quote=True)}"',
+        f'data-a1111-path="{html.escape(path, quote=True)}"',
+        f'data-a1111-basedir="{html.escape(basedir, quote=True)}"',
+        'onload="window.__a1111MarkScriptLoaded&&window.__a1111MarkScriptLoaded(this)"',
+        'onerror="window.__a1111MarkScriptError&&window.__a1111MarkScriptError(this)"',
+    ]
+    if not module and mode == "defer":
+        attrs.append("defer")
+    return f'<script {" ".join(attrs)}></script>\n'
+
+
+def javascript_html():
+    # Localize first so extensions that read localization see it immediately.
+    head = f'<script type="text/javascript">{localization.localization_js(shared.opts.localization)}</script>\n'
+
+    entries = _build_script_entries()
+
+    # Bootstrap loader diagnostics before any external scripts.
+    head += _script_registry_bootstrap_html(entries)
+
+    for entry in entries:
+        head += _script_tag(
+            entry["src"],
+            role=entry["role"],
+            mode=entry["mode"],
+            path=entry["path"],
+            basedir=entry["basedir"],
+            module=entry["module"],
+        )
+
+    if shared.cmd_opts.theme:
+        head += f'<script type="text/javascript">set_theme("{shared.cmd_opts.theme}");</script>\n'
+
+    return head
+
+
+def css_html():
+    head = ""
+
+    def stylesheet(fn):
+        return f'<link rel="stylesheet" property="stylesheet" href="{webpath(fn)}">'
+
+    for cssfile in scripts.list_files_with_name("style.css"):
+        head += stylesheet(cssfile)
+
+    user_css = os.path.join(data_path, "user.css")
+    if os.path.exists(user_css):
+        head += stylesheet(user_css)
+
+    from modules.shared_gradio_themes import resolve_var
+    light = resolve_var('background_fill_primary')
+    dark = resolve_var('background_fill_primary_dark')
+    head += f'<style>html {{ background-color: {light}; }} @media (prefers-color-scheme: dark) {{ html {{background-color:  {dark}; }} }}</style>'
+
+    return head
+
+
+def reload_javascript():
+    js = javascript_html()
+    css = css_html()
+
+    def template_response(*args, **kwargs):
+        res = shared.GradioTemplateResponseOriginal(*args, **kwargs)
+        res.body = res.body.replace(b'</head>', f'{js}<meta name="referrer" content="no-referrer"/></head>'.encode("utf8"))
+        res.body = res.body.replace(b'</body>', f'{css}</body>'.encode("utf8"))
+        res.init_headers()
+        return res
+
+    gr.routes.templates.TemplateResponse = template_response
+
+
+if not hasattr(shared, 'GradioTemplateResponseOriginal'):
+    shared.GradioTemplateResponseOriginal = gr.routes.templates.TemplateResponse