salman/igny8
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add yet-another-react-lightbox package and update .gitignore to exclude node_modules

Browse Source
This commit is contained in:
IGNY8 VPS (Salman)
2025-11-12 18:50:30 +00:00
parent bd2a5570a9
commit c92f4a5edd
9304 changed files with 29 additions and 2008667 deletions
Download Patch File Download Diff File Expand all files Collapse all files

207
frontend/node_modules/turbo-stream/dist/turbo-stream.js generated vendored
View File

@@ -1,207 +0,0 @@
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.encode = exports.decode = void 0;
const flatten_js_1 = require("./flatten.js");
const unflatten_js_1 = require("./unflatten.js");
const utils_js_1 = require("./utils.js");
async function decode(readable, options) {
const { plugins } = options ?? {};
const done = new utils_js_1.Deferred();
const reader = readable
.pipeThrough((0, utils_js_1.createLineSplittingTransform)())
.getReader();
const decoder = {
values: [],
hydrated: [],
deferred: {},
plugins,
};
const decoded = await decodeInitial.call(decoder, reader);
let donePromise = done.promise;
if (decoded.done) {
done.resolve();
}
else {
donePromise = decodeDeferred
.call(decoder, reader)
.then(done.resolve)
.catch((reason) => {
for (const deferred of Object.values(decoder.deferred)) {
deferred.reject(reason);
}
done.reject(reason);
});
}
return {
done: donePromise.then(() => reader.closed),
value: decoded.value,
};
}
exports.decode = decode;
async function decodeInitial(reader) {
const read = await reader.read();
if (!read.value) {
throw new SyntaxError();
}
let line;
try {
line = JSON.parse(read.value);
}
catch (reason) {
throw new SyntaxError();
}
return {
done: read.done,
value: unflatten_js_1.unflatten.call(this, line),
};
}
async function decodeDeferred(reader) {
let read = await reader.read();
while (!read.done) {
if (!read.value)
continue;
const line = read.value;
switch (line[0]) {
case utils_js_1.TYPE_PROMISE: {
const colonIndex = line.indexOf(":");
const deferredId = Number(line.slice(1, colonIndex));
const deferred = this.deferred[deferredId];
if (!deferred) {
throw new Error(`Deferred ID ${deferredId} not found in stream`);
}
const lineData = line.slice(colonIndex + 1);
let jsonLine;
try {
jsonLine = JSON.parse(lineData);
}
catch (reason) {
throw new SyntaxError();
}
const value = unflatten_js_1.unflatten.call(this, jsonLine);
deferred.resolve(value);
break;
}
case utils_js_1.TYPE_ERROR: {
const colonIndex = line.indexOf(":");
const deferredId = Number(line.slice(1, colonIndex));
const deferred = this.deferred[deferredId];
if (!deferred) {
throw new Error(`Deferred ID ${deferredId} not found in stream`);
}
const lineData = line.slice(colonIndex + 1);
let jsonLine;
try {
jsonLine = JSON.parse(lineData);
}
catch (reason) {
throw new SyntaxError();
}
const value = unflatten_js_1.unflatten.call(this, jsonLine);
deferred.reject(value);
break;
}
default:
throw new SyntaxError();
}
read = await reader.read();
}
}
function encode(input, options) {
const { plugins, postPlugins, signal } = options ?? {};
const encoder = {
deferred: {},
index: 0,
indices: new Map(),
stringified: [],
plugins,
postPlugins,
signal,
};
const textEncoder = new TextEncoder();
let lastSentIndex = 0;
const readable = new ReadableStream({
async start(controller) {
const id = flatten_js_1.flatten.call(encoder, input);
if (Array.isArray(id)) {
throw new Error("This should never happen");
}
if (id < 0) {
controller.enqueue(textEncoder.encode(`${id}\n`));
}
else {
controller.enqueue(textEncoder.encode(`[${encoder.stringified.join(",")}]\n`));
lastSentIndex = encoder.stringified.length - 1;
}
const seenPromises = new WeakSet();
while (Object.keys(encoder.deferred).length > 0) {
for (const [deferredId, deferred] of Object.entries(encoder.deferred)) {
if (seenPromises.has(deferred))
continue;
seenPromises.add((encoder.deferred[Number(deferredId)] = raceSignal(deferred, encoder.signal)
.then((resolved) => {
const id = flatten_js_1.flatten.call(encoder, resolved);
if (Array.isArray(id)) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
encoder.index++;
lastSentIndex++;
}
else if (id < 0) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:${id}\n`));
}
else {
const values = encoder.stringified
.slice(lastSentIndex + 1)
.join(",");
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_PROMISE}${deferredId}:[${values}]\n`));
lastSentIndex = encoder.stringified.length - 1;
}
}, (reason) => {
if (!reason ||
typeof reason !== "object" ||
!(reason instanceof Error)) {
reason = new Error("An unknown error occurred");
}
const id = flatten_js_1.flatten.call(encoder, reason);
if (Array.isArray(id)) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:[["${utils_js_1.TYPE_PREVIOUS_RESOLVED}",${id[0]}]]\n`));
encoder.index++;
lastSentIndex++;
}
else if (id < 0) {
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:${id}\n`));
}
else {
const values = encoder.stringified
.slice(lastSentIndex + 1)
.join(",");
controller.enqueue(textEncoder.encode(`${utils_js_1.TYPE_ERROR}${deferredId}:[${values}]\n`));
lastSentIndex = encoder.stringified.length - 1;
}
})
.finally(() => {
delete encoder.deferred[Number(deferredId)];
})));
}
await Promise.race(Object.values(encoder.deferred));
}
await Promise.all(Object.values(encoder.deferred));
controller.close();
},
});
return readable;
}
exports.encode = encode;
function raceSignal(promise, signal) {
if (!signal)
return promise;
if (signal.aborted)
return Promise.reject(signal.reason || new Error("Signal was aborted."));
const abort = new Promise((resolve, reject) => {
signal.addEventListener("abort", (event) => {
reject(signal.reason || new Error("Signal was aborted."));
});
promise.then(resolve).catch(reject);
});
abort.catch(() => { });
return Promise.race([abort, promise]);
}