@aussieljk/forkbook 0.0.1-4 → 0.0.1-6

package/dist/_node-chunks/chunk-XOGU5PWI.js

@@ -0,0 +1,347 @@
+import CJS_COMPAT_NODE_URL_7qov04rgzsv from 'node:url';
+import CJS_COMPAT_NODE_PATH_7qov04rgzsv from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7qov04rgzsv from "node:module";
+
+var __filename = CJS_COMPAT_NODE_URL_7qov04rgzsv.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7qov04rgzsv.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7qov04rgzsv.createRequire(import.meta.url);
+
+// ------------------------------------------------------------
+// end of CJS compatibility banner, injected by Forkbook's esbuild configuration
+// ------------------------------------------------------------
+import {
+  createServiceRuntime,
+  getRegisteredServices,
+  getService,
+  registerService,
+  resolveStaticPath,
+  serviceRegistryApi,
+  validateSchema
+} from "./chunk-5T635FTI.js";
+import {
+  argumentsTag,
+  arrayBufferTag,
+  arrayTag,
+  booleanTag,
+  dataViewTag,
+  dateTag,
+  float32ArrayTag,
+  float64ArrayTag,
+  getSymbols,
+  getTag,
+  int16ArrayTag,
+  int32ArrayTag,
+  int8ArrayTag,
+  isBuffer,
+  isPlainObject,
+  isPrimitive,
+  isTypedArray,
+  mapTag,
+  numberTag,
+  objectTag,
+  regexpTag,
+  setTag,
+  stringTag,
+  symbolTag,
+  uint16ArrayTag,
+  uint32ArrayTag,
+  uint8ArrayTag,
+  uint8ClampedArrayTag
+} from "./chunk-X3RTVNRN.js";
+import {
+  any,
+  up,
+  up2
+} from "./chunk-BLUMKQQB.js";
+import {
+  globSync
+} from "./chunk-YCXTTQ7K.js";
+
+// src/shared/open-service/server.ts
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "pathe";
+
+// ../../node_modules/es-toolkit/dist/object/clone.mjs
+function clone(obj) {
+  if (isPrimitive(obj)) return obj;
+  if (Array.isArray(obj) || isTypedArray(obj) || obj instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && obj instanceof SharedArrayBuffer) return obj.slice(0);
+  let prototype = Object.getPrototypeOf(obj);
+  if (prototype == null) return Object.assign(Object.create(prototype), obj);
+  let Constructor = prototype.constructor;
+  if (obj instanceof Date || obj instanceof Map || obj instanceof Set) return new Constructor(obj);
+  if (obj instanceof RegExp) {
+    let newRegExp = new Constructor(obj);
+    return newRegExp.lastIndex = obj.lastIndex, newRegExp;
+  }
+  if (obj instanceof DataView) return new Constructor(obj.buffer.slice(0));
+  if (obj instanceof Error) {
+    let newError;
+    return obj instanceof AggregateError ? newError = new Constructor(obj.errors, obj.message, { cause: obj.cause }) : newError = new Constructor(obj.message, { cause: obj.cause }), newError.stack = obj.stack, Object.assign(newError, obj), newError;
+  }
+  return typeof File < "u" && obj instanceof File ? new Constructor([obj], obj.name, {
+    type: obj.type,
+    lastModified: obj.lastModified
+  }) : typeof obj == "object" ? Object.assign(Object.create(prototype), obj) : obj;
+}
+
+// ../../node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
+  let cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+  if (cloned !== void 0) return cloned;
+  if (isPrimitive(valueToClone)) return valueToClone;
+  if (stack.has(valueToClone)) return stack.get(valueToClone);
+  if (Array.isArray(valueToClone)) {
+    let result = new Array(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    return Object.hasOwn(valueToClone, "index") && (result.index = valueToClone.index), Object.hasOwn(valueToClone, "input") && (result.input = valueToClone.input), result;
+  }
+  if (valueToClone instanceof Date) return new Date(valueToClone.getTime());
+  if (valueToClone instanceof RegExp) {
+    let result = new RegExp(valueToClone.source, valueToClone.flags);
+    return result.lastIndex = valueToClone.lastIndex, result;
+  }
+  if (valueToClone instanceof Map) {
+    let result = /* @__PURE__ */ new Map();
+    stack.set(valueToClone, result);
+    for (let [key, value] of valueToClone) result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (valueToClone instanceof Set) {
+    let result = /* @__PURE__ */ new Set();
+    stack.set(valueToClone, result);
+    for (let value of valueToClone) result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+    return result;
+  }
+  if (isBuffer(valueToClone)) return valueToClone.subarray();
+  if (isTypedArray(valueToClone)) {
+    let result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer < "u" && valueToClone instanceof SharedArrayBuffer) return valueToClone.slice(0);
+  if (valueToClone instanceof DataView) {
+    let result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (typeof File < "u" && valueToClone instanceof File) {
+    let result = new File([valueToClone], valueToClone.name, { type: valueToClone.type });
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (typeof Blob < "u" && valueToClone instanceof Blob) {
+    let result = new Blob([valueToClone], { type: valueToClone.type });
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof Error) {
+    let result = structuredClone(valueToClone);
+    return stack.set(valueToClone, result), result.message = valueToClone.message, result.name = valueToClone.name, result.stack = valueToClone.stack, result.cause = valueToClone.cause, result.constructor = valueToClone.constructor, copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof Boolean) {
+    let result = new Boolean(valueToClone.valueOf());
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof Number) {
+    let result = new Number(valueToClone.valueOf());
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (valueToClone instanceof String) {
+    let result = new String(valueToClone.valueOf());
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  if (typeof valueToClone == "object" && isCloneableObject(valueToClone)) {
+    let result = Object.create(Object.getPrototypeOf(valueToClone));
+    return stack.set(valueToClone, result), copyProperties(result, valueToClone, objectToClone, stack, cloneValue), result;
+  }
+  return valueToClone;
+}
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+  let keys = [...Object.keys(source), ...getSymbols(source)];
+  for (let i = 0; i < keys.length; i++) {
+    let key = keys[i], descriptor = Object.getOwnPropertyDescriptor(target, key);
+    (descriptor == null || descriptor.writable) && (target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue));
+  }
+}
+function isCloneableObject(object) {
+  switch (getTag(object)) {
+    case argumentsTag:
+    case arrayTag:
+    case arrayBufferTag:
+    case dataViewTag:
+    case booleanTag:
+    case dateTag:
+    case float32ArrayTag:
+    case float64ArrayTag:
+    case int8ArrayTag:
+    case int16ArrayTag:
+    case int32ArrayTag:
+    case mapTag:
+    case numberTag:
+    case objectTag:
+    case regexpTag:
+    case setTag:
+    case stringTag:
+    case symbolTag:
+    case uint8ArrayTag:
+    case uint8ClampedArrayTag:
+    case uint16ArrayTag:
+    case uint32ArrayTag:
+      return !0;
+    default:
+      return !1;
+  }
+}
+
+// ../../node_modules/es-toolkit/dist/object/cloneDeep.mjs
+function cloneDeep(obj) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
+}
+
+// ../../node_modules/es-toolkit/dist/_internal/isMergeableValue.mjs
+function isMergeableValue(value) {
+  return isPlainObject(value) || Array.isArray(value);
+}
+
+// ../../node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+
+// ../../node_modules/es-toolkit/dist/object/mergeWith.mjs
+function mergeWith(target, source, merge2) {
+  let sourceKeys = Object.keys(source);
+  for (let i = 0; i < sourceKeys.length; i++) {
+    let key = sourceKeys[i];
+    if (isUnsafeProperty(key)) continue;
+    let sourceValue = source[key], targetValue = target[key], merged = merge2(targetValue, sourceValue, key, target, source);
+    merged !== void 0 ? target[key] = merged : isMergeableValue(sourceValue) && isMergeableValue(targetValue) ? target[key] = mergeWith(targetValue, sourceValue, merge2) : Array.isArray(sourceValue) ? target[key] = mergeWith([], sourceValue, merge2) : isPlainObject(sourceValue) ? target[key] = mergeWith({}, sourceValue, merge2) : (targetValue === void 0 || sourceValue !== void 0) && (target[key] = sourceValue);
+  }
+  return target;
+}
+
+// ../../node_modules/es-toolkit/dist/object/toMerged.mjs
+function toMerged(target, source) {
+  return mergeWith(cloneDeep(target), source, function mergeRecursively(targetValue, sourceValue) {
+    if (isMergeableValue(sourceValue) && isMergeableValue(targetValue)) return mergeWith(clone(targetValue), sourceValue, mergeRecursively);
+    if (Array.isArray(sourceValue)) return mergeWith([], sourceValue, mergeRecursively);
+    if (isPlainObject(sourceValue)) return mergeWith({}, sourceValue, mergeRecursively);
+  });
+}
+
+// src/shared/open-service/server.ts
+var getService2 = getService;
+function registerService2(definition, registration) {
+  return registerService(definition, registration, { relay: !0 });
+}
+async function buildStaticFiles() {
+  let store = {}, buildTasks = [];
+  for (let service of getRegisteredServices())
+    for (let [queryName, query] of Object.entries(service.queries)) {
+      let { load, staticPath, staticInputs } = query;
+      !staticPath || !load || !staticInputs || buildTasks.push(
+        (async () => {
+          let inputsRuntime = createServiceRuntime(service, { registryApi: serviceRegistryApi }), inputs = await staticInputs(inputsRuntime.loadCtxForStatic);
+          return Promise.all(
+            inputs.map(async (input) => {
+              let buildRuntime = createServiceRuntime(service, {
+                registryApi: serviceRegistryApi
+              }), validatedInput = await validateSchema(query.input, input, {
+                kind: "query",
+                serviceId: service.id,
+                name: queryName,
+                phase: "input"
+              }), path = resolveStaticPath(service.id, queryName, { staticPath }, validatedInput);
+              return await buildRuntime.runLoadOnce(queryName, validatedInput), { path, state: buildRuntime.getStateSnapshot() };
+            })
+          );
+        })()
+      );
+    }
+  let builtStates = (await Promise.all(buildTasks)).flat();
+  for (let { path, state } of builtStates)
+    store[path] = path in store ? toMerged(store[path], state) : state;
+  return store;
+}
+async function writeOpenServiceStaticFiles(outputDir) {
+  let staticStore = await buildStaticFiles();
+  await Promise.all(
+    Object.entries(staticStore).map(async ([relativePath, state]) => {
+      let outputPath = join(outputDir, "services", ...relativePath.split("/"));
+      await mkdir(dirname(outputPath), { recursive: !0 }), await writeFile(outputPath, JSON.stringify(state, null, 2));
+    })
+  );
+}
+
+// src/common/utils/paths.ts
+import { join as join2, relative, resolve, sep } from "node:path";
+
+// src/common/js-package-manager/constants.ts
+var NPM_LOCKFILE = "package-lock.json", PNPM_LOCKFILE = "pnpm-lock.yaml", YARN_LOCKFILE = "yarn.lock", BUN_LOCKFILE = "bun.lock", BUN_LOCKFILE_BINARY = "bun.lockb", LOCK_FILES = [
+  NPM_LOCKFILE,
+  PNPM_LOCKFILE,
+  YARN_LOCKFILE,
+  BUN_LOCKFILE,
+  BUN_LOCKFILE_BINARY
+];
+
+// src/common/utils/paths.ts
+var projectRoot, getProjectRoot = () => {
+  if (projectRoot)
+    return projectRoot;
+  if (process.env.FORKBOOK_PROJECT_ROOT)
+    return process.env.FORKBOOK_PROJECT_ROOT;
+  try {
+    let found = up2(".git") || up2(".svn") || up2(".hg");
+    if (found)
+      return projectRoot = join2(found, ".."), projectRoot;
+  } catch (e) {
+    process.stdout.write(`
+error searching for repository root: ${e}
+`);
+  }
+  try {
+    let found = any(LOCK_FILES);
+    if (found)
+      return projectRoot = join2(found, ".."), projectRoot;
+  } catch (e) {
+    process.stdout.write(`
+error searching for lock file: ${e}
+`);
+  }
+  try {
+    let [basePath, rest] = __dirname.split(`${sep}node_modules${sep}`, 2);
+    if (rest && !basePath.includes(`${sep}npm-cache${sep}`) && !relative(basePath, process.cwd()).startsWith(".."))
+      return projectRoot = basePath, projectRoot;
+  } catch (e) {
+    process.stdout.write(`
+error searching for splitDirname: ${e}
+`);
+  }
+  return projectRoot = process.cwd(), projectRoot;
+}, invalidateProjectRootCache = () => {
+  projectRoot = void 0;
+}, findFilesUp = (matchers, baseDir = process.cwd()) => {
+  let matchingFiles = [];
+  for (let directory of up(baseDir, { last: getProjectRoot() }))
+    matchingFiles.push(...globSync(matchers, { cwd: directory, absolute: !0 }));
+  return matchingFiles;
+}, nodePathsToArray = (nodePath) => nodePath.split(process.platform === "win32" ? ";" : ":").filter(Boolean).map((p) => resolve("./", p)), relativePattern = /^\.{1,2}([/\\]|$)/;
+function normalizeStoryPath(filename) {
+  return relativePattern.test(filename) ? filename : `.${sep}${filename}`;
+}
+
+export {
+  getService2 as getService,
+  registerService2 as registerService,
+  writeOpenServiceStaticFiles,
+  NPM_LOCKFILE,
+  PNPM_LOCKFILE,
+  YARN_LOCKFILE,
+  BUN_LOCKFILE,
+  BUN_LOCKFILE_BINARY,
+  getProjectRoot,
+  invalidateProjectRootCache,
+  findFilesUp,
+  nodePathsToArray,
+  normalizeStoryPath
+};

package/dist/_node-chunks/{chunk-AU3SF2WM.js → chunk-XWGMQW2H.js}

@@ -1,10 +1,10 @@
-import CJS_COMPAT_NODE_URL_ubhjlnocuxr from 'node:url';
-import CJS_COMPAT_NODE_PATH_ubhjlnocuxr from 'node:path';
-import CJS_COMPAT_NODE_MODULE_ubhjlnocuxr from "node:module";
+import CJS_COMPAT_NODE_URL_7qov04rgzsv from 'node:url';
+import CJS_COMPAT_NODE_PATH_7qov04rgzsv from 'node:path';
+import CJS_COMPAT_NODE_MODULE_7qov04rgzsv from "node:module";
 
-var __filename = CJS_COMPAT_NODE_URL_ubhjlnocuxr.fileURLToPath(import.meta.url);
-var __dirname = CJS_COMPAT_NODE_PATH_ubhjlnocuxr.dirname(__filename);
-var require = CJS_COMPAT_NODE_MODULE_ubhjlnocuxr.createRequire(import.meta.url);
+var __filename = CJS_COMPAT_NODE_URL_7qov04rgzsv.fileURLToPath(import.meta.url);
+var __dirname = CJS_COMPAT_NODE_PATH_7qov04rgzsv.dirname(__filename);
+var require = CJS_COMPAT_NODE_MODULE_7qov04rgzsv.createRequire(import.meta.url);
 
 // ------------------------------------------------------------
 // end of CJS compatibility banner, injected by Forkbook's esbuild configuration