npm - effect-start - Versions diffs - 0.19.0 → 0.20.1 - Mend

effect-start 0.19.0 → 0.20.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (144) hide show

package/README.md +3 -3
package/dist/Development.d.ts +3 -3
package/dist/Development.js +3 -2
package/dist/Effectify.d.ts +212 -0
package/dist/Effectify.js +19 -0
package/dist/FilePathPattern.d.ts +29 -0
package/dist/FilePathPattern.js +86 -0
package/dist/FileRouter.d.ts +39 -41
package/dist/FileRouter.js +104 -158
package/dist/FileRouterCodegen.d.ts +7 -8
package/dist/FileRouterCodegen.js +97 -66
package/dist/PlatformError.d.ts +46 -0
package/dist/PlatformError.js +43 -0
package/dist/PlatformRuntime.d.ts +23 -0
package/dist/PlatformRuntime.js +42 -0
package/dist/RouteBody.d.ts +1 -1
package/dist/Start.d.ts +34 -3
package/dist/Start.js +31 -6
package/dist/bun/BunPlatformHttpServer.d.ts +10 -0
package/dist/bun/BunPlatformHttpServer.js +53 -0
package/dist/bun/BunRoute.d.ts +3 -5
package/dist/bun/BunRoute.js +9 -17
package/dist/bun/BunRuntime.d.ts +2 -1
package/dist/bun/BunRuntime.js +10 -5
package/dist/bun/BunServer.d.ts +33 -0
package/dist/bun/BunServer.js +133 -0
package/dist/bun/BunServerRequest.d.ts +60 -0
package/dist/bun/BunServerRequest.js +252 -0
package/dist/bun/index.d.ts +1 -1
package/dist/bun/index.js +1 -1
package/dist/datastar/actions/fetch.d.ts +30 -0
package/dist/datastar/actions/fetch.js +411 -0
package/dist/datastar/actions/peek.d.ts +1 -0
package/dist/datastar/actions/peek.js +14 -0
package/dist/datastar/actions/setAll.d.ts +1 -0
package/dist/datastar/actions/setAll.js +13 -0
package/dist/datastar/actions/toggleAll.d.ts +1 -0
package/dist/datastar/actions/toggleAll.js +13 -0
package/dist/datastar/attributes/attr.d.ts +1 -0
package/dist/datastar/attributes/attr.js +49 -0
package/dist/datastar/attributes/bind.d.ts +1 -0
package/dist/datastar/attributes/bind.js +183 -0
package/dist/datastar/attributes/class.d.ts +1 -0
package/dist/datastar/attributes/class.js +50 -0
package/dist/datastar/attributes/computed.d.ts +1 -0
package/dist/datastar/attributes/computed.js +27 -0
package/dist/datastar/attributes/effect.d.ts +1 -0
package/dist/datastar/attributes/effect.js +10 -0
package/dist/datastar/attributes/indicator.d.ts +1 -0
package/dist/datastar/attributes/indicator.js +32 -0
package/dist/datastar/attributes/init.d.ts +1 -0
package/dist/datastar/attributes/init.js +27 -0
package/dist/datastar/attributes/jsonSignals.d.ts +1 -0
package/dist/datastar/attributes/jsonSignals.js +31 -0
package/dist/datastar/attributes/on.d.ts +1 -0
package/dist/datastar/attributes/on.js +59 -0
package/dist/datastar/attributes/onIntersect.d.ts +1 -0
package/dist/datastar/attributes/onIntersect.js +54 -0
package/dist/datastar/attributes/onInterval.d.ts +1 -0
package/dist/datastar/attributes/onInterval.js +31 -0
package/dist/datastar/attributes/onSignalPatch.d.ts +1 -0
package/dist/datastar/attributes/onSignalPatch.js +44 -0
package/dist/datastar/attributes/ref.d.ts +1 -0
package/dist/datastar/attributes/ref.js +11 -0
package/dist/datastar/attributes/show.d.ts +1 -0
package/dist/datastar/attributes/show.js +32 -0
package/dist/datastar/attributes/signals.d.ts +1 -0
package/dist/datastar/attributes/signals.js +18 -0
package/dist/datastar/attributes/style.d.ts +1 -0
package/dist/datastar/attributes/style.js +56 -0
package/dist/datastar/attributes/text.d.ts +1 -0
package/dist/datastar/attributes/text.js +27 -0
package/dist/datastar/engine.d.ts +156 -0
package/dist/datastar/engine.js +971 -0
package/dist/datastar/index.d.ts +24 -0
package/dist/datastar/index.js +24 -0
package/dist/datastar/load.d.ts +24 -0
package/dist/datastar/load.js +24 -0
package/dist/datastar/utils.d.ts +51 -0
package/dist/datastar/utils.js +205 -0
package/dist/datastar/watchers/patchElements.d.ts +1 -0
package/dist/datastar/watchers/patchElements.js +420 -0
package/dist/datastar/watchers/patchSignals.d.ts +1 -0
package/dist/datastar/watchers/patchSignals.js +15 -0
package/dist/index.d.ts +1 -1
package/dist/index.js +1 -1
package/dist/node/NodeFileSystem.d.ts +7 -0
package/dist/node/NodeFileSystem.js +420 -0
package/dist/node/NodeUtils.d.ts +2 -0
package/dist/node/NodeUtils.js +20 -0
package/dist/x/tailwind/plugin.js +1 -1
package/package.json +11 -7
package/src/Development.ts +26 -25
package/src/{node/Effectify.ts → Effectify.ts} +10 -3
package/src/FilePathPattern.ts +115 -0
package/src/FileRouter.ts +178 -255
package/src/FileRouterCodegen.ts +135 -92
package/src/{node/PlatformError.ts → PlatformError.ts} +34 -19
package/src/PlatformRuntime.ts +97 -0
package/src/RouteBody.ts +1 -1
package/src/RouteHttp.ts +3 -1
package/src/Start.ts +61 -14
package/src/bun/BunPlatformHttpServer.ts +88 -0
package/src/bun/BunRoute.ts +12 -22
package/src/bun/BunRuntime.ts +21 -5
package/src/bun/BunServer.ts +228 -0
package/src/bun/index.ts +1 -1
package/src/datastar/README.md +18 -0
package/src/datastar/actions/fetch.ts +609 -0
package/src/datastar/actions/peek.ts +17 -0
package/src/datastar/actions/setAll.ts +20 -0
package/src/datastar/actions/toggleAll.ts +20 -0
package/src/datastar/attributes/attr.ts +50 -0
package/src/datastar/attributes/bind.ts +220 -0
package/src/datastar/attributes/class.ts +57 -0
package/src/datastar/attributes/computed.ts +33 -0
package/src/datastar/attributes/effect.ts +11 -0
package/src/datastar/attributes/indicator.ts +39 -0
package/src/datastar/attributes/init.ts +35 -0
package/src/datastar/attributes/jsonSignals.ts +38 -0
package/src/datastar/attributes/on.ts +71 -0
package/src/datastar/attributes/onIntersect.ts +65 -0
package/src/datastar/attributes/onInterval.ts +39 -0
package/src/datastar/attributes/onSignalPatch.ts +63 -0
package/src/datastar/attributes/ref.ts +12 -0
package/src/datastar/attributes/show.ts +33 -0
package/src/datastar/attributes/signals.ts +22 -0
package/src/datastar/attributes/style.ts +63 -0
package/src/datastar/attributes/text.ts +30 -0
package/src/datastar/engine.ts +1341 -0
package/src/datastar/index.ts +25 -0
package/src/datastar/utils.ts +286 -0
package/src/datastar/watchers/patchElements.ts +554 -0
package/src/datastar/watchers/patchSignals.ts +15 -0
package/src/index.ts +1 -1
package/src/node/{FileSystem.ts → NodeFileSystem.ts} +2 -2
package/src/node/{Utils.ts → NodeUtils.ts} +2 -0
package/src/x/tailwind/plugin.ts +1 -1
package/src/FileRouterCodegen.todo.ts +0 -1133
package/src/FileRouterPattern.ts +0 -59
package/src/RouterPattern.ts +0 -416
package/src/StartApp.ts +0 -47
package/src/bun/BunHttpServer.ts +0 -303
/package/src/bun/{BunHttpServer_web.ts → BunServerRequest.ts} +0 -0

package/dist/datastar/watchers/patchElements.js ADDED Viewed

@@ -0,0 +1,420 @@
+import { watcher } from "../engine.js";
+import { aliasify, isHTMLOrSVG, supportsViewTransitions, } from "../utils.js";
+const isValidType = (arr, value) => arr.includes(value);
+const PATCH_MODES = [
+    "remove",
+    "outer",
+    "inner",
+    "replace",
+    "prepend",
+    "append",
+    "before",
+    "after",
+];
+const NAMESPACES = ["html", "svg", "mathml"];
+watcher({
+    name: "datastar-patch-elements",
+    apply(ctx, { selector = "", mode = "outer", namespace = "html", useViewTransition = "", elements = "", }) {
+        if (!isValidType(PATCH_MODES, mode)) {
+            throw ctx.error("PatchElementsInvalidMode", { mode });
+        }
+        if (!selector && mode !== "outer" && mode !== "replace") {
+            throw ctx.error("PatchElementsExpectedSelector");
+        }
+        if (!isValidType(NAMESPACES, namespace)) {
+            throw ctx.error("PatchElementsInvalidNamespace", { namespace });
+        }
+        const args2 = {
+            selector,
+            mode,
+            namespace,
+            useViewTransition: useViewTransition.trim() === "true",
+            elements,
+        };
+        if (supportsViewTransitions && useViewTransition) {
+            document.startViewTransition(() => onPatchElements(ctx, args2));
+        }
+        else {
+            onPatchElements(ctx, args2);
+        }
+    },
+});
+const onPatchElements = ({ error }, { selector, mode, namespace, elements }) => {
+    const elementsWithSvgsRemoved = elements.replace(/<svg(\s[^>]*>|>)([\s\S]*?)<\/svg>/gim, "");
+    const hasHtml = /<\/html>/.test(elementsWithSvgsRemoved);
+    const hasHead = /<\/head>/.test(elementsWithSvgsRemoved);
+    const hasBody = /<\/body>/.test(elementsWithSvgsRemoved);
+    const wrapperTag = namespace === "svg"
+        ? "svg"
+        : namespace === "mathml"
+            ? "math"
+            : "";
+    const wrappedEls = wrapperTag
+        ? `<${wrapperTag}>${elements}</${wrapperTag}>`
+        : elements;
+    const newDocument = new DOMParser().parseFromString(hasHtml || hasHead || hasBody
+        ? elements
+        : `<body><template>${wrappedEls}</template></body>`, "text/html");
+    let newContent = document.createDocumentFragment();
+    if (hasHtml) {
+        newContent.appendChild(newDocument.documentElement);
+    }
+    else if (hasHead && hasBody) {
+        newContent.appendChild(newDocument.head);
+        newContent.appendChild(newDocument.body);
+    }
+    else if (hasHead) {
+        newContent.appendChild(newDocument.head);
+    }
+    else if (hasBody) {
+        newContent.appendChild(newDocument.body);
+    }
+    else if (wrapperTag) {
+        const wrapperEl = newDocument
+            .querySelector("template")
+            .content
+            .querySelector(wrapperTag);
+        for (const child of wrapperEl.childNodes) {
+            newContent.appendChild(child);
+        }
+    }
+    else {
+        newContent = newDocument.querySelector("template").content;
+    }
+    if (!selector && (mode === "outer" || mode === "replace")) {
+        for (const child of newContent.children) {
+            let target;
+            if (child instanceof HTMLHtmlElement) {
+                target = document.documentElement;
+            }
+            else if (child instanceof HTMLBodyElement) {
+                target = document.body;
+            }
+            else if (child instanceof HTMLHeadElement) {
+                target = document.head;
+            }
+            else {
+                target = document.getElementById(child.id);
+                if (!target) {
+                    console.warn(error("PatchElementsNoTargetsFound"), {
+                        element: { id: child.id },
+                    });
+                    continue;
+                }
+            }
+            applyToTargets(mode, child, [target]);
+        }
+    }
+    else {
+        const targets = document.querySelectorAll(selector);
+        if (!targets.length) {
+            console.warn(error("PatchElementsNoTargetsFound"), { selector });
+            return;
+        }
+        applyToTargets(mode, newContent, targets);
+    }
+};
+const scripts = new WeakSet();
+for (const script of document.querySelectorAll("script")) {
+    scripts.add(script);
+}
+const execute = (target) => {
+    const elScripts = target instanceof HTMLScriptElement
+        ? [target]
+        : target.querySelectorAll("script");
+    for (const old of elScripts) {
+        if (!scripts.has(old)) {
+            const script = document.createElement("script");
+            for (const { name, value } of old.attributes) {
+                script.setAttribute(name, value);
+            }
+            script.text = old.text;
+            old.replaceWith(script);
+            scripts.add(script);
+        }
+    }
+};
+const applyPatchMode = (targets, element, action) => {
+    for (const target of targets) {
+        const cloned = element.cloneNode(true);
+        execute(cloned);
+        // @ts-ignore
+        target[action](cloned);
+    }
+};
+const applyToTargets = (mode, element, targets) => {
+    switch (mode) {
+        case "remove":
+            for (const target of targets) {
+                target.remove();
+            }
+            break;
+        case "outer":
+        case "inner":
+            for (const target of targets) {
+                morph(target, element.cloneNode(true), mode);
+                execute(target);
+            }
+            break;
+        case "replace":
+            applyPatchMode(targets, element, "replaceWith");
+            break;
+        case "prepend":
+        case "append":
+        case "before":
+        case "after":
+            applyPatchMode(targets, element, mode);
+    }
+};
+const ctxIdMap = new Map();
+const ctxPersistentIds = new Set();
+const oldIdTagNameMap = new Map();
+const duplicateIds = new Set();
+const ctxPantry = document.createElement("div");
+ctxPantry.hidden = true;
+const aliasedIgnoreMorph = aliasify("ignore-morph");
+const aliasedIgnoreMorphAttr = `[${aliasedIgnoreMorph}]`;
+const morph = (oldElt, newContent, mode = "outer") => {
+    if ((isHTMLOrSVG(oldElt)
+        && isHTMLOrSVG(newContent)
+        && oldElt.hasAttribute(aliasedIgnoreMorph)
+        && newContent.hasAttribute(aliasedIgnoreMorph))
+        || oldElt.parentElement?.closest(aliasedIgnoreMorphAttr)) {
+        return;
+    }
+    const normalizedElt = document.createElement("div");
+    normalizedElt.append(newContent);
+    document.body.insertAdjacentElement("afterend", ctxPantry);
+    const oldIdElements = oldElt.querySelectorAll("[id]");
+    for (const { id, tagName } of oldIdElements) {
+        if (oldIdTagNameMap.has(id)) {
+            duplicateIds.add(id);
+        }
+        else {
+            oldIdTagNameMap.set(id, tagName);
+        }
+    }
+    if (oldElt instanceof Element && oldElt.id) {
+        if (oldIdTagNameMap.has(oldElt.id)) {
+            duplicateIds.add(oldElt.id);
+        }
+        else {
+            oldIdTagNameMap.set(oldElt.id, oldElt.tagName);
+        }
+    }
+    ctxPersistentIds.clear();
+    const newIdElements = normalizedElt.querySelectorAll("[id]");
+    for (const { id, tagName } of newIdElements) {
+        if (ctxPersistentIds.has(id)) {
+            duplicateIds.add(id);
+        }
+        else if (oldIdTagNameMap.get(id) === tagName) {
+            ctxPersistentIds.add(id);
+        }
+    }
+    for (const id of duplicateIds) {
+        ctxPersistentIds.delete(id);
+    }
+    oldIdTagNameMap.clear();
+    duplicateIds.clear();
+    ctxIdMap.clear();
+    const parent = mode === "outer" ? oldElt.parentElement : oldElt;
+    populateIdMapWithTree(parent, oldIdElements);
+    populateIdMapWithTree(normalizedElt, newIdElements);
+    morphChildren(parent, normalizedElt, mode === "outer" ? oldElt : null, oldElt.nextSibling);
+    ctxPantry.remove();
+};
+const morphChildren = (oldParent, newParent, insertionPoint = null, endPoint = null) => {
+    if (oldParent instanceof HTMLTemplateElement
+        && newParent instanceof HTMLTemplateElement) {
+        oldParent = oldParent.content;
+        newParent = newParent.content;
+    }
+    insertionPoint ??= oldParent.firstChild;
+    for (const newChild of newParent.childNodes) {
+        if (insertionPoint && insertionPoint !== endPoint) {
+            const bestMatch = findBestMatch(newChild, insertionPoint, endPoint);
+            if (bestMatch) {
+                if (bestMatch !== insertionPoint) {
+                    let cursor = insertionPoint;
+                    while (cursor && cursor !== bestMatch) {
+                        const tempNode = cursor;
+                        cursor = cursor.nextSibling;
+                        removeNode(tempNode);
+                    }
+                }
+                morphNode(bestMatch, newChild);
+                insertionPoint = bestMatch.nextSibling;
+                continue;
+            }
+        }
+        if (newChild instanceof Element && ctxPersistentIds.has(newChild.id)) {
+            const movedChild = document.getElementById(newChild.id);
+            let current = movedChild;
+            while ((current = current.parentNode)) {
+                const idSet = ctxIdMap.get(current);
+                if (idSet) {
+                    idSet.delete(newChild.id);
+                    if (!idSet.size) {
+                        ctxIdMap.delete(current);
+                    }
+                }
+            }
+            moveBefore(oldParent, movedChild, insertionPoint);
+            morphNode(movedChild, newChild);
+            insertionPoint = movedChild.nextSibling;
+            continue;
+        }
+        if (ctxIdMap.has(newChild)) {
+            const namespaceURI = newChild.namespaceURI;
+            const tagName = newChild.tagName;
+            const newEmptyChild = namespaceURI && namespaceURI !== "http://www.w3.org/1999/xhtml"
+                ? document.createElementNS(namespaceURI, tagName)
+                : document.createElement(tagName);
+            oldParent.insertBefore(newEmptyChild, insertionPoint);
+            morphNode(newEmptyChild, newChild);
+            insertionPoint = newEmptyChild.nextSibling;
+        }
+        else {
+            const newClonedChild = document.importNode(newChild, true);
+            oldParent.insertBefore(newClonedChild, insertionPoint);
+            insertionPoint = newClonedChild.nextSibling;
+        }
+    }
+    while (insertionPoint && insertionPoint !== endPoint) {
+        const tempNode = insertionPoint;
+        insertionPoint = insertionPoint.nextSibling;
+        removeNode(tempNode);
+    }
+};
+const findBestMatch = (node, startPoint, endPoint) => {
+    let bestMatch = null;
+    let nextSibling = node.nextSibling;
+    let siblingSoftMatchCount = 0;
+    let displaceMatchCount = 0;
+    const nodeMatchCount = ctxIdMap.get(node)?.size || 0;
+    let cursor = startPoint;
+    while (cursor && cursor !== endPoint) {
+        if (isSoftMatch(cursor, node)) {
+            let isIdSetMatch = false;
+            const oldSet = ctxIdMap.get(cursor);
+            const newSet = ctxIdMap.get(node);
+            if (newSet && oldSet) {
+                for (const id of oldSet) {
+                    if (newSet.has(id)) {
+                        isIdSetMatch = true;
+                        break;
+                    }
+                }
+            }
+            if (isIdSetMatch) {
+                return cursor;
+            }
+            if (!bestMatch && !ctxIdMap.has(cursor)) {
+                if (!nodeMatchCount) {
+                    return cursor;
+                }
+                bestMatch = cursor;
+            }
+        }
+        displaceMatchCount += ctxIdMap.get(cursor)?.size || 0;
+        if (displaceMatchCount > nodeMatchCount) {
+            break;
+        }
+        if (bestMatch === null && nextSibling && isSoftMatch(cursor, nextSibling)) {
+            siblingSoftMatchCount++;
+            nextSibling = nextSibling.nextSibling;
+            if (siblingSoftMatchCount >= 2) {
+                bestMatch = undefined;
+            }
+        }
+        cursor = cursor.nextSibling;
+    }
+    return bestMatch || null;
+};
+const isSoftMatch = (oldNode, newNode) => oldNode.nodeType === newNode.nodeType
+    && oldNode.tagName === newNode.tagName
+    && (!oldNode.id
+        || oldNode.id === newNode.id);
+const removeNode = (node) => {
+    ctxIdMap.has(node)
+        ? moveBefore(ctxPantry, node, null)
+        : node.parentNode?.removeChild(node);
+};
+const moveBefore =
+// @ts-expect-error
+removeNode.call.bind(ctxPantry.moveBefore ?? ctxPantry.insertBefore);
+const aliasedPreserveAttr = aliasify("preserve-attr");
+const morphNode = (oldNode, newNode) => {
+    const type = newNode.nodeType;
+    if (type === 1) {
+        const oldElt = oldNode;
+        const newElt = newNode;
+        const shouldScopeChildren = oldElt.hasAttribute("data-scope-children");
+        if (oldElt.hasAttribute(aliasedIgnoreMorph)
+            && newElt.hasAttribute(aliasedIgnoreMorph)) {
+            return oldNode;
+        }
+        if (oldElt instanceof HTMLInputElement
+            && newElt instanceof HTMLInputElement
+            && newElt.type !== "file") {
+            if (newElt.getAttribute("value") !== oldElt.getAttribute("value")) {
+                oldElt.value = newElt.getAttribute("value") ?? "";
+            }
+        }
+        else if (oldElt instanceof HTMLTextAreaElement
+            && newElt instanceof HTMLTextAreaElement) {
+            if (newElt.value !== oldElt.value) {
+                oldElt.value = newElt.value;
+            }
+            if (oldElt.firstChild && oldElt.firstChild.nodeValue !== newElt.value) {
+                oldElt.firstChild.nodeValue = newElt.value;
+            }
+        }
+        const preserveAttrs = (newNode.getAttribute(aliasedPreserveAttr) ?? "")
+            .split(" ");
+        for (const { name, value } of newElt.attributes) {
+            if (oldElt.getAttribute(name) !== value
+                && !preserveAttrs.includes(name)) {
+                oldElt.setAttribute(name, value);
+            }
+        }
+        for (let i = oldElt.attributes.length - 1; i >= 0; i--) {
+            const { name } = oldElt.attributes[i];
+            if (!newElt.hasAttribute(name) && !preserveAttrs.includes(name)) {
+                oldElt.removeAttribute(name);
+            }
+        }
+        if (shouldScopeChildren && !oldElt.hasAttribute("data-scope-children")) {
+            oldElt.setAttribute("data-scope-children", "");
+        }
+        if (!oldElt.isEqualNode(newElt)) {
+            morphChildren(oldElt, newElt);
+        }
+        if (shouldScopeChildren) {
+            oldElt.dispatchEvent(new CustomEvent("datastar:scope-children", { bubbles: false }));
+        }
+    }
+    if (type === 8 || type === 3) {
+        if (oldNode.nodeValue !== newNode.nodeValue) {
+            oldNode.nodeValue = newNode.nodeValue;
+        }
+    }
+    return oldNode;
+};
+const populateIdMapWithTree = (root, elements) => {
+    for (const elt of elements) {
+        if (ctxPersistentIds.has(elt.id)) {
+            let current = elt;
+            while (current && current !== root) {
+                let idSet = ctxIdMap.get(current);
+                if (!idSet) {
+                    idSet = new Set();
+                    ctxIdMap.set(current, idSet);
+                }
+                idSet.add(elt.id);
+                current = current.parentElement;
+            }
+        }
+    }
+};

package/dist/datastar/watchers/patchSignals.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export {};

package/dist/datastar/watchers/patchSignals.js ADDED Viewed

@@ -0,0 +1,15 @@
+import { watcher } from "../engine.js";
+import { mergePatch } from "../engine.js";
+import { jsStrToObject } from "../utils.js";
+watcher({
+    name: "datastar-patch-signals",
+    apply({ error }, { signals, onlyIfMissing }) {
+        if (signals) {
+            const ifMissing = onlyIfMissing?.trim() === "true";
+            mergePatch(jsStrToObject(signals), { ifMissing });
+        }
+        else {
+            throw error("PatchSignalsExpectedSignals");
+        }
+    },
+});

package/dist/index.d.ts CHANGED Viewed

@@ -2,6 +2,6 @@ export * as Bundle from "./bundler/Bundle.ts";
 export * as Development from "./Development.ts";
 export * as Entity from "./Entity.ts";
 export * as FileRouter from "./FileRouter.ts";
-export * as Unique from "./Unique.ts";
 export * as Route from "./Route.ts";
 export * as Start from "./Start.ts";
+export * as Unique from "./Unique.ts";

package/dist/index.js CHANGED Viewed

@@ -2,6 +2,6 @@ export * as Bundle from "./bundler/Bundle.js";
 export * as Development from "./Development.js";
 export * as Entity from "./Entity.js";
 export * as FileRouter from "./FileRouter.js";
-export * as Unique from "./Unique.js";
 export * as Route from "./Route.js";
 export * as Start from "./Start.js";
+export * as Unique from "./Unique.js";

package/dist/node/NodeFileSystem.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+import * as FileSystem from "@effect/platform/FileSystem";
+import * as Layer from "effect/Layer";
+import * as NFS from "node:fs";
+import * as PlatformError from "../PlatformError.ts";
+export declare const layer: Layer.Layer<FileSystem.FileSystem, never, never>;
+export { FileSystem, PlatformError as Error, };
+export declare function handleErrnoException(module: PlatformError.SystemError["module"], method: string): (err: NodeJS.ErrnoException, [path]: [path: NFS.PathLike | number, ...args: Array<any>]) => PlatformError.PlatformError;