@highstate/designer 0.2.0 → 0.2.1

package/.output/server/node_modules/vue-bundle-renderer/dist/runtime.mjs

@@ -0,0 +1,196 @@
+import { withLeadingSlash } from 'ufo';
+
+function createRendererContext({ manifest, buildAssetsURL }) {
+  const ctx = {
+    // Manifest
+    buildAssetsURL: buildAssetsURL || withLeadingSlash,
+    manifest: void 0,
+    updateManifest,
+    // Internal cache
+    _dependencies: void 0,
+    _dependencySets: void 0,
+    _entrypoints: void 0
+  };
+  function updateManifest(manifest2) {
+    const manifestEntries = Object.entries(manifest2);
+    ctx.manifest = manifest2;
+    ctx._dependencies = {};
+    ctx._dependencySets = {};
+    ctx._entrypoints = manifestEntries.filter((e) => e[1].isEntry).map(([module]) => module);
+  }
+  updateManifest(manifest);
+  return ctx;
+}
+function getModuleDependencies(id, rendererContext) {
+  if (rendererContext._dependencies[id]) {
+    return rendererContext._dependencies[id];
+  }
+  const dependencies = rendererContext._dependencies[id] = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  const meta = rendererContext.manifest[id];
+  if (!meta) {
+    return dependencies;
+  }
+  if (meta.file) {
+    dependencies.preload[id] = meta;
+    if (meta.isEntry || meta.sideEffects) {
+      dependencies.scripts[id] = meta;
+    }
+  }
+  for (const css of meta.css || []) {
+    dependencies.styles[css] = dependencies.preload[css] = dependencies.prefetch[css] = rendererContext.manifest[css];
+  }
+  for (const asset of meta.assets || []) {
+    dependencies.preload[asset] = dependencies.prefetch[asset] = rendererContext.manifest[asset];
+  }
+  for (const depId of meta.imports || []) {
+    const depDeps = getModuleDependencies(depId, rendererContext);
+    Object.assign(dependencies.styles, depDeps.styles);
+    Object.assign(dependencies.preload, depDeps.preload);
+    Object.assign(dependencies.prefetch, depDeps.prefetch);
+  }
+  const filteredPreload = {};
+  for (const id2 in dependencies.preload) {
+    const dep = dependencies.preload[id2];
+    if (dep.preload) {
+      filteredPreload[id2] = dep;
+    }
+  }
+  dependencies.preload = filteredPreload;
+  return dependencies;
+}
+function getAllDependencies(ids, rendererContext) {
+  const cacheKey = Array.from(ids).sort().join(",");
+  if (rendererContext._dependencySets[cacheKey]) {
+    return rendererContext._dependencySets[cacheKey];
+  }
+  const allDeps = {
+    scripts: {},
+    styles: {},
+    preload: {},
+    prefetch: {}
+  };
+  for (const id of ids) {
+    const deps = getModuleDependencies(id, rendererContext);
+    Object.assign(allDeps.scripts, deps.scripts);
+    Object.assign(allDeps.styles, deps.styles);
+    Object.assign(allDeps.preload, deps.preload);
+    Object.assign(allDeps.prefetch, deps.prefetch);
+    for (const dynamicDepId of rendererContext.manifest[id]?.dynamicImports || []) {
+      const dynamicDeps = getModuleDependencies(dynamicDepId, rendererContext);
+      Object.assign(allDeps.prefetch, dynamicDeps.scripts);
+      Object.assign(allDeps.prefetch, dynamicDeps.styles);
+      Object.assign(allDeps.prefetch, dynamicDeps.preload);
+    }
+  }
+  const filteredPrefetch = {};
+  for (const id in allDeps.prefetch) {
+    const dep = allDeps.prefetch[id];
+    if (dep.prefetch) {
+      filteredPrefetch[id] = dep;
+    }
+  }
+  allDeps.prefetch = filteredPrefetch;
+  for (const id in allDeps.preload) {
+    delete allDeps.prefetch[id];
+  }
+  for (const style in allDeps.styles) {
+    delete allDeps.preload[style];
+    delete allDeps.prefetch[style];
+  }
+  rendererContext._dependencySets[cacheKey] = allDeps;
+  return allDeps;
+}
+function getRequestDependencies(ssrContext, rendererContext) {
+  if (ssrContext._requestDependencies) {
+    return ssrContext._requestDependencies;
+  }
+  const ids = new Set(Array.from([
+    ...rendererContext._entrypoints,
+    ...ssrContext.modules || ssrContext._registeredComponents || []
+  ]));
+  const deps = getAllDependencies(ids, rendererContext);
+  ssrContext._requestDependencies = deps;
+  return deps;
+}
+function renderStyles(ssrContext, rendererContext) {
+  const { styles } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(styles).map(
+    (resource) => renderLinkToString({ rel: "stylesheet", href: rendererContext.buildAssetsURL(resource.file), crossorigin: "" })
+  ).join("");
+}
+function getResources(ssrContext, rendererContext) {
+  return [...getPreloadLinks(ssrContext, rendererContext), ...getPrefetchLinks(ssrContext, rendererContext)];
+}
+function renderResourceHints(ssrContext, rendererContext) {
+  return getResources(ssrContext, rendererContext).map(renderLinkToString).join("");
+}
+function renderResourceHeaders(ssrContext, rendererContext) {
+  return {
+    link: getResources(ssrContext, rendererContext).map(renderLinkToHeader).join(", ")
+  };
+}
+function getPreloadLinks(ssrContext, rendererContext) {
+  const { preload } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(preload).map((resource) => ({
+    rel: resource.module ? "modulepreload" : "preload",
+    as: resource.resourceType,
+    type: resource.mimeType ?? null,
+    crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+    href: rendererContext.buildAssetsURL(resource.file)
+  }));
+}
+function getPrefetchLinks(ssrContext, rendererContext) {
+  const { prefetch } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(prefetch).map((resource) => ({
+    rel: "prefetch",
+    as: resource.resourceType,
+    type: resource.mimeType ?? null,
+    crossorigin: resource.resourceType === "style" || resource.resourceType === "font" || resource.resourceType === "script" || resource.module ? "" : null,
+    href: rendererContext.buildAssetsURL(resource.file)
+  }));
+}
+function renderScripts(ssrContext, rendererContext) {
+  const { scripts } = getRequestDependencies(ssrContext, rendererContext);
+  return Object.values(scripts).map((resource) => renderScriptToString({
+    type: resource.module ? "module" : null,
+    src: rendererContext.buildAssetsURL(resource.file),
+    defer: resource.module ? null : "",
+    crossorigin: ""
+  })).join("");
+}
+function createRenderer(createApp, renderOptions) {
+  const rendererContext = createRendererContext(renderOptions);
+  return {
+    rendererContext,
+    async renderToString(ssrContext) {
+      ssrContext._registeredComponents = ssrContext._registeredComponents || /* @__PURE__ */ new Set();
+      const _createApp = await Promise.resolve(createApp).then((r) => "default" in r ? r.default : r);
+      const app = await _createApp(ssrContext);
+      const html = await renderOptions.renderToString(app, ssrContext);
+      const wrap = (fn) => () => fn(ssrContext, rendererContext);
+      return {
+        html,
+        renderResourceHeaders: wrap(renderResourceHeaders),
+        renderResourceHints: wrap(renderResourceHints),
+        renderStyles: wrap(renderStyles),
+        renderScripts: wrap(renderScripts)
+      };
+    }
+  };
+}
+function renderScriptToString(attrs) {
+  return `<script${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}><\/script>`;
+}
+function renderLinkToString(attrs) {
+  return `<link${Object.entries(attrs).map(([key, value]) => value === null ? "" : value ? ` ${key}="${value}"` : " " + key).join("")}>`;
+}
+function renderLinkToHeader(attrs) {
+  return `<${attrs.href}>${Object.entries(attrs).map(([key, value]) => key === "href" || value === null ? "" : value ? `; ${key}="${value}"` : `; ${key}`).join("")}`;
+}
+
+export { createRenderer, createRendererContext, getAllDependencies, getModuleDependencies, getPrefetchLinks, getPreloadLinks, getRequestDependencies, getResources, renderResourceHeaders, renderResourceHints, renderScripts, renderStyles };

package/.output/server/node_modules/vue-bundle-renderer/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "vue-bundle-renderer",
+  "version": "2.1.1",
+  "description": "Bundle Renderer for Vue 3.0",
+  "repository": "nuxt-contrib/vue-bundle-renderer",
+  "license": "MIT",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.mjs",
+      "require": "./dist/runtime.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "runtime.d.ts"
+  ],
+  "scripts": {
+    "build": "unbuild",
+    "dev": "vitest",
+    "lint": "eslint src",
+    "prepack": "unbuild",
+    "release": "pnpm test && pnpm build && changelogen --release --push && npm publish",
+    "test": "pnpm lint && pnpm vitest run --coverage && tsc --noEmit"
+  },
+  "dependencies": {
+    "ufo": "^1.5.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.16.6",
+    "@vitest/coverage-v8": "^2.1.1",
+    "changelogen": "^0.5.7",
+    "eslint": "^9.11.1",
+    "typescript": "^5.6.2",
+    "unbuild": "^2.0.0",
+    "vite": "^5.4.7",
+    "vitest": "2.1.1",
+    "vue": "3.5.8",
+    "@nuxt/eslint-config": "^0.5.7"
+  },
+  "packageManager": "pnpm@9.11.0"
+}

package/.output/server/node_modules/watcher/dist/constants.js

@@ -0,0 +1,16 @@
+/* IMPORT */
+import os from 'node:os';
+/* MAIN */
+const DEBOUNCE = 300;
+const DEPTH = 20;
+const LIMIT = 10000000;
+const PLATFORM = os.platform();
+const IS_LINUX = (PLATFORM === 'linux');
+const IS_MAC = (PLATFORM === 'darwin');
+const IS_WINDOWS = (PLATFORM === 'win32');
+const HAS_NATIVE_RECURSION = IS_MAC || IS_WINDOWS;
+const POLLING_INTERVAL = 3000;
+const POLLING_TIMEOUT = 20000;
+const RENAME_TIMEOUT = 1250;
+/* EXPORT */
+export { DEBOUNCE, DEPTH, LIMIT, HAS_NATIVE_RECURSION, IS_LINUX, IS_MAC, IS_WINDOWS, PLATFORM, POLLING_INTERVAL, POLLING_TIMEOUT, RENAME_TIMEOUT };

package/.output/server/node_modules/watcher/dist/enums.js

@@ -0,0 +1,35 @@
+/* MAIN */
+var FileType;
+(function (FileType) {
+    FileType[FileType["DIR"] = 1] = "DIR";
+    FileType[FileType["FILE"] = 2] = "FILE";
+})(FileType || (FileType = {}));
+var FSTargetEvent;
+(function (FSTargetEvent) {
+    FSTargetEvent["CHANGE"] = "change";
+    FSTargetEvent["RENAME"] = "rename";
+})(FSTargetEvent || (FSTargetEvent = {}));
+var FSWatcherEvent;
+(function (FSWatcherEvent) {
+    FSWatcherEvent["CHANGE"] = "change";
+    FSWatcherEvent["ERROR"] = "error";
+})(FSWatcherEvent || (FSWatcherEvent = {}));
+var TargetEvent;
+(function (TargetEvent) {
+    TargetEvent["ADD"] = "add";
+    TargetEvent["ADD_DIR"] = "addDir";
+    TargetEvent["CHANGE"] = "change";
+    TargetEvent["RENAME"] = "rename";
+    TargetEvent["RENAME_DIR"] = "renameDir";
+    TargetEvent["UNLINK"] = "unlink";
+    TargetEvent["UNLINK_DIR"] = "unlinkDir";
+})(TargetEvent || (TargetEvent = {}));
+var WatcherEvent;
+(function (WatcherEvent) {
+    WatcherEvent["ALL"] = "all";
+    WatcherEvent["CLOSE"] = "close";
+    WatcherEvent["ERROR"] = "error";
+    WatcherEvent["READY"] = "ready";
+})(WatcherEvent || (WatcherEvent = {}));
+/* EXPORT */
+export { FileType, FSTargetEvent, FSWatcherEvent, TargetEvent, WatcherEvent };

package/.output/server/node_modules/watcher/dist/lazy_map_set.js

@@ -0,0 +1,81 @@
+/* IMPORT */
+import Utils from './utils.js';
+/* MAIN */
+//TODO: Maybe publish this as a standalone module
+class LazyMapSet {
+    constructor() {
+        /* VARIABLES */
+        this.map = new Map();
+    }
+    /* API */
+    clear() {
+        this.map.clear();
+    }
+    delete(key, value) {
+        if (Utils.lang.isUndefined(value)) {
+            return this.map.delete(key);
+        }
+        else if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                const deleted = values.delete(value);
+                if (!values.size) {
+                    this.map.delete(key);
+                }
+                return deleted;
+            }
+            else if (values === value) {
+                this.map.delete(key);
+                return true;
+            }
+        }
+        return false;
+    }
+    find(key, iterator) {
+        if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                return Array.from(values).find(iterator);
+            }
+            else if (iterator(values)) { //TSC
+                return values;
+            }
+        }
+        return undefined;
+    }
+    get(key) {
+        return this.map.get(key);
+    }
+    has(key, value) {
+        if (Utils.lang.isUndefined(value)) {
+            return this.map.has(key);
+        }
+        else if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                return values.has(value);
+            }
+            else {
+                return (values === value);
+            }
+        }
+        return false;
+    }
+    set(key, value) {
+        if (this.map.has(key)) {
+            const values = this.map.get(key);
+            if (Utils.lang.isSet(values)) {
+                values.add(value);
+            }
+            else if (values !== value) {
+                this.map.set(key, new Set([values, value])); //TSC
+            }
+        }
+        else {
+            this.map.set(key, value);
+        }
+        return this;
+    }
+}
+/* EXPORT */
+export default LazyMapSet;

package/.output/server/node_modules/watcher/dist/utils.js

@@ -0,0 +1,120 @@
+/* IMPORT */
+import { debounce } from 'dettle';
+import fs from 'node:fs';
+import path from 'node:path';
+import sfs from 'stubborn-fs';
+import readdir from 'tiny-readdir';
+import { POLLING_TIMEOUT } from './constants.js';
+/* MAIN */
+const Utils = {
+    /* LANG API */
+    lang: {
+        debounce,
+        attempt: (fn) => {
+            try {
+                return fn();
+            }
+            catch (error) {
+                return Utils.lang.castError(error);
+            }
+        },
+        castArray: (x) => {
+            return Utils.lang.isArray(x) ? x : [x];
+        },
+        castError: (exception) => {
+            if (Utils.lang.isError(exception))
+                return exception;
+            if (Utils.lang.isString(exception))
+                return new Error(exception);
+            return new Error('Unknown error');
+        },
+        defer: (callback) => {
+            return setTimeout(callback, 0);
+        },
+        isArray: (value) => {
+            return Array.isArray(value);
+        },
+        isError: (value) => {
+            return value instanceof Error;
+        },
+        isFunction: (value) => {
+            return typeof value === 'function';
+        },
+        isNaN: (value) => {
+            return Number.isNaN(value);
+        },
+        isNumber: (value) => {
+            return typeof value === 'number';
+        },
+        isPrimitive: (value) => {
+            if (value === null)
+                return true;
+            const type = typeof value;
+            return type !== 'object' && type !== 'function';
+        },
+        isShallowEqual: (x, y) => {
+            if (x === y)
+                return true;
+            if (Utils.lang.isNaN(x))
+                return Utils.lang.isNaN(y);
+            if (Utils.lang.isPrimitive(x) || Utils.lang.isPrimitive(y))
+                return x === y;
+            for (const i in x)
+                if (!(i in y))
+                    return false;
+            for (const i in y)
+                if (x[i] !== y[i])
+                    return false;
+            return true;
+        },
+        isSet: (value) => {
+            return value instanceof Set;
+        },
+        isString: (value) => {
+            return typeof value === 'string';
+        },
+        isUndefined: (value) => {
+            return value === undefined;
+        },
+        noop: () => {
+            return;
+        },
+        uniq: (arr) => {
+            if (arr.length < 2)
+                return arr;
+            return Array.from(new Set(arr));
+        }
+    },
+    /* FS API */
+    fs: {
+        getDepth: (targetPath) => {
+            return Math.max(0, targetPath.split(path.sep).length - 1);
+        },
+        getRealPath: (targetPath, native) => {
+            try {
+                return native ? fs.realpathSync.native(targetPath) : fs.realpathSync(targetPath);
+            }
+            catch {
+                return;
+            }
+        },
+        isSubPath: (targetPath, subPath) => {
+            return (subPath.startsWith(targetPath) && subPath[targetPath.length] === path.sep && (subPath.length - targetPath.length) > path.sep.length);
+        },
+        poll: (targetPath, timeout = POLLING_TIMEOUT) => {
+            return sfs.retry.stat(timeout)(targetPath, { bigint: true }).catch(Utils.lang.noop);
+        },
+        readdir: async (rootPath, ignore, depth = Infinity, limit = Infinity, signal, readdirMap) => {
+            if (readdirMap && depth === 1 && rootPath in readdirMap) { // Reusing cached data
+                const result = readdirMap[rootPath];
+                return [result.directories, result.files];
+            }
+            else { // Retrieving fresh data
+                const result = await readdir(rootPath, { depth, limit, ignore, signal });
+                return [result.directories, result.files];
+            }
+        }
+    }
+};
+/* EXPORT */
+export default Utils;