fullstacked 1.0.0-alpha.1696 → 1.0.0-alpha.1706

package/index.js

@@ -90,9 +90,11 @@ var Stream = 1;
 var Path = 4;
 var Os = 5;
 var Bundle = 9;
+var Plugin = 15;
 var CoreResponseError = 0;
 var CoreResponseData = 1;
 var CoreResponseStream = 2;
+var PluginTypeBuild = "build";
 var UNDEFINED = 0;
 var BOOLEAN = 1;
 var STRING = 2;
@@ -624,8 +626,8 @@ function createWebSocketServer(core3, ctx, server, close) {
     webSockets.add(ws);
     ws.on("close", () => onClose(ws));
   };
-  const onUpgrade = (...args3) => {
-    wss.handleUpgrade(...args3, handleUpgrade);
+  const onUpgrade = (...args2) => {
+    wss.handleUpgrade(...args2, handleUpgrade);
   };
   server.on("upgrade", onUpgrade);
   return webSockets;
@@ -773,6 +775,12 @@ async function BridgeAppleInit() {
           clipboardResponsePromises.set(id2, resolve2);
         });
       };
+      globalThis.copy = function(text) {
+        globalThis.webkit.messageHandlers.clipboard.postMessage({
+          action: "copy",
+          text
+        });
+      };
     }
     if (globalThis.webkit.messageHandlers.resize) {
       const resizeResponsePromises = [];
@@ -1048,8 +1056,8 @@ function createEventEmitter(duplex) {
       let listeners = eventListeners.get(event);
       listeners?.delete(callback);
     },
-    writeEvent(event, ...args3) {
-      duplex.writeEvent(event, ...args3);
+    writeEvent(event, ...args2) {
+      duplex.writeEvent(event, ...args2);
     }
   };
 }
@@ -1228,25 +1236,36 @@ function createDuplex(id2, bridgeFn) {
       data: [id2, data]
     });
   };
-  stream.writeEvent = async (event, ...args3) => {
+  stream.writeEvent = async (event, ...args2) => {
     if (!duplex.open) {
       await open2();
     }
     return bridgeFn({
       mod: Stream,
       fn: WriteEvent,
-      data: [id2, event, ...args3]
+      data: [id2, event, ...args2]
     });
   };
   stream.end = async () => {
     if (!duplex.open) {
       await open2();
     }
-    return bridgeFn({
+    const res = await bridgeFn({
       mod: Stream,
       fn: Close,
       data: [id2]
     });
+    if (duplex.done) {
+      return res;
+    }
+    await new Promise((resolve2) => {
+      const onClose = () => {
+        duplex.listeners.close.delete(onClose);
+        resolve2();
+      };
+      duplex.listeners.close.add(onClose);
+    });
+    return res;
   };
   stream.promise = async () => {
     let data = new Uint8Array();
@@ -1294,6 +1313,9 @@ function bridge(opts, sync) {
   }
   return new Promise(async (resolve2, reject) => {
     await platform_default.ready;
+    if (globalThis.pluginConnectionPromise && !(opts.mod === 15 && opts.fn === 0)) {
+      await globalThis.pluginConnectionPromise;
+    }
     const payload = preparePayload();
     const responseBuffer = await platform_default.bridge.Async(
       payload.buffer
@@ -1332,7 +1354,6 @@ function processResponse(buffer) {
 
 // ../../core/internal/bundle/lib/@types/bundle.ts
 var BundleDir = 1;
-var BuilderTailwindCSS = 3;
 
 // ../../core/internal/bundle/lib/@types/path.ts
 var Join = 0;
@@ -1551,39 +1572,209 @@ function bundle(entryPoint) {
     ee.on("result", resolve2);
   });
 }
-async function builderTailwindCSS() {
-  return (await bridge({
-    mod: Bundle,
-    fn: BuilderTailwindCSS
-  })).eventEmitter();
+
+// ../../core/internal/bundle/lib/@types/plugin.ts
+var StartPluginStream = 0;
+var Register = 1;
+var Unregister = 2;
+
+// ../../core/internal/bundle/lib/plugin/index.ts
+var plugins = /* @__PURE__ */ new Map();
+var duplexStream = null;
+var eventEmitter = null;
+var connectionPromise = null;
+var te4 = new TextEncoder();
+async function connect() {
+  if (duplexStream) {
+    return;
+  }
+  const duplex = await bridge({
+    mod: Plugin,
+    fn: StartPluginStream
+  });
+  await duplex.open();
+  duplexStream = duplex;
+  eventEmitter = duplex.eventEmitter();
+  eventEmitter.on(
+    "plugin-call",
+    async (pluginId, requestId, ...args2) => {
+      let result2 = null;
+      let errorMsg = null;
+      try {
+        const registeredPlugin = plugins.get(pluginId);
+        if (registeredPlugin) {
+          result2 = await registeredPlugin.callback(...args2);
+          if (registeredPlugin.type === PluginTypeBuild) {
+            const remappedResult = [];
+            result2.forEach(({ outputName, contents }) => {
+              contents = typeof contents === "string" ? te4.encode(contents) : contents;
+              remappedResult.push(outputName, contents);
+            });
+            result2 = remappedResult;
+          }
+        } else {
+          throw new Error(
+            `No registered plugin found for id: ${pluginId}`
+          );
+        }
+      } catch (err) {
+        errorMsg = err.message || String(err);
+      }
+      if (Array.isArray(result2)) {
+        eventEmitter.writeEvent(
+          "plugin-response",
+          pluginId,
+          requestId,
+          errorMsg,
+          ...result2
+        );
+      } else {
+        eventEmitter.writeEvent(
+          "plugin-response",
+          pluginId,
+          requestId,
+          errorMsg,
+          result2
+        );
+      }
+    }
+  );
+}
+async function register(type2, plugin2) {
+  if (!connectionPromise) {
+    connectionPromise = connect();
+  }
+  await connectionPromise;
+  const { name, ...pluginData } = plugin2.data || {};
+  const id2 = await bridge({
+    mod: Plugin,
+    fn: Register,
+    data: [type2, name || "plugin-" + type2, pluginData]
+  });
+  plugins.set(id2, { type: type2, callback: plugin2.callback });
+  return {
+    unregister: async () => {
+      plugins.delete(id2);
+      await bridge({
+        mod: Plugin,
+        fn: Unregister,
+        data: [id2]
+      });
+    }
+  };
 }
+var plugin = {
+  register
+};
+var plugin_default = plugin;
 
 // ../../core/internal/bundle/lib/run/index.ts
 function run(directoryOrOptions) {
   const directory2 = typeof directoryOrOptions === "string" ? directoryOrOptions : directoryOrOptions?.directory;
-  const env = typeof directoryOrOptions === "object" ? directoryOrOptions.env : void 0;
+  const env2 = typeof directoryOrOptions === "object" ? directoryOrOptions.env : void 0;
   const resolved = path_default.resolve(directory2 ?? ".");
   return bridge({
     mod: Core,
     fn: Run,
-    data: [resolved, env]
+    data: [resolved, env2]
   });
 }
 
 // ../../core/internal/bundle/lib/process/version.json
-var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1696", hash: "78be2a93cd4be4d52e13672db2a7826f2023e230" };
+var version_default = { major: "1", minor: "0", patch: "0-alpha", branch: "v1", build: "1706", hash: "83a224d4d1c01ade773cdc6ba8edf0074686f3e7" };
+
+// src/args.ts
+function findArg(aliases, hasValueOrArgs, customArgs) {
+  const hasValue = typeof hasValueOrArgs === "boolean" ? hasValueOrArgs : false;
+  const args2 = Array.isArray(hasValueOrArgs) ? hasValueOrArgs : customArgs || process.argv.slice(2);
+  const values = [];
+  let present = false;
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (aliases.includes(arg)) {
+      present = true;
+      if (hasValue) {
+        const next = args2[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          values.push(next);
+          i++;
+        } else {
+          values.push("");
+        }
+      }
+    } else if (hasValue) {
+      for (const alias of aliases) {
+        if (arg.startsWith(alias + "=")) {
+          values.push(arg.slice(alias.length + 1));
+          present = true;
+          break;
+        }
+      }
+    }
+  }
+  return hasValue ? values : present;
+}
+function getPositionalArgs(args2 = process.argv.slice(2)) {
+  const positional = [];
+  const valueFlags = [
+    ["-e", "--env"],
+    ["-p", "--port"]
+  ];
+  const booleanFlags = [
+    ["-h", "--help"],
+    ["-v", "--version"],
+    ["-o", "--open"],
+    ["-b", "--build"]
+  ];
+  for (let i = 0; i < args2.length; i++) {
+    const arg = args2[i];
+    if (booleanFlags.some((aliases) => aliases.includes(arg))) {
+      continue;
+    }
+    let isValueFlag = false;
+    for (const aliases of valueFlags) {
+      if (aliases.includes(arg)) {
+        const next = args2[i + 1];
+        if (next !== void 0 && !next.startsWith("-")) {
+          i++;
+        }
+        isValueFlag = true;
+        break;
+      }
+      let matchedPrefix = false;
+      for (const alias of aliases) {
+        if (arg.startsWith(alias + "=")) {
+          matchedPrefix = true;
+          break;
+        }
+      }
+      if (matchedPrefix) {
+        isValueFlag = true;
+        break;
+      }
+    }
+    if (isValueFlag) {
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      continue;
+    }
+    positional.push(arg);
+  }
+  return positional;
+}
 
 // src/index.ts
-import postcss from "postcss";
-import atImport from "postcss-import";
-import tailwindcss from "@tailwindcss/postcss";
-import autoprefixer from "autoprefixer";
-import fs3 from "node:fs";
-var end = () => {
+import pluginTailwindcss, {
+  initialize
+} from "@fullstacked/tailwindcss/index.ts";
+var end = (code2) => {
   core2.end();
-  process.exit();
+  process.exit(code2);
 };
-["SIGINT", "SIGTERM", "SIGQUIT"].forEach((signal) => process.on(signal, end));
+["SIGINT", "SIGTERM", "SIGQUIT"].forEach(
+  (signal) => process.on(signal, () => end(0))
+);
 var webviews = /* @__PURE__ */ new Map();
 var core2 = await load(
   (ctx, streamId, buffer) => {
@@ -1606,12 +1797,23 @@ var core2 = await load(
     });
   }
 );
-var args2 = process.argv.slice(2);
-var help = args2.includes("-h") || args2.includes("--help");
-var showVersion = args2.includes("-v") || args2.includes("--version");
-var openBrowser = args2.includes("-o") || args2.includes("--open");
-var buildOnly = args2.includes("-b") || args2.includes("--build");
-var positionalArgs = args2.filter((arg) => !arg.startsWith("-"));
+var help = findArg(["-h", "--help"]);
+var showVersion = findArg(["-v", "--version"]);
+var openBrowser = findArg(["-o", "--open"]);
+var buildOnly = findArg(["-b", "--build"]);
+var envArgs = findArg(["-e", "--env"], true);
+var env = {};
+for (const val of envArgs) {
+  const index = val.indexOf("=");
+  if (index !== -1) {
+    const key = val.slice(0, index);
+    const value = val.slice(index + 1);
+    env[key] = value;
+  } else if (val) {
+    env[val] = "";
+  }
+}
+var positionalArgs = getPositionalArgs();
 var directory = path3.resolve(positionalArgs.at(-1) || ".");
 if (showVersion) {
   console.log(
@@ -1641,35 +1843,23 @@ globalThis.bridges = {
   Sync: (payload) => core2.call(payload),
   Async: async (payload) => core2.call(payload)
 };
-var tailwindcssBuilder = await builderTailwindCSS();
-tailwindcssBuilder.on("build", async (entryfile, outfile) => {
-  const from = path3.resolve(directory, entryfile);
-  const to = path3.resolve(directory, outfile);
-  const css = await fs3.promises.readFile(from, "utf-8");
-  const result2 = await postcss([
-    atImport({
-      addModulesDirectories: [
-        path3.resolve(import.meta.dirname, "node_modules")
-      ]
-    }),
-    tailwindcss(),
-    autoprefixer()
-  ]).process(css, {
-    from,
-    to
-  });
-  await fs3.promises.writeFile(to, result2.css);
-  tailwindcssBuilder.writeEvent("build-done");
+await initialize({
+  oxide: "node_modules/oxide-wasm/pkg/oxide_wasm_bg.wasm",
+  lightningcss: "node_modules/lightningcss-wasm/lightningcss_node.wasm",
+  tailwindcss: "node_modules/tailwindcss",
+  baseDirectory: directory
 });
+await plugin_default.register("build", pluginTailwindcss);
 var result = await bundle();
 if (result.Warnings?.length) {
   console.warn("Warnings:", result.Warnings);
 }
 if (result.Errors?.length) {
   console.error("Errors:", result.Errors);
+  end(1);
 } else if (!buildOnly) {
-  run();
+  run({ env });
 } else {
   console.log("Build complete.");
-  end();
+  end(0);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fullstacked",
-    "version": "1.0.0-alpha.1696",
+    "version": "1.0.0-alpha.1706",
     "bin": {
         "fullstacked": "index.js"
     },
@@ -10,12 +10,8 @@
         "prepack": "npm run build"
     },
     "dependencies": {
-        "@tailwindcss/postcss": "^4.3.1",
-        "autoprefixer": "^10.5.0",
+        "@fullstacked/tailwindcss": "github:fullstackedorg/tailwindcss",
         "open": "^11.0.0",
-        "postcss": "^8.5.15",
-        "postcss-import": "^16.1.1",
-        "tailwindcss": "^4.3.1",
         "ws": "^8.21.0"
     },
     "devDependencies": {
@@ -25,12 +21,12 @@
         "node-addon-api": "^8.8.0"
     },
     "optionalDependencies": {
-        "@fullstacked/darwin-arm64": "1.0.0-alpha.1696",
-        "@fullstacked/darwin-x64": "1.0.0-alpha.1696",
-        "@fullstacked/linux-arm64": "1.0.0-alpha.1696",
-        "@fullstacked/linux-x64": "1.0.0-alpha.1696",
-        "@fullstacked/win32-arm64": "1.0.0-alpha.1696",
-        "@fullstacked/win32-x64": "1.0.0-alpha.1696"
+        "@fullstacked/darwin-arm64": "1.0.0-alpha.1706",
+        "@fullstacked/darwin-x64": "1.0.0-alpha.1706",
+        "@fullstacked/linux-arm64": "1.0.0-alpha.1706",
+        "@fullstacked/linux-x64": "1.0.0-alpha.1706",
+        "@fullstacked/win32-arm64": "1.0.0-alpha.1706",
+        "@fullstacked/win32-x64": "1.0.0-alpha.1706"
     },
     "author": "FullStacked",
     "license": "MIT",
@@ -53,6 +49,9 @@
         "./packages": {
             "types": "./types/packages/index.d.ts"
         },
+        "./plugin": {
+            "types": "./types/plugin/index.d.ts"
+        },
         "./run": {
             "types": "./types/run/index.d.ts"
         },

package/types/@types/bundle.d.ts

@@ -4,12 +4,27 @@ export declare const BundleDir: BundleFn;
 export declare const BundleFile: BundleFn;
 export declare const BuilderTailwindCSS: BundleFn;
 export declare const BuilderSASS: BundleFn;
-export interface TailwindCSSBuilder {
-}
 export interface EsbuildResult {
     OutputFiles: string[];
     Errors: any[];
     Warnings: any[];
 }
+export interface PluginBuildData {
+    filter: string;
+    ext?: string[];
+}
+export interface PluginResolvedFile {
+    importer: string;
+    path: string;
+    resolvedDir: string;
+}
+export interface PluginParams {
+    sources: string[];
+    resolved: PluginResolvedFile[];
+}
+export interface BuildPluginOutputFile {
+    outputName: string;
+    contents: string;
+}
 export interface DocumentHTML {
 }

package/types/@types/git.d.ts

@@ -12,7 +12,6 @@ export declare const RefTag: GitRefType;
 export interface CustomFS {
 }
 export type GitFn = number;
-export declare const AuthManager: GitFn;
 export declare const HasGit: GitFn;
 export declare const Init: GitFn;
 export declare const Head: GitFn;
@@ -30,7 +29,7 @@ export declare const Checkout: GitFn;
 export declare const Merge: GitFn;
 export declare const Restore: GitFn;
 export interface HTTPBasicAuth {
-    GitAuth?: GitAuth;
+    GitAuth?: any;
 }
 export interface GitHead {
     branch: string;
@@ -60,12 +59,6 @@ export interface GitCommit {
 export declare const DateFormat = "Mon Jan 2 15:04:05 2006 -0700";
 export interface GitStream {
 }
-export interface GitAuth {
-    host: string;
-    username: string;
-    password: string;
-    email: string;
-}
 export interface GitBranch {
     name: string;
     remote: boolean;

package/types/@types/index.d.ts

@@ -14,6 +14,7 @@ export declare const Git: CoreModule;
 export declare const Packages: CoreModule;
 export declare const Sentry: CoreModule;
 export declare const Dgram: CoreModule;
+export declare const Plugin: CoreModule;
 export type ModuleSwitch = any;
 export type CoreCallResponseType = number;
 export declare const CoreResponseError: CoreCallResponseType;
@@ -53,6 +54,30 @@ export interface ContextDirectories {
     Root: string;
     Build: string;
 }
+export declare const PluginTypeGitAuth = "git-auth";
+export declare const PluginTypeBuild = "build";
+export type PluginType = typeof PluginTypeGitAuth | typeof PluginTypeBuild;
+export interface PluginRequest {
+    Response: DeserializedData[];
+    ResponseError?: string;
+    Wg?: any;
+}
+export interface ContextPlugin {
+    Id: number;
+    Name: string;
+    Type: PluginType;
+    Data: DeserializedRawObject;
+    Requests: {
+        [key: number]: PluginRequest | undefined;
+    };
+    RequestsMutex?: any;
+}
+export interface GitAuth {
+    host: string;
+    username: string;
+    password: string;
+    email: string;
+}
 export interface Context {
     Id: number;
     Directories: ContextDirectories;
@@ -68,6 +93,15 @@ export interface Context {
     };
     StreamsMutex?: any;
     NextStreamId: number;
+    PluginStreamId: number;
+    Plugins: {
+        [key: number]: ContextPlugin | undefined;
+    };
+    PluginsMutex?: any;
+    GitAuths: {
+        [key: string]: GitAuth | undefined;
+    };
+    GitAuthsMutex?: any;
     Exit: boolean;
 }
 export type SerializableData = any;

package/types/@types/plugin.d.ts

@@ -0,0 +1,4 @@
+export type PluginFn = number;
+export declare const StartPluginStream: PluginFn;
+export declare const Register: PluginFn;
+export declare const Unregister: PluginFn;

package/types/bridge/duplex.d.ts

@@ -8,7 +8,7 @@ export interface Duplex extends ReadableStream<Uint8Array<ArrayBuffer>> {
     on(event: "close", callback: EndCallback): void;
     write(data: StreamData): Promise<any>;
     writeEvent(event: string, ...args: SerializableData[]): Promise<any>;
-    end(chunk?: StreamData, encoding?: string | EndCallback, callback?: EndCallback): void;
+    end(): Promise<any>;
     promise(): Promise<any>;
     eventEmitter(): ReturnType<typeof createEventEmitter>;
     open(): Promise<void>;

package/types/bundle/index.d.ts

@@ -1,12 +1,10 @@
 import { EsbuildResult } from "../@types/bundle.ts";
-import { EventEmitter } from "../bridge/eventEmitter.ts";
 export declare function esbuildVersion(): Promise<string>;
 export declare function bundle(entryPoint?: string): Promise<EsbuildResult>;
 export declare function bundleFile(entryPoint: string): Promise<EsbuildResult>;
-export declare function builderTailwindCSS(): Promise<EventEmitter<{
-    build: string[];
-    "build-done": [];
-}>>;
+export declare function builderTailwindCSS(): Promise<{
+    on(): void;
+}>;
 declare const bundler: {
     esbuildVersion: typeof esbuildVersion;
     bundle: typeof bundle;

package/types/git/index.d.ts

@@ -1,10 +1,8 @@
-import { GitAuth, GitAuthor, GitBranch, GitCommit, GitHead, GitStatus, GitTag } from "../@types/git.ts";
+import { GitAuthor, GitBranch, GitCommit, GitHead, GitStatus, GitTag } from "../@types/git.ts";
 import type { Duplex } from "../bridge/duplex.ts";
-import { EventEmitter } from "../bridge/eventEmitter.ts";
-export declare function createGitAuthManager(): Promise<EventEmitter<{
-    auth: [string];
-    authResponse: [string, Partial<GitAuth>];
-}>>;
+export declare function createGitAuthManager(): Promise<{
+    on(): void;
+}>;
 export declare function hasGit(directory: string): Promise<boolean>;
 export declare function init(directory: string, url: string): Promise<any>;
 export declare function head(directory: string): Promise<GitHead>;
@@ -22,7 +20,6 @@ export declare function checkout(directory: string, ref: string, create?: boolea
 export declare function merge(directory: string, branch: string): Promise<any>;
 export declare function restore(directory: string, ...files: string[]): Promise<any>;
 declare const git: {
-    createGitAuthManager: typeof createGitAuthManager;
     hasGit: typeof hasGit;
     init: typeof init;
     head: typeof head;
@@ -39,5 +36,6 @@ declare const git: {
     checkout: typeof checkout;
     merge: typeof merge;
     restore: typeof restore;
+    createGitAuthManager: typeof createGitAuthManager;
 };
 export default git;

package/types/plugin/index.d.ts

@@ -0,0 +1,32 @@
+import { GitAuth, PluginTypeGitAuth, PluginTypeBuild } from "../@types/index.ts";
+import { PluginBuildData, PluginResolvedFile } from "../@types/bundle.ts";
+type CommonPluginData = {
+    name?: string;
+};
+export type PluginRegistry = {
+    [PluginTypeGitAuth]: {
+        data?: CommonPluginData;
+        callback: (host: string) => Promise<Partial<GitAuth>> | Partial<GitAuth>;
+    };
+    [PluginTypeBuild]: {
+        data?: CommonPluginData & PluginBuildData;
+        callback: (params: {
+            resolved: PluginResolvedFile[];
+            sources: string[];
+        }) => Promise<{
+            outputName: string;
+            contents: string | Uint8Array;
+        }[]>;
+    };
+};
+export interface JSPlugin {
+    type: string;
+    callback: (...args: any[]) => Promise<any | any[]> | any | any[];
+}
+export declare function register<T extends keyof PluginRegistry>(type: T, plugin: PluginRegistry[T]): Promise<{
+    unregister: () => Promise<void>;
+}>;
+declare const plugin: {
+    register: typeof register;
+};
+export default plugin;