fullstacked 0.12.0-1175 → 0.12.0-1184

package/fullstacked_modules/git/git.ts

@@ -0,0 +1,238 @@
+import { bridge } from "../bridge";
+import { serializeArgs } from "../bridge/serialization";
+import core_message from "../core_message";
+import { Project } from "../../editor/types";
+
+const pullPromises = new Map<string, ((pullResponse: PullResponse) => void)[]>();
+let addedListener = false;
+function setListenerOnce() {
+    if (addedListener) return;
+
+    core_message.addListener("git-pull", (message) => {
+        console.log(message);
+        const { url, data, finished } = JSON.parse(message);
+        if (!finished) return;
+        const promises = pullPromises.get(url);
+        promises?.forEach((resolve) => resolve(data));
+        pullPromises.delete(url);
+    });
+
+    core_message.addListener("git-push", console.log);
+
+    addedListener = true;
+}
+
+// 81
+export function gitAuthResponse(id: number, success: boolean) {
+    console.log(id, success);
+    const payload = new Uint8Array([81, ...serializeArgs([id, success])]);
+    bridge(payload);
+}
+
+// 70
+export function clone(url: string, into: string) {
+    const payload = new Uint8Array([70, ...serializeArgs([into, url])]);
+    return bridge(payload);
+}
+
+// 71
+export function head(projectId: string): Promise<{ name: string; hash: string }> {
+    const payload = new Uint8Array([71,
+        ...serializeArgs([projectId])
+    ]);
+
+    const transformer = ([name, hash]) => {
+        return { name, hash };
+    };
+
+    return bridge(payload, transformer);
+}
+
+export type Status = {
+    added: string[];
+    deleted: string[];
+    modified: string[];
+};
+
+// 72
+export function status(projectId: string): Promise<Status> {
+    const payload = new Uint8Array([72, ...serializeArgs([projectId])]);
+
+    // added: 0, deleted: 1, modified: 2
+    const transformer = (s: (string | number)[]) => {
+        const status: Status = {
+            added: [],
+            deleted: [],
+            modified: []
+        };
+
+        for (let i = 0; i < s.length; i = i + 2) {
+            const file = s[i] as string;
+            const type = s[i + 1] as number;
+
+            switch (type) {
+                case 0:
+                    status.added.push(file);
+                    break;
+                case 1:
+                    status.deleted.push(file);
+                    break;
+                case 2:
+                    status.modified.push(file);
+                    break;
+            }
+        }
+
+        return status;
+    };
+
+    return bridge(payload, transformer);
+}
+
+// 73
+export enum PullResponse {
+    DID_PULL = "",
+    UP_TO_DATE = "already up-to-date",
+    REF_NOT_FOUND = "reference not found",
+    UNAUTHORIZED = "authentication required",
+    UNREACHABLE = "unreacheable"
+}
+export async function pull(project?: Project): Promise<PullResponse> {
+    setListenerOnce();
+
+    const args = project
+        ? serializeArgs([project.id])
+        : [];
+
+    const payload = new Uint8Array([73, ...args]);
+
+    const url = await remoteUrl(project);
+    let p = pullPromises.get(url);
+    if (!p) {
+        p = [];
+        pullPromises.set(url, p);
+    }
+
+    return new Promise((resolve) => {
+        p.push(resolve);
+        bridge(payload);
+    });
+}
+
+// 74
+export function restore(projectId: string, files: string[]): Promise<void> {
+    const payload = new Uint8Array([
+        74,
+        ...serializeArgs([projectId, ...files])
+    ]);
+
+    return bridge(payload);
+}
+
+// 75
+export function checkout(
+    project: Project,
+    branch: string,
+    create: boolean = false
+) {
+    const payload = new Uint8Array([
+        75,
+        ...serializeArgs([project.id, branch, create])
+    ]);
+
+    return bridge(payload);
+}
+
+// 76
+export function fetch(project: Project): Promise<void> {
+    const payload = new Uint8Array([76, ...serializeArgs([project.id])]);
+    return bridge(payload);
+}
+
+// 77
+export function commit(project: Project, commitMessage: string): Promise<void> {
+    const payload = new Uint8Array([
+        77,
+        ...serializeArgs([
+            project.id,
+            commitMessage,
+            project.gitRepository.name || "",
+            project.gitRepository.email || ""
+        ])
+    ]);
+
+    return bridge(payload);
+}
+
+type Branch = {
+    name: string;
+    remote: boolean;
+    local: boolean;
+};
+
+// 78
+export async function branches(project: Project): Promise<Branch[]> {
+    const payload = new Uint8Array([78, ...serializeArgs([project.id])]);
+
+    // [name, isLocal, isRemote, name, isLocal, isRemote, ...]
+    const transformer = (branchesArgs: (string | boolean)[]) => {
+        const branches: Branch[] = [];
+
+        for (let i = 0; i < branchesArgs.length; i = i + 3) {
+            branches.push({
+                name: branchesArgs[i] as string,
+                remote: branchesArgs[i + 1] as boolean,
+                local: branchesArgs[i + 2] as boolean
+            });
+        }
+
+        return branches;
+    };
+
+    return bridge(payload, transformer);
+}
+
+// 79
+export function push(project: Project) {
+    const payload = new Uint8Array([79, ...serializeArgs([project.id])]);
+    return bridge(payload);
+}
+
+// 80
+export function branchDelete(project: Project, branch: string) {
+    const payload = new Uint8Array([
+        80,
+        ...serializeArgs([project.id, branch])
+    ]);
+
+    return bridge(payload);
+}
+
+
+// 82
+export function hasGit(project?: Project) {
+    const args = project
+        ? [project.id]
+        : [];
+
+    const payload = new Uint8Array([
+        82,
+        ...serializeArgs(args)
+    ]);
+
+    return bridge(payload, ([hasGit]) => hasGit);
+}
+
+// 83
+export function remoteUrl(project?: Project) {
+    const args = project
+        ? [project.id]
+        : [];
+
+    const payload = new Uint8Array([
+        83,
+        ...serializeArgs(args)
+    ]);
+
+    return bridge(payload, ([url]) => url);
+}

package/fullstacked_modules/git/index.ts

@@ -0,0 +1,3 @@
+import * as git from "./git";
+export default git;
+export * from "./git";

package/fullstacked_modules/packages/index.ts

@@ -0,0 +1,3 @@
+import * as packages from "./packages";
+export default packages;
+export * from "./packages";

package/fullstacked_modules/packages/packages.ts

@@ -0,0 +1,143 @@
+import { Project } from "../../editor/types";
+import { bridge } from "../bridge";
+import { getLowestKeyIdAvailable, serializeArgs } from "../bridge/serialization";
+import core_message from "../core_message";
+
+
+const activeInstallations = new Map<
+    number,
+    {
+        project: Project;
+        installing: Map<string, PackageInfoProgress>;
+        progress?: InstallationProgressCb;
+        resolve: (result: InstallationResult) => void;
+    }
+>();
+
+type InstallationResult = {
+    duration: number;
+    packagesInstalledCount: number;
+};
+
+export type PackageInfoProgress = {
+    stage: string;
+    loaded: number;
+    total: number;
+};
+
+export type PackageInfo = {
+    name: string;
+    version: string;
+    direct: boolean;
+    dependencies: PackageInfo[];
+    progress: PackageInfoProgress;
+};
+
+type InstallationProgressCb = (
+    packages: [string, PackageInfoProgress][]
+) => void;
+
+
+function installationsListener(messageStr: string) {
+    const message = JSON.parse(messageStr) as { id: number };
+
+    const activeInstallation = activeInstallations.get(message.id);
+
+    if (!activeInstallation) {
+        console.log(
+            "received packages installation notification for unknown active installation"
+        );
+        return;
+    }
+
+    if (typeof message["duration"] === "undefined") {
+        const { name, version, progress } = message as {
+            id: number;
+        } & PackageInfo;
+
+        const packageName = name + "@" + version;
+
+        if (progress.stage === "done") {
+            activeInstallation.installing.delete(packageName);
+        } else {
+            activeInstallation.installing.set(packageName, progress);
+        }
+
+        const arr = Array.from(activeInstallation.installing).sort((a, b) =>
+            a[0] < b[0] ? -1 : 1
+        );
+
+        activeInstallation.progress?.(arr);
+        return;
+    }
+
+    const installation = message as {
+        id: number;
+    } & InstallationResult;
+
+    activeInstallation.resolve(installation);
+    activeInstallations.delete(message.id);
+}
+
+let addedListener = false;
+function setListenerOnce() {
+    if (addedListener) return;
+
+    core_message.addListener(
+        "packages-installation",
+        installationsListener
+    );
+
+    addedListener = true;
+}
+
+// 60
+export function install(
+    project: Project,
+    packagesNames: string[],
+    progress?: InstallationProgressCb,
+    dev = false
+) {
+    setListenerOnce();
+
+    const installationId = getLowestKeyIdAvailable(activeInstallations);
+
+    let args: any[] = [project.id, installationId, dev, ...packagesNames];
+
+    const payload = new Uint8Array([60, ...serializeArgs(args)]);
+
+    return new Promise<InstallationResult>((resolve) => {
+        activeInstallations.set(installationId, {
+            project,
+            progress,
+            resolve,
+            installing: new Map()
+        });
+
+        bridge(payload);
+    });
+}
+
+//61
+export function installQuick(project?: Project, progress?: InstallationProgressCb) {
+    setListenerOnce();
+
+    const installationId = getLowestKeyIdAvailable(activeInstallations);
+
+    let args: any[] = project
+        ? [project.id, installationId]
+        : [installationId];
+
+    const payload = new Uint8Array([61, ...serializeArgs(args)]);
+
+    return new Promise<InstallationResult>((resolve) => {
+        activeInstallations.set(installationId, {
+            project,
+            progress,
+            resolve,
+            installing: new Map()
+        });
+
+        bridge(payload);
+    });
+}

package/fullstacked_modules/platform/index.d.ts

@@ -0,0 +1,2 @@
+import ".";
+declare module "platform" {}

package/fullstacked_modules/zod/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Colin McDonnell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/fullstacked_modules/zod/README.md

@@ -0,0 +1,208 @@
+<p align="center">
+  <img src="logo.svg" width="200px" align="center" alt="Zod logo" />
+  <h1 align="center">Zod</h1>
+  <p align="center">
+    TypeScript-first schema validation with static type inference
+    <br/>
+    by <a href="https://x.com/colinhacks">@colinhacks</a>
+  </p>
+</p>
+<br/>
+
+<p align="center">
+<a href="https://github.com/colinhacks/zod/actions?query=branch%3Amain"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=main" alt="Zod CI status" /></a>
+<a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
+<a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
+<a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
+<a href="https://github.com/colinhacks/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
+</p>
+
+<div align="center">
+  <a href="https://zod.dev/api">Docs</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://discord.gg/RcG33DQJdf">Discord</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://twitter.com/colinhacks">𝕏</a>
+  <span>&nbsp;&nbsp;•&nbsp;&nbsp;</span>
+  <a href="https://bsky.app/profile/zod.dev">Bluesky</a>
+  <br />
+</div>
+
+<br/>
+<br/>
+
+<h2 align="center">Featured sponsor: Jazz</h2>
+
+<div align="center">
+  <a href="https://jazz.tools/?utm_source=zod">
+    <picture width="85%" >
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png">
+      <img alt="jazz logo" src="https://raw.githubusercontent.com/garden-co/jazz/938f6767e46cdfded60e50d99bf3b533f4809c68/homepage/homepage/public/Zod%20sponsor%20message.png" width="85%">
+    </picture>
+  </a>
+  <br/>
+  <p><sub>Learn more about <a target="_blank" rel="noopener noreferrer" href="mailto:sponsorship@colinhacks.com">featured sponsorships</a></sub></p>
+</div>
+
+<br/>
+<br/>
+<br/>
+
+### [Read the docs →](https://zod.dev/api)
+
+<br/>
+<br/>
+
+## What is Zod?
+
+Zod is a TypeScript-first validation library. Define a schema and parse some data with it. You'll get back a strongly typed, validated result.
+
+```ts
+import * as z from "zod";
+
+const User = z.object({
+  name: z.string(),
+});
+
+// some untrusted data...
+const input = {
+  /* stuff */
+};
+
+// the parsed result is validated and type safe!
+const data = User.parse(input);
+
+// so you can use it with confidence :)
+console.log(data.name);
+```
+
+<br/>
+
+## Features
+
+- Zero external dependencies
+- Works in Node.js and all modern browsers
+- Tiny: `2kb` core bundle (gzipped)
+- Immutable API: methods return a new instance
+- Concise interface
+- Works with TypeScript and plain JS
+- Built-in JSON Schema conversion
+- Extensive ecosystem
+
+<br/>
+
+## Installation
+
+```sh
+npm install zod
+```
+
+<br/>
+
+## Basic usage
+
+Before you can do anything else, you need to define a schema. For the purposes of this guide, we'll use a simple object schema.
+
+```ts
+import * as z from "zod";
+
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+```
+
+### Parsing data
+
+Given any Zod schema, use `.parse` to validate an input. If it's valid, Zod returns a strongly-typed _deep clone_ of the input.
+
+```ts
+Player.parse({ username: "billie", xp: 100 });
+// => returns { username: "billie", xp: 100 }
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.parseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.parseAsync("hello");
+// => "hello"
+```
+
+### Handling errors
+
+When validation fails, the `.parse()` method will throw a `ZodError` instance with granular information about the validation issues.
+
+```ts
+try {
+  Player.parse({ username: 42, xp: "100" });
+} catch (err) {
+  if (err instanceof z.ZodError) {
+    err.issues;
+    /* [
+      {
+        expected: 'string',
+        code: 'invalid_type',
+        path: [ 'username' ],
+        message: 'Invalid input: expected string'
+      },
+      {
+        expected: 'number',
+        code: 'invalid_type',
+        path: [ 'xp' ],
+        message: 'Invalid input: expected number'
+      }
+    ] */
+  }
+}
+```
+
+To avoid a `try/catch` block, you can use the `.safeParse()` method to get back a plain result object containing either the successfully parsed data or a `ZodError`. The result type is a [discriminated union](https://www.typescriptlang.org/docs/handbook/2/narrowing.html#discriminated-unions), so you can handle both cases conveniently.
+
+```ts
+const result = Player.safeParse({ username: 42, xp: "100" });
+if (!result.success) {
+  result.error; // ZodError instance
+} else {
+  result.data; // { username: string; xp: number }
+}
+```
+
+**Note** — If your schema uses certain asynchronous APIs like `async` [refinements](#refine) or [transforms](#transform), you'll need to use the `.safeParseAsync()` method instead.
+
+```ts
+const schema = z.string().refine(async (val) => val.length <= 8);
+
+await schema.safeParseAsync("hello");
+// => { success: true; data: "hello" }
+```
+
+### Inferring types
+
+Zod infers a static type from your schema definitions. You can extract this type with the `z.infer<>` utility and use it however you like.
+
+```ts
+const Player = z.object({
+  username: z.string(),
+  xp: z.number(),
+});
+
+// extract the inferred type
+type Player = z.infer<typeof Player>;
+
+// use it in your code
+const player: Player = { username: "billie", xp: 100 };
+```
+
+In some cases, the input & output types of a schema can diverge. For instance, the `.transform()` API can convert the input from one type to another. In these cases, you can extract the input and output types independently:
+
+```ts
+const mySchema = z.string().transform((val) => val.length);
+
+type MySchemaIn = z.input<typeof mySchema>;
+// => string
+
+type MySchemaOut = z.output<typeof mySchema>; // equivalent to z.infer<typeof mySchema>
+// number
+```

package/fullstacked_modules/zod/index.d.cts

@@ -0,0 +1,4 @@
+import * as z from "./v4/classic/external.cjs";
+export * from "./v4/classic/external.cjs";
+export { z };
+export default z;

package/fullstacked_modules/zod/index.d.ts

@@ -0,0 +1,4 @@
+import * as z from "./v4/classic/external.js";
+export * from "./v4/classic/external.js";
+export { z };
+export default z;

package/fullstacked_modules/zod/locales/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/locales/index.cjs";

package/fullstacked_modules/zod/locales/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/locales/index.js";

package/fullstacked_modules/zod/mini/index.d.cts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.cjs";

package/fullstacked_modules/zod/mini/index.d.ts

@@ -0,0 +1 @@
+export * from "../v4/mini/index.js";