attio 0.0.1-experimental.20250328.1 → 0.0.1-experimental.20250401.1

package/lib/machines/js-machine.js

@@ -1,231 +0,0 @@
-import * as esbuild from "esbuild";
-import fs from "fs/promises";
-import path from "path";
-import tmp from "tmp-promise";
-import { assign, setup, fromCallback, sendTo } from "xstate";
-import { errorsAndWarningsSchema } from "../build.js";
-import { createClientBuildConfig } from "../build/client/create-client-build-config.js";
-import { generateClientEntry } from "../build/client/generate-client-entry.js";
-import { createServerBuildConfig } from "../build/server/create-server-build-config.js";
-import { generateServerEntry } from "../build/server/generate-server-entry.js";
-export const jsMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    guards: {
-        "has errors": (_, params) => Boolean(params.errors),
-    },
-    actors: {
-        prepareBuildContext: fromCallback(({ sendBack, input: { write } }) => {
-            let buildContexts;
-            const prepare = async () => {
-                const srcDir = "src";
-                const assetsDir = path.join(srcDir, "assets");
-                const webhooksDir = path.join(srcDir, "webhooks");
-                const eventsDir = path.join(srcDir, "events");
-                buildContexts = (await Promise.all([
-                    tmp.file({ postfix: ".js" }).then(async (tempFile) => {
-                        let lastJS;
-                        const updateTempFile = async () => {
-                            const js = await generateClientEntry({
-                                srcDirAbsolute: path.resolve(srcDir),
-                                assetsDirAbsolute: path.resolve(assetsDir),
-                            });
-                            if (js === lastJS) {
-                                return;
-                            }
-                            lastJS = js;
-                            await fs.writeFile(tempFile.path, js);
-                        };
-                        const esbuildContext = await esbuild.context({
-                            ...createClientBuildConfig({
-                                entryPoint: tempFile.path,
-                                srcDir,
-                            }),
-                            write,
-                            outfile: path.resolve("dist", "index.js"),
-                            loader: { ".png": "dataurl", ".graphql": "text", ".gql": "text" },
-                        });
-                        return {
-                            rebuild: async () => {
-                                await updateTempFile();
-                                return esbuildContext.rebuild();
-                            },
-                            dispose: async () => {
-                                await Promise.all([
-                                    esbuildContext.dispose(),
-                                    tempFile.cleanup(),
-                                ]);
-                            },
-                        };
-                    }),
-                    tmp.file({ postfix: ".js" }).then(async (tempFile) => {
-                        let lastJS;
-                        const updateTempFile = async () => {
-                            const js = await generateServerEntry({
-                                srcDirAbsolute: path.resolve(srcDir),
-                                webhooksDirAbsolute: path.resolve(webhooksDir),
-                                eventDirAbsolute: path.resolve(eventsDir),
-                            });
-                            if (js === lastJS) {
-                                return;
-                            }
-                            lastJS = js;
-                            await fs.writeFile(tempFile.path, js);
-                        };
-                        const esbuildContext = await esbuild.context({
-                            ...createServerBuildConfig(tempFile.path),
-                            write,
-                            outfile: path.resolve("dist", "server.js"),
-                        });
-                        return {
-                            rebuild: async () => {
-                                await updateTempFile();
-                                return esbuildContext.rebuild();
-                            },
-                            dispose: async () => {
-                                await Promise.all([
-                                    esbuildContext.dispose(),
-                                    tempFile.cleanup(),
-                                ]);
-                            },
-                        };
-                    }),
-                ])).flat();
-                sendBack({
-                    type: "Build Contexts Prepared",
-                    buildContexts,
-                });
-            };
-            prepare();
-            return async () => {
-                if (!buildContexts)
-                    return;
-                await Promise.all(buildContexts.map(async (context) => context.dispose()));
-            };
-        }),
-        build: fromCallback(({ sendBack, input }) => {
-            const { buildContexts, write } = input;
-            const build = async () => {
-                try {
-                    const results = await Promise.all(buildContexts.map(async (buildContext) => buildContext.rebuild()));
-                    sendBack({
-                        type: "Result",
-                        contents: write
-                            ? ["", ""]
-                            : results.map((result) => result.outputFiles[0].text),
-                        time: new Date(),
-                    });
-                }
-                catch (e) {
-                    sendBack({
-                        type: "Result",
-                        errors: errorsAndWarningsSchema.parse(e),
-                        time: new Date(),
-                    });
-                }
-            };
-            build();
-        }),
-    },
-    actions: {
-        clearErrors: assign({
-            errors: () => undefined,
-        }),
-        raiseErrored: sendTo(({ context }) => context.parentRef, (_, params) => ({
-            type: "JavaScript Error",
-            errors: params.errors,
-        })),
-        raiseSuccess: sendTo(({ context }, _params) => context.parentRef, (_, params) => ({
-            type: "JavaScript Success",
-            contents: params.contents,
-            time: params.time,
-        })),
-        setBuildContexts: assign({
-            buildContexts: (_, params) => params.buildContexts,
-        }),
-        setError: assign({
-            errors: (_, params) => params.errors,
-        }),
-        setTime: assign({
-            time: (_, params) => params.time,
-        }),
-    },
-}).createMachine({
-    id: "JavaScript Machine",
-    initial: "Preparing",
-    context: ({ input }) => ({
-        ...input,
-        buildContexts: [],
-    }),
-    states: {
-        Preparing: {
-            on: {
-                "Build Contexts Prepared": {
-                    target: "Watching",
-                    actions: {
-                        type: "setBuildContexts",
-                        params: ({ event }) => event,
-                    },
-                },
-            },
-        },
-        Watching: {
-            states: {
-                Success: {},
-                Building: {
-                    on: {
-                        Result: [
-                            {
-                                target: "Errored",
-                                guard: {
-                                    type: "has errors",
-                                    params: ({ event }) => event,
-                                },
-                                actions: [
-                                    {
-                                        type: "setError",
-                                        params: ({ event }) => ({ errors: event.errors }),
-                                    },
-                                    {
-                                        type: "raiseErrored",
-                                        params: ({ event }) => ({ errors: event.errors }),
-                                    },
-                                ],
-                            },
-                            {
-                                target: "Success",
-                                actions: [
-                                    { type: "setTime", params: ({ event }) => event },
-                                    {
-                                        type: "raiseSuccess",
-                                        params: ({ event }) => ({
-                                            contents: event.contents,
-                                            time: event.time,
-                                        }),
-                                    },
-                                    "clearErrors",
-                                ],
-                            },
-                        ],
-                    },
-                    invoke: {
-                        src: "build",
-                        input: ({ context }) => context,
-                    },
-                },
-                Errored: {},
-            },
-            initial: "Building",
-            on: {
-                Change: ".Building",
-            },
-        },
-    },
-    invoke: {
-        src: "prepareBuildContext",
-        input: ({ context }) => context,
-    },
-});

package/lib/machines/ts-machine.js

@@ -1,105 +0,0 @@
-import path from "path";
-import { sendTo, assign, setup, fromCallback } from "xstate";
-import { getDiagnostics, readConfig, typeScriptErrorSchema, } from "../util/typescript.js";
-export const tsMachine = setup({
-    types: {
-        context: {},
-        events: {},
-        input: {},
-    },
-    guards: {
-        "has errors": (_, params) => Boolean(params.errors?.length),
-    },
-    actors: {
-        validate: fromCallback(({ sendBack }) => {
-            const validate = async () => {
-                try {
-                    const program = await readConfig(path.resolve("tsconfig.json"));
-                    if (program === "Not a TypeScript project") {
-                        sendBack({ type: "Result", time: new Date() });
-                        return;
-                    }
-                    const errors = await getDiagnostics(program);
-                    if (errors.length) {
-                        sendBack({ type: "Result", errors, time: new Date() });
-                    }
-                    else {
-                        sendBack({ type: "Result", time: new Date() });
-                    }
-                }
-                catch (e) {
-                    sendBack({
-                        type: "Result",
-                        errors: [
-                            typeScriptErrorSchema.parse({ text: e.message ?? "ERROR" }),
-                        ],
-                        time: new Date(),
-                    });
-                }
-            };
-            validate();
-        }),
-    },
-    actions: {
-        clearError: assign({
-            errors: () => undefined,
-        }),
-        clearTime: assign({
-            time: () => undefined,
-        }),
-        raiseErrored: sendTo(({ context }) => context.parentRef, ({ context }) => ({
-            type: "TypeScript Error",
-            errors: context.errors,
-        })),
-        raiseSuccess: sendTo(({ context }) => context.parentRef, { type: "TypeScript Success" }),
-        setErrors: assign({
-            errors: (_, params) => params.errors,
-        }),
-        setTime: assign({
-            time: (_, params) => params.time,
-        }),
-    },
-}).createMachine({
-    id: "TypeScript Machine",
-    context: ({ input }) => ({
-        parentRef: input.parentRef,
-    }),
-    states: {
-        Validating: {
-            on: {
-                Result: [
-                    {
-                        target: "Errored",
-                        actions: [
-                            {
-                                type: "setErrors",
-                                params: ({ event }) => event,
-                            },
-                            { type: "setTime", params: ({ event }) => event },
-                        ],
-                        guard: { type: "has errors", params: ({ event }) => event },
-                    },
-                    {
-                        target: "Success",
-                        reenter: true,
-                        actions: ["clearError", { type: "setTime", params: ({ event }) => event }],
-                    },
-                ],
-            },
-            invoke: {
-                src: "validate",
-            },
-            entry: "clearTime",
-        },
-        Errored: {
-            entry: "raiseErrored",
-        },
-        Success: {
-            entry: "raiseSuccess",
-        },
-    },
-    initial: "Validating",
-    on: {
-        Change: ".Validating",
-    },
-});

package/lib/util/set-terminal-title.js

@@ -1,8 +0,0 @@
-export function setTerminalTitle(title) {
-    if (process.platform === "win32") {
-        process.title = title;
-    }
-    else {
-        process.stdout.write(`\x1B]2;${title}\x1B\x5C`);
-    }
-}