create-outsystems-astro 0.9.0 → 0.10.0

package/integrations/eslint.config.mjs

@@ -0,0 +1,61 @@
+import { fixupPluginRules } from "@eslint/compat";
+import pluginJs from "@eslint/js";
+import eslintConfigPrettier from "eslint-config-prettier";
+import eslintPluginAstro from "eslint-plugin-astro";
+import importPlugin from "eslint-plugin-import";
+import perfectionist from "eslint-plugin-perfectionist";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+
+// Fix for Bun and eslint-plugin-perfectionist.
+if (!Array.prototype.toSorted) {
+  Array.prototype.toSorted = function (compareFn) {
+    return [...this].sort(compareFn);
+  };
+}
+
+/** @type {import('eslint').Linter.Config[]} */
+export default [
+  {
+    ignores: [".astro/*", "dist/*", "node_modules/*"],
+  },
+  { languageOptions: { globals: { ...globals.browser, ...globals.node } } },
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended.map((config) => ({
+    ...config,
+    files: ["**/*.{ts,tsx}"],
+  })),
+  ...eslintPluginAstro.configs.recommended,
+  {
+    files: ["**/*.{js,mjs,cjs,ts,jsx,tsx}"],
+    plugins: {
+      import: fixupPluginRules(importPlugin),
+    },
+    rules: {
+      "import/order": [
+        "error",
+        {
+          alphabetize: {
+            caseInsensitive: true,
+            order: "asc",
+          },
+          groups: ["builtin", "external", "internal", "parent", "sibling"],
+          pathGroups: [
+            {
+              group: "internal",
+              pattern: "~/**",
+              position: "after",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  eslintConfigPrettier,
+  perfectionist.configs["recommended-alphabetical"],
+  {
+    rules: {
+      "perfectionist/sort-imports": ["off"],
+    },
+  },
+];

package/integrations/html/client.ts

@@ -0,0 +1,30 @@
+const client_default =
+  (element: HTMLElement) =>
+  (
+    Component: unknown,
+    props: Record<string, unknown>,
+    { client }: { client: string },
+  ) => {
+    if (client !== "only" && !element.hasAttribute("ssr")) return;
+
+    let html: string;
+    if (typeof Component === "string") {
+      html = Component;
+    } else if (typeof Component === "function") {
+      html = (Component as (p: Record<string, unknown>) => string)({
+        ...props,
+      });
+    } else {
+      html = "";
+    }
+
+    element.innerHTML = html;
+
+    element.querySelectorAll("script").forEach((oldScript) => {
+      const newScript = document.createElement("script");
+      newScript.textContent = oldScript.textContent;
+      oldScript.parentNode?.replaceChild(newScript, oldScript);
+    });
+  };
+
+export default client_default;

package/integrations/html/index.ts

@@ -0,0 +1,57 @@
+import type { AstroIntegration, AstroRenderer } from "astro";
+
+const VIRTUAL_SERVER_ID = "virtual:islands/html/server-with-filter";
+const RESOLVED_VIRTUAL_SERVER_ID = `\0${VIRTUAL_SERVER_ID}`;
+
+function getRenderer(filtered: boolean): AstroRenderer {
+  return {
+    clientEntrypoint: "islands-integrations/html/client",
+    name: "islands/html",
+    serverEntrypoint: filtered
+      ? VIRTUAL_SERVER_ID
+      : "islands-integrations/html/server",
+  };
+}
+
+export const getContainerRenderer = (): AstroRenderer => getRenderer(false);
+
+export interface Options {
+  exclude?: string[];
+  include?: string[];
+}
+
+export default function (options: Options = {}): AstroIntegration {
+  const { exclude, include } = options;
+  const filtered = !!(include?.length || exclude?.length);
+
+  return {
+    hooks: {
+      "astro:config:setup": ({ addRenderer, updateConfig }) => {
+        addRenderer(getRenderer(filtered));
+        updateConfig({
+          vite: filtered
+            ? {
+                plugins: [
+                  {
+                    load(id: string) {
+                      if (id !== RESOLVED_VIRTUAL_SERVER_ID) return;
+                      return [
+                        `import { createRenderer } from "islands-integrations/html/server";`,
+                        `export default createRenderer(${JSON.stringify(include)}, ${JSON.stringify(exclude)});`,
+                      ].join("\n");
+                    },
+                    name: "islands/html/filter",
+                    resolveId(id: string) {
+                      if (id === VIRTUAL_SERVER_ID)
+                        return RESOLVED_VIRTUAL_SERVER_ID;
+                    },
+                  },
+                ],
+              }
+            : {},
+        });
+      },
+    },
+    name: "islands/html",
+  };
+}

package/integrations/html/server.ts

@@ -0,0 +1,54 @@
+import type {
+  AstroComponentMetadata,
+  NamedSSRLoadedRendererValue,
+} from "astro";
+
+export function createRenderer(
+  include?: string[],
+  exclude?: string[],
+): NamedSSRLoadedRendererValue {
+  return {
+    check: async (
+      Component: unknown,
+      _props: unknown,
+      _slots: unknown,
+      metadata?: AstroComponentMetadata,
+    ) => {
+      const url = metadata?.componentUrl;
+      if (url) {
+        if (include && !matchesPatterns(url, include)) return false;
+        if (exclude && matchesPatterns(url, exclude)) return false;
+      }
+      return checkComponent(Component);
+    },
+    name: "islands/html",
+    renderToStaticMarkup,
+    supportsAstroStaticSlot: false,
+  };
+}
+
+async function checkComponent(Component: unknown): Promise<boolean> {
+  if (typeof Component === "string") return true;
+  if (typeof Component === "function") {
+    try {
+      const result = (Component as (p: Record<string, unknown>) => unknown)({});
+      return typeof result === "string";
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+function matchesPatterns(url: string, patterns: string[]): boolean {
+  return patterns.some((pattern) => {
+    const prefix = pattern.replace(/\/?\*+$/, "");
+    return url.includes(prefix);
+  });
+}
+
+async function renderToStaticMarkup(): Promise<{ html: string }> {
+  return { html: "" };
+}
+
+export default createRenderer();