vibe64 0.1.21

package/node_modules/json-rest-schema/src/index.js

@@ -0,0 +1,218 @@
+/**
+ * @file Main entry point for the schema library.
+ * Assembles and exports the `createSchema` factory function and related utilities.
+ */
+
+import { Schema } from './core/Schema.js'
+import CorePlugin from './core/CorePlugin.js'
+import { flattenErrors, getError, hasError, nestErrors } from './utils/error-helpers.js'
+import { setOwnProperty } from './utils/path-helpers.js'
+
+const factoryTypesBySource = new WeakMap()
+const factoryValidatorsBySource = new WeakMap()
+const registryMetadataSymbol = Symbol.for('json-rest-schema.registry-metadata')
+
+function registerTypeHandler (types, name, handler) {
+  if (typeof handler !== 'function') {
+    throw new Error(`Type handler for '${name}' must be a function.`)
+  }
+  setOwnProperty(types, name, handler)
+}
+
+function registerValidatorHandler (validators, name, handler) {
+  if (typeof handler !== 'function') {
+    throw new Error(`Validator handler for '${name}' must be a function.`)
+  }
+  setOwnProperty(validators, name, handler)
+}
+
+function createHandlerRegistry (source = {}) {
+  const registry = Object.create(null)
+
+  for (const [name, handler] of Object.entries(source)) {
+    setOwnProperty(registry, name, handler)
+  }
+
+  return registry
+}
+
+function installPlugin (plugin, api) {
+  if (typeof plugin.install !== 'function') {
+    throw new Error('Plugin must have an install method.')
+  }
+  plugin.install(api)
+}
+
+function attachRegistryMetadata (target, types, validators) {
+  factoryTypesBySource.set(target, types)
+  factoryValidatorsBySource.set(target, validators)
+
+  Object.defineProperty(target, registryMetadataSymbol, {
+    value: Object.freeze({
+      getTypes: () => types,
+      getValidators: () => validators
+    }),
+    enumerable: false,
+    configurable: false,
+    writable: false
+  })
+}
+
+function extractRegistryMetadata (source) {
+  if (!source || (typeof source !== 'object' && typeof source !== 'function')) {
+    return null
+  }
+
+  const types = factoryTypesBySource.get(source)
+  const validators = factoryValidatorsBySource.get(source)
+  if (types && validators) {
+    return { types, validators }
+  }
+
+  const symbolMetadata = source[registryMetadataSymbol]
+  if (
+    symbolMetadata &&
+    typeof symbolMetadata.getTypes === 'function' &&
+    typeof symbolMetadata.getValidators === 'function'
+  ) {
+    return {
+      types: symbolMetadata.getTypes(),
+      validators: symbolMetadata.getValidators()
+    }
+  }
+
+  if (
+    typeof source === 'object' &&
+    source.types &&
+    typeof source.types === 'object' &&
+    source.validators &&
+    typeof source.validators === 'object' &&
+    typeof source.create === 'function' &&
+    typeof source.replace === 'function' &&
+    typeof source.patch === 'function' &&
+    typeof source.toJsonSchema === 'function'
+  ) {
+    return {
+      types: source.types,
+      validators: source.validators
+    }
+  }
+
+  return null
+}
+
+function normalizeFactorySources (sources) {
+  if (sources.length === 1 && Array.isArray(sources[0])) {
+    return sources[0]
+  }
+
+  return sources
+}
+
+function areEquivalentHandlers (left, right) {
+  return left === right
+}
+
+function mergeRegistryHandlers (target, source, kind) {
+  for (const [name, handler] of Object.entries(source)) {
+    if (Object.hasOwn(target, name) && !areEquivalentHandlers(target[name], handler)) {
+      throw new Error(`Cannot merge schema factories with conflicting ${kind} "${name}".`)
+    }
+    setOwnProperty(target, name, handler)
+  }
+}
+
+function resolveMergedRegistries (fallbackTypes, fallbackValidators, sources) {
+  const normalizedSources = normalizeFactorySources(sources).filter(Boolean)
+  if (normalizedSources.length < 1) {
+    return {
+      types: createHandlerRegistry(fallbackTypes),
+      validators: createHandlerRegistry(fallbackValidators)
+    }
+  }
+
+  const mergedTypes = Object.create(null)
+  const mergedValidators = Object.create(null)
+  for (const source of normalizedSources) {
+    const metadata = extractRegistryMetadata(source)
+    if (!metadata) {
+      throw new Error('Factory sources must be schema instances or schema factories created by json-rest-schema.')
+    }
+
+    mergeRegistryHandlers(mergedTypes, metadata.types, 'type')
+    mergeRegistryHandlers(mergedValidators, metadata.validators, 'validator')
+  }
+
+  return {
+    types: mergedTypes,
+    validators: mergedValidators
+  }
+}
+
+function createSchemaFactory ({
+  types = {},
+  validators = {},
+  installCore = true
+} = {}) {
+  const factoryTypes = createHandlerRegistry(types)
+  const factoryValidators = createHandlerRegistry(validators)
+
+  const factory = (structure, options = {}) => {
+    const schema = new Schema(
+      structure,
+      factoryTypes,
+      factoryValidators,
+      options.operations
+    )
+    attachRegistryMetadata(schema, factoryTypes, factoryValidators)
+    return schema
+  }
+
+  attachRegistryMetadata(factory, factoryTypes, factoryValidators)
+
+  factory.addType = (name, handler) => {
+    registerTypeHandler(factoryTypes, name, handler)
+  }
+
+  factory.addValidator = (name, handler) => {
+    registerValidatorHandler(factoryValidators, name, handler)
+  }
+
+  factory.use = (plugin) => {
+    installPlugin(plugin, {
+      addType: factory.addType,
+      addValidator: factory.addValidator
+    })
+  }
+
+  factory.createFactory = (...sources) => {
+    const mergedRegistries = resolveMergedRegistries(factoryTypes, factoryValidators, sources)
+    return createSchemaFactory({
+      types: mergedRegistries.types,
+      validators: mergedRegistries.validators,
+      installCore: false
+    })
+  }
+
+  if (installCore) {
+    factory.use(CorePlugin)
+  }
+
+  return factory
+}
+
+const createSchema = createSchemaFactory({ installCore: true })
+
+function addType (name, handler) {
+  createSchema.addType(name, handler)
+}
+
+function addValidator (name, handler) {
+  createSchema.addValidator(name, handler)
+}
+
+function use (plugin) {
+  createSchema.use(plugin)
+}
+
+export { createSchema, createSchemaFactory, addType, addValidator, use, getError, hasError, nestErrors, flattenErrors }

package/node_modules/json-rest-schema/src/utils/adapter-helpers.js

@@ -0,0 +1,117 @@
+/**
+ * @file Shared helper utilities for UI adapter entry points.
+ */
+
+import { setOwnProperty } from './path-helpers.js'
+import { isPlainObject } from './object-helpers.js'
+
+export {
+  getNestedValue,
+  normalizeFieldPath,
+  pathToSegments,
+  setNestedValue,
+  uniqueNormalizedPaths
+} from './path-helpers.js'
+
+export { isPlainObject } from './object-helpers.js'
+
+function hasValueAccessor (value) {
+  let prototype = Object.getPrototypeOf(value)
+
+  while (prototype !== null && prototype !== Object.prototype) {
+    const descriptor = Object.getOwnPropertyDescriptor(prototype, 'value')
+    if (descriptor) {
+      return typeof descriptor.get === 'function' && typeof descriptor.set === 'function'
+    }
+
+    prototype = Object.getPrototypeOf(prototype)
+  }
+
+  return false
+}
+
+export function isRefLike (value) {
+  return value !== null &&
+    typeof value === 'object' &&
+    !Array.isArray(value) &&
+    (Object.hasOwn(value, 'value') || hasValueAccessor(value))
+}
+
+export function cloneValue (value) {
+  if (Array.isArray(value)) {
+    return value.map(item => cloneValue(item))
+  }
+
+  if (isPlainObject(value)) {
+    const clonedObject = {}
+
+    for (const [key, nestedValue] of Object.entries(value)) {
+      setOwnProperty(clonedObject, key, cloneValue(nestedValue))
+    }
+
+    return clonedObject
+  }
+
+  return value
+}
+
+export function readSourceValue (source) {
+  if (typeof source === 'function') {
+    return source()
+  }
+
+  if (isRefLike(source)) {
+    return source.value
+  }
+
+  return source
+}
+
+function syncArrayContainer (target, value) {
+  target.length = 0
+
+  if (!Array.isArray(value)) {
+    throw new Error('State container array cannot be replaced with a non-array value.')
+  }
+
+  for (const item of value) {
+    target.push(cloneValue(item))
+  }
+}
+
+function syncObjectContainer (target, value) {
+  if (!isPlainObject(value)) {
+    throw new Error('State container object cannot be replaced with a non-object value.')
+  }
+
+  for (const key of Object.keys(target)) {
+    delete target[key]
+  }
+
+  for (const [key, nestedValue] of Object.entries(value)) {
+    setOwnProperty(target, key, cloneValue(nestedValue))
+  }
+}
+
+export function replaceContainerValue (container, value) {
+  if (isRefLike(container)) {
+    container.value = cloneValue(value)
+    return
+  }
+
+  if (Array.isArray(container)) {
+    syncArrayContainer(container, value)
+    return
+  }
+
+  if (isPlainObject(container)) {
+    syncObjectContainer(container, value)
+    return
+  }
+
+  throw new Error('State container must be a ref-like object, array, or plain object.')
+}
+
+export function createStateBox (initialValue) {
+  return { value: cloneValue(initialValue) }
+}

package/node_modules/json-rest-schema/src/utils/error-helpers.js

@@ -0,0 +1,119 @@
+/**
+ * @file Small helper utilities for working with the flat dotted-path error map.
+ */
+
+import {
+  buildPathSegments,
+  isNumericSegment,
+  isObjectLike,
+  joinPath,
+  setOwnProperty
+} from './path-helpers.js'
+
+function isValidationErrorObject (value) {
+  return isObjectLike(value) &&
+    typeof value.field === 'string' &&
+    typeof value.code === 'string' &&
+    typeof value.message === 'string' &&
+    Object.hasOwn(value, 'params')
+}
+
+function flattenNestedErrorsInto (nestedValue, currentPath, flatErrors) {
+  if (!isObjectLike(nestedValue)) {
+    throw new Error(`flattenErrors() found an invalid nested error value at "${currentPath}".`)
+  }
+
+  if (isValidationErrorObject(nestedValue)) {
+    if (currentPath === '') {
+      throw new Error('flattenErrors() cannot flatten a root-level error object without a path.')
+    }
+
+    buildPathSegments(currentPath, 'flattenErrors')
+    setOwnProperty(flatErrors, currentPath, nestedValue)
+    return
+  }
+
+  const entries = Array.isArray(nestedValue)
+    ? Object.entries(nestedValue)
+    : Object.entries(nestedValue).sort(([left], [right]) => left.localeCompare(right))
+
+  for (const [segment, childValue] of entries) {
+    flattenNestedErrorsInto(childValue, joinPath(currentPath, segment), flatErrors)
+  }
+}
+
+/**
+ * Reads one error object from a flat dotted-path error map.
+ * @param {Object.<string, object>} errors
+ * @param {string} path
+ * @returns {object|undefined}
+ */
+export function getError (errors, path) {
+  buildPathSegments(path, 'getError')
+  if (!isObjectLike(errors)) return undefined
+  return Object.hasOwn(errors, path) ? errors[path] : undefined
+}
+
+/**
+ * Checks whether a flat dotted-path error map contains a specific path.
+ * @param {Object.<string, object>} errors
+ * @param {string} path
+ * @returns {boolean}
+ */
+export function hasError (errors, path) {
+  return getError(errors, path) !== undefined
+}
+
+/**
+ * Converts a flat dotted-path error map into a nested object/array structure.
+ * @param {Object.<string, object>} errors
+ * @returns {object}
+ */
+export function nestErrors (errors) {
+  if (!isObjectLike(errors)) return {}
+
+  const nestedErrors = {}
+
+  for (const [path, error] of Object.entries(errors)) {
+    const segments = buildPathSegments(path, 'nestErrors')
+    let currentNode = nestedErrors
+
+    for (let index = 0; index < segments.length; index++) {
+      const segment = segments[index]
+      const isLast = index === segments.length - 1
+
+      if (isLast) {
+        setOwnProperty(currentNode, segment, error)
+        continue
+      }
+
+      const hasExistingNode = Object.hasOwn(currentNode, segment)
+      const existingNode = hasExistingNode ? currentNode[segment] : undefined
+      if (hasExistingNode && (!isObjectLike(existingNode) || isValidationErrorObject(existingNode))) {
+        throw new Error(`nestErrors() cannot nest conflicting path "${path}".`)
+      }
+
+      if (!hasExistingNode) {
+        const nextSegment = segments[index + 1]
+        setOwnProperty(currentNode, segment, isNumericSegment(nextSegment) ? [] : {})
+      }
+
+      currentNode = currentNode[segment]
+    }
+  }
+
+  return nestedErrors
+}
+
+/**
+ * Converts a nested object/array error structure into the flat dotted-path map.
+ * @param {object} nestedErrors
+ * @returns {Object.<string, object>}
+ */
+export function flattenErrors (nestedErrors) {
+  if (!isObjectLike(nestedErrors)) return {}
+
+  const flatErrors = {}
+  flattenNestedErrorsInto(nestedErrors, '', flatErrors)
+  return flatErrors
+}

package/node_modules/json-rest-schema/src/utils/object-helpers.js

@@ -0,0 +1,23 @@
+/**
+ * @file Shared object-shape helpers.
+ */
+
+export function isPlainObject (value) {
+  if (value === null || typeof value !== 'object') return false
+
+  const prototype = Object.getPrototypeOf(value)
+  return (
+    prototype === Object.prototype ||
+    prototype === null ||
+    isEmptyNullPrototypeRecord(prototype)
+  )
+}
+
+function isEmptyNullPrototypeRecord (value) {
+  return (
+    value !== null &&
+    typeof value === 'object' &&
+    Object.getPrototypeOf(value) === null &&
+    Reflect.ownKeys(value).length === 0
+  )
+}

package/node_modules/json-rest-schema/src/utils/path-helpers.js

@@ -0,0 +1,118 @@
+/**
+ * @file Shared dotted-path helpers for schema errors and UI adapters.
+ */
+
+const UNSAFE_PATH_SEGMENTS = new Set(['__proto__', 'prototype', 'constructor'])
+
+export function isObjectLike (value) {
+  return value !== null && typeof value === 'object'
+}
+
+export function isNumericSegment (segment) {
+  return /^[0-9]+$/.test(segment)
+}
+
+export function setOwnProperty (target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  })
+}
+
+function assertSafePathSegment (segment, helperName) {
+  if (UNSAFE_PATH_SEGMENTS.has(segment)) {
+    throw new Error(`${helperName}() received unsafe path segment "${segment}".`)
+  }
+}
+
+export function normalizeFieldPath (path) {
+  if (typeof path !== 'string') return path
+
+  return path
+    .replace(/\[(.+?)\]/g, '.$1')
+    .replace(/^\.+/, '')
+    .replace(/\.+/g, '.')
+    .replace(/\.$/, '')
+}
+
+export function buildPathSegments (path, helperName, { normalize = false, allowEmpty = false } = {}) {
+  const normalizedPath = normalize ? normalizeFieldPath(path) : path
+
+  if (typeof normalizedPath !== 'string' || normalizedPath.trim() === '') {
+    if (allowEmpty && normalizedPath === '') return []
+    throw new Error(`${helperName}() expects a non-empty dotted path string.`)
+  }
+
+  const segments = normalizedPath.split('.')
+  if (segments.some(segment => segment === '')) {
+    throw new Error(`${helperName}() received an invalid path "${normalizedPath}".`)
+  }
+
+  for (const segment of segments) {
+    assertSafePathSegment(segment, helperName)
+  }
+
+  return segments
+}
+
+export function joinPath (basePath, pathSegment) {
+  return basePath === '' ? String(pathSegment) : `${basePath}.${String(pathSegment)}`
+}
+
+export function uniqueNormalizedPaths (paths = []) {
+  return [...new Set(
+    paths
+      .map(path => normalizeFieldPath(path))
+      .filter(path => typeof path === 'string' && path !== '')
+      .map(path => buildPathSegments(path, 'normalizeFieldPath').join('.'))
+  )]
+}
+
+export function pathToSegments (path) {
+  return buildPathSegments(path, 'pathToSegments', { normalize: true, allowEmpty: true })
+    .map(segment => (isNumericSegment(segment) ? Number(segment) : segment))
+}
+
+function createContainer (nextSegment) {
+  return isNumericSegment(nextSegment) ? [] : {}
+}
+
+export function getNestedValue (target, path) {
+  const segments = buildPathSegments(path, 'getNestedValue', { normalize: true, allowEmpty: true })
+
+  if (segments.length === 0) return target
+
+  let currentNode = target
+
+  for (const segment of segments) {
+    if (currentNode === null || currentNode === undefined) return undefined
+    if (!isObjectLike(currentNode)) return undefined
+    if (!Object.hasOwn(currentNode, segment)) return undefined
+    currentNode = currentNode[segment]
+  }
+
+  return currentNode
+}
+
+export function setNestedValue (target, path, value) {
+  const segments = buildPathSegments(path, 'setNestedValue', { normalize: true })
+  let currentNode = target
+
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index]
+    const isLast = index === segments.length - 1
+
+    if (isLast) {
+      setOwnProperty(currentNode, segment, value)
+      return
+    }
+
+    if (!Object.hasOwn(currentNode, segment) || currentNode[segment] === null || !isObjectLike(currentNode[segment])) {
+      setOwnProperty(currentNode, segment, createContainer(segments[index + 1]))
+    }
+
+    currentNode = currentNode[segment]
+  }
+}

package/node_modules/node-addon-api/LICENSE.md

@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 [Node.js API collaborators](https://github.com/nodejs/node-addon-api#collaborators)
+
+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.