@livestore/livestore 0.4.0-dev.22 → 0.4.0-dev.23

package/docs/building-with-livestore/examples/turnbased-game/index.md

@@ -1,7 +0,0 @@
-# Turn-based game
-
-LiveStore is a great fit for turn-based games. In this guide we'll look at a simple turn-based game and how to model it in LiveStore.
-
-General idea: Let server enforce the logic that each player only commits one action per turn.
-
-TODO: write rest of guide

package/docs/building-with-livestore/opentelemetry/index.md

@@ -1,227 +0,0 @@
-# OpenTelemetry
-
-LiveStore has built-in support for OpenTelemetry.
-
-## Usage with React
-
-<Tabs>
-  <TabItem label="otel.ts">
-
-## `reference/opentelemetry/otel.ts`
-
-```ts filename="reference/opentelemetry/otel.ts"
-
-/**
- * Configure a browser tracer that preserves parent/child spans across async work.
- * Requires a zone.js runtime (e.g. provided by many frameworks) so the ZoneContextManager
- * can keep context during timers, promises, and event callbacks.
- */
-export const makeTracer = (serviceName: string) => {
-  const url = import.meta.env.VITE_OTEL_EXPORTER_OTLP_ENDPOINT as string | undefined
-  const provider = new WebTracerProvider({
-    spanProcessors: url ? [new SimpleSpanProcessor(new OTLPTraceExporter({ url: `${url}/v1/traces` }))] : [],
-    resource: resourceFromAttributes({ 'service.name': serviceName }),
-  })
-
-  provider.register({
-    contextManager: new ZoneContextManager(),
-    propagator: new W3CTraceContextPropagator(),
-  })
-
-  return provider.getTracer('livestore')
-}
-
-export const tracer = makeTracer('my-app')
-```
-
-</TabItem>
-  <TabItem label="App.tsx">
-
-## `reference/opentelemetry/app.tsx`
-
-```tsx filename="reference/opentelemetry/app.tsx"
-
-const adapter = makeInMemoryAdapter()
-
-// ---cut---
-const useAppStore = () =>
-  useStore({
-    storeId: 'otel-demo',
-    schema,
-    adapter,
-    batchUpdates,
-    otelOptions: { tracer },
-  })
-
-export const App: FC = () => {
-  const [storeRegistry] = useState(() => new StoreRegistry())
-  return (
-    <Suspense fallback={<div>Loading...</div>}>
-      <StoreRegistryProvider storeRegistry={storeRegistry}>
-        <AppContent />
-      </StoreRegistryProvider>
-    </Suspense>
-  )
-}
-
-const AppContent: FC = () => {
-  const _store = useAppStore()
-  // Use the store in your components
-  return <div>{/* Your app content */}</div>
-}
-```
-
-### `reference/framework-integrations/react/schema.ts`
-
-```ts filename="reference/framework-integrations/react/schema.ts"
-
-export const tables = {
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean({ default: false }),
-    },
-  }),
-  uiState: State.SQLite.clientDocument({
-    name: 'UiState',
-    schema: Schema.Struct({ text: Schema.String }),
-    default: { value: { text: '' } },
-  }),
-} as const
-
-export const events = {
-  todoCreated: Events.synced({
-    name: 'v1.TodoCreated',
-    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
-  }),
-} as const
-
-const materializers = State.SQLite.materializers(events, {
-  [events.todoCreated.name]: defineMaterializer(events.todoCreated, ({ id, text }) =>
-    tables.todos.insert({ id, text, completed: false }),
-  ),
-})
-
-const state = State.SQLite.makeState({ tables, materializers })
-
-export const schema = makeSchema({ events, state })
-```
-
-### `reference/opentelemetry/otel.ts`
-
-```ts filename="reference/opentelemetry/otel.ts"
-
-/**
- * Configure a browser tracer that preserves parent/child spans across async work.
- * Requires a zone.js runtime (e.g. provided by many frameworks) so the ZoneContextManager
- * can keep context during timers, promises, and event callbacks.
- */
-export const makeTracer = (serviceName: string) => {
-  const url = import.meta.env.VITE_OTEL_EXPORTER_OTLP_ENDPOINT as string | undefined
-  const provider = new WebTracerProvider({
-    spanProcessors: url ? [new SimpleSpanProcessor(new OTLPTraceExporter({ url: `${url}/v1/traces` }))] : [],
-    resource: resourceFromAttributes({ 'service.name': serviceName }),
-  })
-
-  provider.register({
-    contextManager: new ZoneContextManager(),
-    propagator: new W3CTraceContextPropagator(),
-  })
-
-  return provider.getTracer('livestore')
-}
-
-export const tracer = makeTracer('my-app')
-```
-
-### `reference/opentelemetry/schema.ts`
-
-```ts filename="reference/opentelemetry/schema.ts"
-export { schema } from '../framework-integrations/react/schema.ts'
-```
-
-</TabItem>
-  <TabItem label="livestore.worker.ts">
-
-## `reference/opentelemetry/livestore.worker.ts`
-
-```ts filename="reference/opentelemetry/livestore.worker.ts"
-
-makeWorker({ schema, otelOptions: { tracer } })
-```
-
-### `reference/framework-integrations/react/schema.ts`
-
-```ts filename="reference/framework-integrations/react/schema.ts"
-
-export const tables = {
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean({ default: false }),
-    },
-  }),
-  uiState: State.SQLite.clientDocument({
-    name: 'UiState',
-    schema: Schema.Struct({ text: Schema.String }),
-    default: { value: { text: '' } },
-  }),
-} as const
-
-export const events = {
-  todoCreated: Events.synced({
-    name: 'v1.TodoCreated',
-    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
-  }),
-} as const
-
-const materializers = State.SQLite.materializers(events, {
-  [events.todoCreated.name]: defineMaterializer(events.todoCreated, ({ id, text }) =>
-    tables.todos.insert({ id, text, completed: false }),
-  ),
-})
-
-const state = State.SQLite.makeState({ tables, materializers })
-
-export const schema = makeSchema({ events, state })
-```
-
-### `reference/opentelemetry/otel.ts`
-
-```ts filename="reference/opentelemetry/otel.ts"
-
-/**
- * Configure a browser tracer that preserves parent/child spans across async work.
- * Requires a zone.js runtime (e.g. provided by many frameworks) so the ZoneContextManager
- * can keep context during timers, promises, and event callbacks.
- */
-export const makeTracer = (serviceName: string) => {
-  const url = import.meta.env.VITE_OTEL_EXPORTER_OTLP_ENDPOINT as string | undefined
-  const provider = new WebTracerProvider({
-    spanProcessors: url ? [new SimpleSpanProcessor(new OTLPTraceExporter({ url: `${url}/v1/traces` }))] : [],
-    resource: resourceFromAttributes({ 'service.name': serviceName }),
-  })
-
-  provider.register({
-    contextManager: new ZoneContextManager(),
-    propagator: new W3CTraceContextPropagator(),
-  })
-
-  return provider.getTracer('livestore')
-}
-
-export const tracer = makeTracer('my-app')
-```
-
-### `reference/opentelemetry/schema.ts`
-
-```ts filename="reference/opentelemetry/schema.ts"
-export { schema } from '../framework-integrations/react/schema.ts'
-```
-
-</TabItem>
-</Tabs>

package/docs/building-with-livestore/production-checklist/index.md

@@ -1,5 +0,0 @@
-# Production checklist
-
-## Production checklist
-
-TBD

package/docs/building-with-livestore/reactivity-system/index.md

@@ -1,202 +0,0 @@
-# Reactivity system
-
-LiveStore has a high-performance, fine-grained reactivity system built in which is similar to Signals (e.g. in [SolidJS](https://docs.solidjs.com/concepts/signals)).
-
-## Defining reactive state
-
-LiveStore provides 3 types of reactive state:
-- Reactive SQL queries on top of SQLite state (`queryDb()`)
-- Reactive state values (`signal()`)
-- Reactive computed values (`computed()`)
-
-Reactive state variables end on a `$` by convention (e.g. `todos$`). The `label` option is optional but can be used to identify the reactive state variable in the devtools.
-
-### Reactive SQL queries
-
-## `reference/reactivity-system/query-db.ts`
-
-```ts filename="reference/reactivity-system/query-db.ts"
-/** biome-ignore-all lint/correctness/noUnusedVariables: docs snippet exposes intermediate streams */
-// ---cut---
-
-const tables = {
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean({ default: false }),
-      createdAt: State.SQLite.datetime(),
-    },
-  }),
-} as const
-
-const uiState$ = signal({ showCompleted: false }, { label: 'uiState$' })
-
-const todos$ = queryDb(tables.todos.orderBy('createdAt', 'desc'), { label: 'todos$' })
-
-{
-  const todos$ = queryDb(
-    (get) => {
-      const { showCompleted } = get(uiState$)
-      return tables.todos.where(showCompleted ? { completed: true } : {})
-    },
-    { label: 'todos$' },
-  )
-}
-```
-
-### Signals
-
-Signals are reactive state values that can be set and get. This can be useful for state that is not materialized from events into SQLite tables.
-
-## `reference/reactivity-system/signals.ts`
-
-```ts filename="reference/reactivity-system/signals.ts"
-
-declare const store: Store
-
-const now$ = signal(Date.now(), { label: 'now$' })
-
-setInterval(() => {
-  store.setSignal(now$, Date.now())
-}, 1000)
-
-const num$ = signal(0, { label: 'num$' })
-const increment = () => store.setSignal(num$, (prev) => prev + 1)
-
-increment()
-increment()
-
-console.log(store.query(num$))
-```
-
-### Computed values
-
-## `reference/reactivity-system/computed.ts`
-
-```ts filename="reference/reactivity-system/computed.ts"
-/** biome-ignore-all lint/correctness/noUnusedVariables: docs snippet highlights derived signal */
-// ---cut---
-
-const num$ = signal(0, { label: 'num$' })
-const duplicated$ = computed((get) => get(num$) * 2, { label: 'duplicated$' })
-```
-
-## Accessing reactive state
-
-Reactive state is always bound to a `Store` instance. You can access the current value of reactive state the following ways:
-
-### Using the `Store` instance
-
-## `reference/reactivity-system/store-access.ts`
-
-```ts filename="reference/reactivity-system/store-access.ts"
-
-declare const store: Store
-
-const tables = {
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      title: State.SQLite.text(),
-      completed: State.SQLite.boolean({ default: false }),
-    },
-  }),
-} as const
-
-const count$ = queryDb(tables.todos.count(), { label: 'count$' })
-const count = store.query(count$)
-console.log(count)
-
-const unsubscribe = store.subscribe(count$, (value) => {
-  console.log(value)
-})
-
-unsubscribe()
-```
-
-### Via framework integrations
-
-#### React
-
-## `reference/reactivity-system/react-component.tsx`
-
-```tsx filename="reference/reactivity-system/react-component.tsx"
-
-declare const state$: LiveQueryDef<number>
-
-export const MyComponent: FC = () => {
-  const value = useQuery(state$)
-
-  return <div>{value}</div>
-}
-```
-
-#### Solid
-
-## `reference/reactivity-system/solid-component.tsx`
-
-```tsx filename="reference/reactivity-system/solid-component.tsx"
-
-declare const state$: LiveQueryDef<number>
-
-export const MyComponent = () => {
-  const value = query(state$, 0)
-
-  return <div>{value()}</div>
-}
-```
-
-### Reacting to changing variables passed to queries
-
-If your query depends on a variable passed in by the component, use the deps array to react to changes in this variable.
-
-## `reference/reactivity-system/deps-query.tsx`
-
-```tsx filename="reference/reactivity-system/deps-query.tsx"
-
-const tables = {
-  todos: State.SQLite.table({
-    name: 'todos',
-    columns: {
-      id: State.SQLite.text({ primaryKey: true }),
-      text: State.SQLite.text(),
-      completed: State.SQLite.boolean({ default: false }),
-    },
-  }),
-} as const
-
-declare const store: Store & ReactApi
-
-export const todos$ = ({ showCompleted }: { showCompleted: boolean }) =>
-  queryDb(
-    () => {
-      return tables.todos.where(showCompleted ? { completed: true } : {})
-    },
-    {
-      label: 'todos$',
-      deps: [showCompleted ? 'true' : 'false'],
-    },
-  )
-
-export const MyComponent: FC<{ showCompleted: boolean }> = ({ showCompleted }) => {
-  const todos = store.useQuery(todos$({ showCompleted })) as ReadonlyArray<{
-    id: string
-    text: string
-    completed: boolean
-  }>
-
-  return <div>{todos.length} Done</div>
-}
-```
-
-## Further reading
-
-- [Riffle](https://riffle.systems/essays/prelude/): Building data-centric apps with a reactive relational database
-- [Adapton](http://adapton.org/) / [miniAdapton](https://arxiv.org/pdf/1609.05337)
-
-## Related technologies
-
-- [Signia](https://signia.tldraw.dev/): Signia is a minimal, fast, and scalable signals library for TypeScript developed by TLDraw.

package/docs/building-with-livestore/rules-for-ai-agents/index.md

@@ -1,9 +0,0 @@
-# Rules for AI agents
-
-## AGENTS.md
-
-Add the content of this `AGENTS.md` file or other custom rules:
-
-```md wrap
-- When you need to look up information about LiveStore, always use the `docs` directory that's shipped as part of the `@livestore/livestore` package in `node_modules/@livestore/livestore/docs`.
-```