npm - @alstar/studio - Versions diffs - 0.0.0-beta.2 → 0.0.0-beta.4 - Mend

@alstar/studio 0.0.0-beta.2 → 0.0.0-beta.4

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 (9) hide show

package/components/layout.ts +10 -1
package/index.ts +4 -4
package/package.json +3 -4
package/public/main.css +2 -1
package/public/main.js +15 -14
package/utils/define.ts +13 -0
package/utils/file-based-router.ts +1 -1
package/utils/get-config.ts +1 -1
package/utils/html.ts +247 -0

package/components/layout.ts CHANGED Viewed

@@ -34,7 +34,16 @@ export default (props: {
           type="module"
           src="https://cdn.jsdelivr.net/gh/starfederation/datastar@main/bundles/datastar.js"
         ></script>
-        <script src="https://unpkg.com/@barba/core@2.10.3/dist/barba.umd.js"></script>
+        <script type="importmap">
+          {
+            "imports": {
+              "@barba/core": "https://esm.sh/@barba/core@2.10.3/dist/barba.mjs",
+              "sortablejs": "https://esm.sh/sortablejs@1.15.6/modular/sortable.core.esm.js",
+              "ink-mde": "https://esm.sh/ink-mde@0.34.0"
+            }
+          }
+        </script>
       </head>
       <body data-barba="wrapper">

package/index.ts CHANGED Viewed

@@ -14,6 +14,8 @@ import { serveStatic } from '@hono/node-server/serve-static'
 import { createStudioTables } from './utils/create-studio-tables.ts'
 import { fileBasedRouter } from './utils/file-based-router.ts'
+export { html, type HtmlEscapedString } from './utils/html.ts'
 export let structure: types.Structure
 export let rootdir = '/node_modules/@alstar/studio'
@@ -22,7 +24,7 @@ const createStudio = async (studioStructure?: types.Structure) => {
   structure = studioStructure || []
-  loadDb('./cms.db')
+  loadDb('./studio.db')
   createStudioTables()
@@ -65,7 +67,5 @@ const createStudio = async (studioStructure?: types.Structure) => {
   return app
 }
-export const defineConfig = (config: types.StudioConfig) => config
-export const defineStructure = (structure: types.Structure) => structure
+export { defineConfig, defineEntry, defineStructure } from './utils/define.ts'
 export { createStudio, query }

package/package.json CHANGED Viewed

@@ -1,15 +1,14 @@
 {
   "name": "@alstar/studio",
-  "version": "0.0.0-beta.2",
+  "version": "0.0.0-beta.4",
   "type": "module",
   "main": "index.ts",
   "dependencies": {
     "@hono/node-server": "^1.18.1",
     "@starfederation/datastar-sdk": "1.0.0-RC.1",
     "hono": "^4.8.12",
-    "sortablejs": "^1.15.6",
-    "@alstar/ui": "0.0.0-beta.1",
-    "@alstar/db": "0.0.0-beta.1"
+    "@alstar/db": "0.0.0-beta.1",
+    "@alstar/ui": "0.0.0-beta.1"
   },
   "devDependencies": {
     "@types/node": "^24.1.0",

package/public/main.css CHANGED Viewed

@@ -1,4 +1,5 @@
-@import './../node_modules/@alstar/ui/red.css';
+/* @import './../node_modules/@alstar/ui/red.css'; */
+@import 'https://esm.sh/@alstar/ui/red.css';
 body {
   min-height: 100vh;

package/public/main.js CHANGED Viewed

@@ -1,5 +1,6 @@
-import Sortable from '../node_modules/sortablejs/modular/sortable.core.esm.js'
-import { ink, wrap } from 'https://esm.sh/ink-mde@0.34.0'
+import barba from '@barba/core'
+import Sortable from 'sortablejs'
+// import { wrap } from 'ink-mde'
 barba.init({
   views: [
@@ -27,17 +28,17 @@ function init() {
     })
   }
-  // ink-mde
-  {
-    const el = document.querySelector('textarea')
+  // // ink-mde
+  // {
+  //   const el = document.querySelector('textarea')
-    if (el) {
-      wrap(el, {
-        interface: {
-          // appearance: InkValues.Appearance.Auto,
-          attribution: false,
-        },
-      })
-    }
-  }
+  //   if (el) {
+  //     wrap(el, {
+  //       interface: {
+  //         // appearance: InkValues.Appearance.Auto,
+  //         attribution: false,
+  //       },
+  //     })
+  //   }
+  // }
 }

package/utils/define.ts ADDED Viewed

@@ -0,0 +1,13 @@
+import { type Context } from 'hono'
+import * as types from '../types.ts'
+import { type HttpBindings } from '@hono/node-server'
+import { type BlankInput } from 'hono/types'
+import { type HtmlEscapedString } from './html.ts'
+export const defineConfig = (config: types.StudioConfig) => config
+export const defineStructure = (structure: types.Structure) => structure
+export const defineEntry = (
+  fn: (
+    c: Context<{ Bindings: HttpBindings }, string, BlankInput>,
+  ) => HtmlEscapedString | Promise<HtmlEscapedString>,
+) => fn

package/utils/file-based-router.ts CHANGED Viewed

@@ -3,7 +3,7 @@ import path from 'node:path'
 import { Hono } from 'hono'
 import { type HtmlEscapedString } from 'hono/utils/html'
-type Page<C> = (c?: C) => HtmlEscapedString | Promise<HtmlEscapedString>
+export type Page<C> = (c?: C) => HtmlEscapedString | Promise<HtmlEscapedString>
 export const fileBasedRouter = async (rootdir: string) => {
   const router = new Hono()

package/utils/get-config.ts CHANGED Viewed

@@ -8,7 +8,7 @@ async function fileExists(filepath: string) {
   try {
     await fs.stat(filepath)
   } catch (error) {
-    return {}
+    return null
   }
 }

package/utils/html.ts ADDED Viewed

@@ -0,0 +1,247 @@
+export const HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3,
+} as const
+type HtmlEscapedCallbackOpts = {
+  buffer?: [string]
+  phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase]
+  context: Readonly<object> // An object unique to each JSX tree. This object is used as the WeakMap key.
+}
+export type HtmlEscapedCallback = (
+  opts: HtmlEscapedCallbackOpts,
+) => Promise<string> | undefined
+export type HtmlEscaped = {
+  isEscaped: true
+  callbacks?: HtmlEscapedCallback[]
+}
+export type HtmlEscapedString = string & HtmlEscaped
+/**
+ * StringBuffer contains string and Promise<string> alternately
+ * The length of the array will be odd, the odd numbered element will be a string,
+ * and the even numbered element will be a Promise<string>.
+ * When concatenating into a single string, it must be processed from the tail.
+ * @example
+ * [
+ *   'framework.',
+ *   Promise.resolve('ultra fast'),
+ *   'a ',
+ *   Promise.resolve('is '),
+ *   'Hono',
+ * ]
+ */
+export type StringBuffer = (string | Promise<string>)[]
+export type StringBufferWithCallbacks = StringBuffer & {
+  callbacks: HtmlEscapedCallback[]
+}
+export const raw = (
+  value: unknown,
+  callbacks?: HtmlEscapedCallback[],
+): HtmlEscapedString => {
+  const escapedString = new String(value) as HtmlEscapedString
+  escapedString.isEscaped = true
+  escapedString.callbacks = callbacks
+  return escapedString
+}
+// The `escapeToBuffer` implementation is based on code from the MIT licensed `react-dom` package.
+// https://github.com/facebook/react/blob/main/packages/react-dom-bindings/src/server/escapeTextForBrowser.js
+const escapeRe = /[&<>'"]/
+export const stringBufferToString = async (
+  buffer: StringBuffer,
+  callbacks: HtmlEscapedCallback[] | undefined,
+): Promise<HtmlEscapedString> => {
+  let str = ''
+  callbacks ||= []
+  const resolvedBuffer = await Promise.all(buffer)
+  for (let i = resolvedBuffer.length - 1; ; i--) {
+    str += resolvedBuffer[i]
+    i--
+    if (i < 0) {
+      break
+    }
+    let r = resolvedBuffer[i]
+    if (typeof r === 'object') {
+      callbacks.push(...((r as HtmlEscapedString).callbacks || []))
+    }
+    const isEscaped = (r as HtmlEscapedString).isEscaped
+    r = await (typeof r === 'object' ? (r as HtmlEscapedString).toString() : r)
+    if (typeof r === 'object') {
+      callbacks.push(...((r as HtmlEscapedString).callbacks || []))
+    }
+    if ((r as HtmlEscapedString).isEscaped ?? isEscaped) {
+      str += r
+    } else {
+      const buf = [str]
+      escapeToBuffer(r, buf)
+      str = buf[0]
+    }
+  }
+  return raw(str, callbacks)
+}
+export const escapeToBuffer = (str: string, buffer: StringBuffer): void => {
+  const match = str.search(escapeRe)
+  if (match === -1) {
+    buffer[0] += str
+    return
+  }
+  let escape
+  let index
+  let lastIndex = 0
+  for (index = match; index < str.length; index++) {
+    switch (str.charCodeAt(index)) {
+      case 34: // "
+        escape = '&quot;'
+        break
+      case 39: // '
+        escape = '&#39;'
+        break
+      case 38: // &
+        escape = '&amp;'
+        break
+      case 60: // <
+        escape = '&lt;'
+        break
+      case 62: // >
+        escape = '&gt;'
+        break
+      default:
+        continue
+    }
+    buffer[0] += str.substring(lastIndex, index) + escape
+    lastIndex = index + 1
+  }
+  buffer[0] += str.substring(lastIndex, index)
+}
+export const resolveCallbackSync = (
+  str: string | HtmlEscapedString,
+): string => {
+  const callbacks = (str as HtmlEscapedString)
+    .callbacks as HtmlEscapedCallback[]
+  if (!callbacks?.length) {
+    return str
+  }
+  const buffer: [string] = [str]
+  const context = {}
+  callbacks.forEach((c) =>
+    c({ phase: HtmlEscapedCallbackPhase.Stringify, buffer, context }),
+  )
+  return buffer[0]
+}
+export const resolveCallback = async (
+  str: string | HtmlEscapedString | Promise<string>,
+  phase: (typeof HtmlEscapedCallbackPhase)[keyof typeof HtmlEscapedCallbackPhase],
+  preserveCallbacks: boolean,
+  context: object,
+  buffer?: [string],
+): Promise<string> => {
+  if (typeof str === 'object' && !(str instanceof String)) {
+    if (!((str as unknown) instanceof Promise)) {
+      str = (str as unknown as string).toString() // HtmlEscapedString object to string
+    }
+    if ((str as string | Promise<string>) instanceof Promise) {
+      str = await (str as unknown as Promise<string>)
+    }
+  }
+  const callbacks = (str as HtmlEscapedString)
+    .callbacks as HtmlEscapedCallback[]
+  if (!callbacks?.length) {
+    return Promise.resolve(str)
+  }
+  if (buffer) {
+    buffer[0] += str
+  } else {
+    buffer = [str as string]
+  }
+  const resStr = Promise.all(
+    callbacks.map((c) => c({ phase, buffer, context })),
+  ).then((res) =>
+    Promise.all(
+      res
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .filter<string>(Boolean as any)
+        .map((str) => resolveCallback(str, phase, false, context, buffer)),
+    ).then(() => (buffer as [string])[0]),
+  )
+  if (preserveCallbacks) {
+    return raw(await resStr, callbacks)
+  } else {
+    return resStr
+  }
+}
+export const html = (
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): HtmlEscapedString | Promise<HtmlEscapedString> => {
+  const buffer: StringBufferWithCallbacks = [''] as StringBufferWithCallbacks
+  for (let i = 0, len = strings.length - 1; i < len; i++) {
+    buffer[0] += strings[i]
+    const children = Array.isArray(values[i])
+      ? (values[i] as Array<unknown>).flat(Infinity)
+      : [values[i]]
+    for (let i = 0, len = children.length; i < len; i++) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const child = children[i] as any
+      if (typeof child === 'string') {
+        escapeToBuffer(child, buffer)
+      } else if (typeof child === 'number') {
+        ;(buffer[0] as string) += child
+      } else if (
+        typeof child === 'boolean' ||
+        child === null ||
+        child === undefined
+      ) {
+        continue
+      } else if (
+        typeof child === 'object' &&
+        (child as HtmlEscaped).isEscaped
+      ) {
+        if ((child as HtmlEscapedString).callbacks) {
+          buffer.unshift('', child)
+        } else {
+          const tmp = child.toString()
+          if (tmp instanceof Promise) {
+            buffer.unshift('', tmp)
+          } else {
+            buffer[0] += tmp
+          }
+        }
+      } else if (child instanceof Promise) {
+        buffer.unshift('', child)
+      } else {
+        escapeToBuffer(child.toString(), buffer)
+      }
+    }
+  }
+  buffer[0] += strings.at(-1) as string
+  return buffer.length === 1
+    ? 'callbacks' in buffer
+      ? raw(resolveCallbackSync(raw(buffer[0], buffer.callbacks)))
+      : raw(buffer[0])
+    : stringBufferToString(buffer, buffer.callbacks)
+}