@aurabase/aurabase-js 0.3.0 → 0.4.0

package/packages/realtime/tests/dispatch.test.ts

@@ -1,191 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { RealtimeService } from '../src/RealtimeService'
-import { AuraChannel } from '../src/AuraChannel'
-import { BaseAuthStore } from '@aurabase/core'
-import type { AuraClientLike } from '@aurabase/core'
-
-function client(): AuraClientLike {
-  return {
-    baseUrl: 'http://x',
-    projectId: 'proj',
-    apiKey: 'k',
-    authStore: new BaseAuthStore(),
-    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
-  }
-}
-
-describe('RealtimeService._dispatch — routage CDC borné par ":"', () => {
-  it('un event de `room2` ne fuite pas vers le channel `room` (préfixe)', () => {
-    const rt = new RealtimeService(client())
-    const room = new AuraChannel('room', 'proj')
-    const room2 = new AuraChannel('room2', 'proj')
-    // Insère `room` en PREMIER (l'ancien startsWith non borné l'aurait fait matcher d'abord).
-    const map = (rt as unknown as { _channels: Map<string, AuraChannel> })._channels
-    map.set('room', room)
-    map.set('room2', room2)
-    const spyRoom = vi.spyOn(room, '_onMessage').mockImplementation(() => {})
-    const spyRoom2 = vi.spyOn(room2, '_onMessage').mockImplementation(() => {})
-
-    // Message CDC : topic composite `proj:room2:public.x` (pas de channel exact de ce nom).
-    ;(rt as unknown as { _dispatch: (m: unknown) => void })._dispatch({
-      type: 'event',
-      id: '1',
-      event: 'insert',
-      topic: 'proj:room2:public.x',
-      payload: {},
-      timestamp: '',
-    })
-
-    expect(spyRoom2).toHaveBeenCalledTimes(1)
-    expect(spyRoom).not.toHaveBeenCalled()
-  })
-})
-
-describe('AuraChannel._dispatchEvent — fallback client filtre colonne (second rideau)', () => {
-  it("un event dont le record ne matche pas `filter` n'atteint pas le callback", () => {
-    const channel = new AuraChannel('room', 'proj')
-    const cb = vi.fn()
-    channel.on(
-      'postgres_changes',
-      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
-      cb,
-    )
-
-    channel._onMessage({
-      type: 'event',
-      id: '1',
-      event: 'insert',
-      topic: 'proj:room:public.messages',
-      payload: {
-        schema: 'public',
-        table: 'messages',
-        type: 'INSERT',
-        record: { room_id: 7 },
-        old_record: null,
-      },
-      timestamp: '',
-    })
-
-    expect(cb).not.toHaveBeenCalled()
-  })
-
-  it('un event dont le record matche `filter` atteint le callback', () => {
-    const channel = new AuraChannel('room', 'proj')
-    const cb = vi.fn()
-    channel.on(
-      'postgres_changes',
-      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
-      cb,
-    )
-
-    channel._onMessage({
-      type: 'event',
-      id: '2',
-      event: 'insert',
-      topic: 'proj:room:public.messages',
-      payload: {
-        schema: 'public',
-        table: 'messages',
-        type: 'INSERT',
-        record: { room_id: 42 },
-        old_record: null,
-      },
-      timestamp: '',
-    })
-
-    expect(cb).toHaveBeenCalledTimes(1)
-  })
-
-  it('DELETE : le filtre est évalué sur old_record (record CDC vide)', () => {
-    const channel = new AuraChannel('room', 'proj')
-    const matched = vi.fn()
-    const notMatched = vi.fn()
-    channel.on(
-      'postgres_changes',
-      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
-      matched,
-    )
-
-    channel._onMessage({
-      type: 'event',
-      id: '3',
-      event: 'delete',
-      topic: 'proj:room:public.messages',
-      payload: {
-        schema: 'public',
-        table: 'messages',
-        type: 'DELETE',
-        record: {},
-        old_record: { room_id: 42 },
-      },
-      timestamp: '',
-    })
-    expect(matched).toHaveBeenCalledTimes(1)
-
-    channel.on(
-      'postgres_changes',
-      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
-      notMatched,
-    )
-    channel._onMessage({
-      type: 'event',
-      id: '4',
-      event: 'delete',
-      topic: 'proj:room:public.messages',
-      payload: {
-        schema: 'public',
-        table: 'messages',
-        type: 'DELETE',
-        record: {},
-        old_record: { room_id: 7 },
-      },
-      timestamp: '',
-    })
-    expect(notMatched).not.toHaveBeenCalled()
-  })
-
-  it('cible absente/non-objet => ne filtre pas (le serveur a déjà filtré, pas de faux négatif)', () => {
-    const channel = new AuraChannel('room', 'proj')
-    const cb = vi.fn()
-    channel.on(
-      'postgres_changes',
-      { event: '*', schema: 'public', table: 'messages', filter: 'room_id=eq.42' },
-      cb,
-    )
-
-    channel._onMessage({
-      type: 'event',
-      id: '5',
-      event: 'insert',
-      topic: 'proj:room:public.messages',
-      payload: {
-        schema: 'public',
-        table: 'messages',
-        type: 'INSERT',
-        // pas de champ `record` du tout
-      },
-      timestamp: '',
-    })
-
-    expect(cb).toHaveBeenCalledTimes(1)
-  })
-
-  it('filtre absent (non défini) => pas de fallback appliqué, event livré normalement', () => {
-    const channel = new AuraChannel('room', 'proj')
-    const cb = vi.fn()
-    channel.on('postgres_changes', { event: '*', schema: 'public', table: 'messages' }, cb)
-
-    channel._onMessage({
-      type: 'event',
-      id: '6',
-      event: 'insert',
-      topic: 'proj:room:public.messages',
-      payload: { schema: 'public', table: 'messages', type: 'INSERT', record: { room_id: 999 } },
-      timestamp: '',
-    })
-
-    expect(cb).toHaveBeenCalledTimes(1)
-  })
-})

package/packages/realtime/tests/heartbeat.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect, vi, afterEach, beforeEach } from 'vitest'
-import { HeartbeatManager } from '../src/HeartbeatManager'
-
-class FakeWorker {
-  static instances: FakeWorker[] = []
-  onmessage: ((e: unknown) => void) | null = null
-  posted: unknown[] = []
-  terminated = false
-  constructor(public url: string) {
-    FakeWorker.instances.push(this)
-  }
-  postMessage(d: unknown) {
-    this.posted.push(d)
-  }
-  terminate() {
-    this.terminated = true
-  }
-}
-
-const g = globalThis as unknown as Record<string, unknown>
-let revoke: ReturnType<typeof vi.fn>
-
-beforeEach(() => {
-  FakeWorker.instances = []
-  revoke = vi.fn()
-  g.Worker = FakeWorker
-  g.URL = { createObjectURL: vi.fn(() => 'blob:x'), revokeObjectURL: revoke }
-})
-afterEach(() => {
-  vi.useRealTimers()
-  delete g.Worker
-  delete g.URL
-})
-
-describe('HeartbeatManager — Worker dédié', () => {
-  it('start() crée un Worker, ping au message worker, URL non révoquée avant stop', () => {
-    const hm = new HeartbeatManager()
-    const ping = vi.fn()
-    hm.start(ping, 25000)
-    expect(FakeWorker.instances.length).toBe(1)
-    expect(revoke).not.toHaveBeenCalled()
-    FakeWorker.instances[0].onmessage!({})
-    expect(ping).toHaveBeenCalledTimes(1)
-  })
-
-  it('stop() termine le worker et révoque l’URL', () => {
-    const hm = new HeartbeatManager()
-    hm.start(vi.fn())
-    hm.stop()
-    expect(FakeWorker.instances[0].terminated).toBe(true)
-    expect(revoke).toHaveBeenCalledWith('blob:x')
-    expect(hm.isActive).toBe(false)
-  })
-
-  it('sans Worker → fallback setInterval', () => {
-    delete g.Worker
-    vi.useFakeTimers()
-    const hm = new HeartbeatManager()
-    const ping = vi.fn()
-    hm.start(ping, 1000)
-    vi.advanceTimersByTime(1000)
-    expect(ping).toHaveBeenCalledTimes(1)
-    hm.stop()
-    vi.advanceTimersByTime(2000)
-    expect(ping).toHaveBeenCalledTimes(1)
-  })
-})

package/packages/realtime/tests/http-broadcast.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { RealtimeService } from '../src/RealtimeService'
-import { BaseAuthStore } from '@aurabase/core'
-import type { AuraClientLike } from '@aurabase/core'
-
-type Captured = { url: string; init: RequestInit }
-
-function clientWithSpy(): { client: AuraClientLike; calls: Captured[] } {
-  const calls: Captured[] = []
-  const fetchFn = (async (url: string, init: RequestInit) => {
-    calls.push({ url, init })
-    return new Response(JSON.stringify({ data: null, meta: null }), {
-      status: 200,
-      headers: { 'content-type': 'application/json' },
-    })
-  }) as unknown as typeof globalThis.fetch
-  const store = new BaseAuthStore()
-  return {
-    calls,
-    client: {
-      baseUrl: 'http://x',
-      projectId: 'proj',
-      apiKey: 'k',
-      authStore: store,
-      fetchFn,
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      auth: { refreshSession: async () => ({ data: null, error: null }) as any },
-    },
-  }
-}
-
-describe('RealtimeService.httpBroadcast — envoi REST hors WebSocket', () => {
-  it('POST /v1/realtime/{projectId}/broadcast avec corps { channel, payload:{event,...} } + apikey', async () => {
-    const { client, calls } = clientWithSpy()
-    const rt = new RealtimeService(client)
-
-    const res = await rt.httpBroadcast('room-1', 'ping', { a: 1 })
-
-    expect(res.error).toBeNull()
-    expect(calls).toHaveLength(1)
-    const { url, init } = calls[0]!
-    expect(url).toBe('http://x/v1/realtime/proj/broadcast')
-    expect(init.method).toBe('POST')
-    expect(JSON.parse(init.body as string)).toEqual({
-      channel: 'proj:room-1',
-      payload: { event: 'ping', a: 1 },
-    })
-    expect((init.headers as Record<string, string>)['apikey']).toBe('k')
-  })
-
-  it("ne préfixe pas deux fois un canal déjà préfixé par le projet", async () => {
-    const { client, calls } = clientWithSpy()
-    const rt = new RealtimeService(client)
-
-    await rt.httpBroadcast('proj:room-x', 'evt', {})
-
-    expect(JSON.parse(calls[0]!.init.body as string).channel).toBe('proj:room-x')
-  })
-
-  it("n'ouvre aucune connexion WebSocket", async () => {
-    const { client } = clientWithSpy()
-    const rt = new RealtimeService(client)
-
-    await rt.httpBroadcast('room-1', 'ping', {})
-
-    expect(rt.connectionState).toBe('disconnected')
-  })
-})

package/packages/realtime/tests/realtime-token.test.ts

@@ -1,43 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { RealtimeService } from '../src/RealtimeService'
-import { BaseAuthStore } from '@aurabase/core'
-import type { AuraClientLike } from '@aurabase/core'
-
-function makeClient(): AuraClientLike {
-  return {
-    baseUrl: 'http://x',
-    projectId: 'p',
-    apiKey: 'k',
-    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
-    authStore: new BaseAuthStore(), // vide → _scheduleTokenRefresh no-op
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
-  }
-}
-
-describe('RealtimeService — propagation token différentielle', () => {
-  it('ne renvoie pas un token identique, renvoie un token changé', () => {
-    const rt = new RealtimeService(makeClient())
-    const send = vi
-      .spyOn(rt as unknown as { _send: (d: string) => void }, '_send')
-      .mockImplementation(() => {})
-    rt.refreshToken('t1')
-    expect(send).toHaveBeenCalledTimes(1)
-    rt.refreshToken('t1')
-    expect(send).toHaveBeenCalledTimes(1) // identique → pas renvoyé
-    rt.refreshToken('t2')
-    expect(send).toHaveBeenCalledTimes(2)
-  })
-
-  it('disconnect() réarme la propagation (renvoie le token après reconnexion)', () => {
-    const rt = new RealtimeService(makeClient())
-    const send = vi
-      .spyOn(rt as unknown as { _send: (d: string) => void }, '_send')
-      .mockImplementation(() => {})
-    rt.refreshToken('t1')
-    expect(send).toHaveBeenCalledTimes(1)
-    rt.disconnect()
-    rt.refreshToken('t1')
-    expect(send).toHaveBeenCalledTimes(2) // _lastSentToken reset → renvoyé
-  })
-})

package/packages/realtime/tests/reconnect-race.test.ts

@@ -1,149 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { RealtimeService } from '../src/RealtimeService'
-import { BaseAuthStore } from '@aurabase/core'
-import type { AuraClientLike } from '@aurabase/core'
-
-/**
- * Faux WebSocket contrôlable : les transitions (open/close) sont déclenchées
- * manuellement pour reproduire de façon déterministe la race « stale onclose »
- * (un ancien socket dont le onclose se déclenche APRÈS qu'un nouveau socket a
- * été créé).
- */
-class FakeWebSocket {
-  static readonly CONNECTING = 0
-  static readonly OPEN = 1
-  static readonly CLOSING = 2
-  static readonly CLOSED = 3
-  static instances: FakeWebSocket[] = []
-
-  url: string
-  readyState: number = FakeWebSocket.CONNECTING
-  onopen: (() => void) | null = null
-  onmessage: ((evt: { data: string }) => void) | null = null
-  onclose: (() => void) | null = null
-  onerror: ((evt: unknown) => void) | null = null
-  sent: string[] = []
-
-  constructor(url: string) {
-    this.url = url
-    FakeWebSocket.instances.push(this)
-  }
-
-  send(data: string): void {
-    this.sent.push(data)
-  }
-
-  close(): void {
-    this.readyState = FakeWebSocket.CLOSING
-  }
-
-  // ─── Helpers de test ───
-  fireOpen(): void {
-    this.readyState = FakeWebSocket.OPEN
-    this.onopen?.()
-  }
-
-  fireClose(): void {
-    this.readyState = FakeWebSocket.CLOSED
-    this.onclose?.()
-  }
-}
-
-function client(): AuraClientLike {
-  return {
-    baseUrl: 'http://x',
-    projectId: 'proj',
-    apiKey: 'k',
-    authStore: new BaseAuthStore(),
-    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
-  }
-}
-
-describe('RealtimeService — race « stale onclose »', () => {
-  beforeEach(() => {
-    vi.useFakeTimers()
-    FakeWebSocket.instances = []
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ;(globalThis as any).WebSocket = FakeWebSocket
-  })
-
-  afterEach(() => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    delete (globalThis as any).WebSocket
-    vi.useRealTimers()
-    vi.restoreAllMocks()
-  })
-
-  it("le onclose tardif d'un ancien socket n'écrase PAS la connexion courante", () => {
-    const rt = new RealtimeService(client())
-    rt.setAutoReconnect(false) // isole le test du scheduler de reconnexion
-
-    rt.connect()
-    const ws1 = FakeWebSocket.instances[0]
-    ws1.fireOpen()
-    expect(rt.connectionState).toBe('connected')
-
-    // Déconnexion intentionnelle : ferme ws1, mais son onclose est différé.
-    rt.disconnect()
-    expect(rt.connectionState).toBe('disconnected')
-
-    // Une nouvelle connexion est établie AVANT que le onclose de ws1 n'arrive.
-    rt.connect()
-    const ws2 = FakeWebSocket.instances[1]
-    expect(ws2).toBeDefined()
-    ws2.fireOpen()
-    expect(rt.connectionState).toBe('connected')
-
-    // Le onclose TARDIF de l'ancien socket se déclenche maintenant.
-    ws1.fireClose()
-
-    // Il ne doit ni annuler l'état 'connected', ni détacher le nouveau socket.
-    expect(rt.connectionState).toBe('connected')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((rt as any)._ws).toBe(ws2)
-  })
-
-  it('un socket périmé qui s\'ouvre tardivement est fermé et n\'active rien', () => {
-    const rt = new RealtimeService(client())
-    rt.setAutoReconnect(false)
-
-    rt.connect()
-    const ws1 = FakeWebSocket.instances[0]
-
-    // Avant que ws1 ne s'ouvre, on repart sur une nouvelle connexion.
-    rt.disconnect()
-    rt.connect()
-    const ws2 = FakeWebSocket.instances[1]
-    ws2.fireOpen()
-    expect(rt.connectionState).toBe('connected')
-
-    // ws1 (périmé) s'ouvre tardivement : doit être fermé, sans toucher l'état.
-    const closeSpy = vi.spyOn(ws1, 'close')
-    ws1.fireOpen()
-    expect(closeSpy).toHaveBeenCalled()
-    expect(rt.connectionState).toBe('connected')
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    expect((rt as any)._ws).toBe(ws2)
-  })
-
-  it('après disconnect+reconnect, une coupure inattendue reconnecte bien (flag _intentionalClose non bloqué)', () => {
-    const rt = new RealtimeService(client())
-
-    rt.connect()
-    const ws1 = FakeWebSocket.instances[0]
-    ws1.fireOpen()
-
-    rt.disconnect() // pose _intentionalClose = true
-    rt.connect() // doit remettre le flag à false
-    const ws2 = FakeWebSocket.instances[1]
-    ws2.fireOpen()
-    expect(rt.connectionState).toBe('connected')
-
-    // Coupure inattendue de ws2 : doit repasser en 'reconnecting'
-    // (et non rester 'disconnected' à cause d'un flag resté à true).
-    ws2.fireClose()
-    expect(rt.connectionState).toBe('reconnecting')
-  })
-})

package/packages/realtime/tests/ref-id.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest'
-import { AuraChannel } from '../src/AuraChannel'
-
-afterEach(() => vi.useRealTimers())
-
-describe('AuraChannel — ref_id global-unique', () => {
-  it('deux channels produisent des refs distincts préfixés par fullName', () => {
-    vi.useFakeTimers()
-    const a = new AuraChannel('a', 'p', { broadcast: { ack: true } })
-    const b = new AuraChannel('b', 'p', { broadcast: { ack: true } })
-    const sentA: Array<Record<string, unknown>> = []
-    const sentB: Array<Record<string, unknown>> = []
-    a._bindSend((d) => sentA.push(JSON.parse(d)))
-    b._bindSend((d) => sentB.push(JSON.parse(d)))
-
-    const pa = a.send({ type: 'broadcast', event: 'e', payload: {} })
-    const pb = b.send({ type: 'broadcast', event: 'e', payload: {} })
-
-    const rA = sentA[0].ref_id as string
-    const rB = sentB[0].ref_id as string
-    expect(rA).not.toBe(rB)
-    expect(rA.startsWith('p:a:')).toBe(true)
-    expect(rB.startsWith('p:b:')).toBe(true)
-
-    // broadcast_ack du ref de A → seul A résout ; le pending de B reste
-    a._onMessage({ type: 'broadcast_ack', ref_id: rA } as never)
-    return Promise.resolve().then(async () => {
-      await expect(pa).resolves.toBe('ok')
-      expect((b as unknown as { _pendingAcks: Map<string, unknown> })._pendingAcks.has(rB)).toBe(true)
-      vi.advanceTimersByTime(5000) // laisse pb timeout (nettoyage)
-      await expect(pb).resolves.toBe('timeout')
-    })
-  })
-})

package/packages/realtime/tests/set-auth.test.ts

@@ -1,70 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { RealtimeService } from '../src/RealtimeService'
-import { BaseAuthStore } from '@aurabase/core'
-import type { AuraClientLike } from '@aurabase/core'
-
-function makeClient(store = new BaseAuthStore()): AuraClientLike {
-  return {
-    baseUrl: 'http://x',
-    projectId: 'p',
-    apiKey: 'k',
-    fetchFn: (async () => new Response('{}')) as unknown as typeof globalThis.fetch,
-    authStore: store,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    auth: { refreshSession: async () => ({ data: null, error: null }) as any },
-  }
-}
-
-function spySend(rt: RealtimeService) {
-  return vi
-    .spyOn(rt as unknown as { _send: (d: string) => void }, '_send')
-    .mockImplementation(() => {})
-}
-
-describe('RealtimeService.setAuth — parité Supabase', () => {
-  it("setAuth(token) pousse un seul { type:'access_token', token } (dédupliqué)", () => {
-    const rt = new RealtimeService(makeClient())
-    const send = spySend(rt)
-
-    rt.setAuth('tok')
-    expect(send).toHaveBeenCalledTimes(1)
-    expect(JSON.parse(send.mock.calls[0]![0] as string)).toEqual({
-      type: 'access_token',
-      token: 'tok',
-    })
-
-    // Second appel identique → pas de renvoi (déduplication _lastSentToken).
-    rt.setAuth('tok')
-    expect(send).toHaveBeenCalledTimes(1)
-  })
-
-  it('setAuth() sans argument reprend client.authStore.token', () => {
-    const store = new BaseAuthStore()
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    store.save('from-store', 'r', {} as any)
-    const rt = new RealtimeService(makeClient(store))
-    const send = spySend(rt)
-
-    rt.setAuth()
-
-    expect(send).toHaveBeenCalledTimes(1)
-    expect(JSON.parse(send.mock.calls[0]![0] as string)).toEqual({
-      type: 'access_token',
-      token: 'from-store',
-    })
-  })
-
-  it("setAuth() no-op si aucun token disponible", () => {
-    const rt = new RealtimeService(makeClient())
-    const send = spySend(rt)
-    rt.setAuth()
-    expect(send).not.toHaveBeenCalled()
-  })
-
-  it('ne provoque aucune reconnexion WS', () => {
-    const rt = new RealtimeService(makeClient())
-    spySend(rt)
-    rt.setAuth('tok')
-    expect(rt.connectionState).toBe('disconnected')
-  })
-})

package/packages/realtime/tsconfig.json

@@ -1,5 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": { "outDir": "dist", "rootDir": "src" },
-  "include": ["src"]
-}

package/packages/realtime/tsup.config.ts

@@ -1,11 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  dts: true,
-  splitting: false,
-  clean: true,
-  treeshake: true,
-  minify: false,
-})

package/packages/storage/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Aurabase
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.