Implement table/inline packages

.changeset/sweet-buttons-argue.md

@@ -0,0 +1,16 @@
+---
+"@dpkit/camtrap": minor
+"@dpkit/datahub": minor
+"@dpkit/folder": minor
+"@dpkit/github": minor
+"@dpkit/inline": minor
+"@dpkit/zenodo": minor
+"dpkit": minor
+"@dpkit/table": minor
+"@dpkit/ckan": minor
+"@dpkit/core": minor
+"@dpkit/file": minor
+"@dpkit/zip": minor
+---
+
+Implemented table/inline packages

.gitignore

@@ -43,6 +43,9 @@ pids
 # Storybook
 *storybook.log
 
+# Notebooks
+.ipynb_checkpoints/
+
 # React
 .react-router/
 

CLAUDE.md

@@ -21,5 +21,3 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 - **Comments:** You are forbiddedn to write `//` comments in the code
 - **Todos:** If you asked to resolve TODO, follow the instructions literally
 - **Linting:** Don't run linting as a part of your tasks
-- **Functions:** Use one prope argument in functions instead of positional arguments
-

biome.jsonc

@@ -31,6 +31,9 @@
       "correctness": {
         "useExhaustiveDependencies": "off"
       },
+      "performance": {
+        "noDelete": "off"
+      },
       "security": {
         "noDangerouslySetInnerHtml": "off"
       },

camtrap/package/assert.ts

@@ -10,10 +10,10 @@ const SUPPORTED_PROFILES = [
 /**
  * Assert a Package descriptor (JSON Object) against its profile
  */
-export async function assertCamtrapPackage(props: {
-  descriptor: Descriptor | Package
-}) {
-  const descriptor = props.descriptor as Descriptor
+export async function assertCamtrapPackage(
+  descriptorOrPackage: Descriptor | Package,
+) {
+  const descriptor = descriptorOrPackage as Descriptor
 
   const isCamtrap =
     typeof descriptor.$schema === "string" &&
@@ -23,10 +23,8 @@ export async function assertCamtrapPackage(props: {
     throw new Error(`Unsupported Camtrap profile "${descriptor.$schema}"`)
   }
 
-  const { errors, datapackage } = await validatePackageDescriptor({
-    descriptor,
-  })
+  const { errors, dataPackage } = await validatePackageDescriptor(descriptor)
 
-  if (!datapackage) throw new AssertionError(errors)
-  return datapackage as CamtrapPackage
+  if (!dataPackage) throw new AssertionError(errors)
+  return dataPackage as CamtrapPackage
 }

ckan/general/request.ts

@@ -1,6 +1,6 @@
 import type { Descriptor } from "@dpkit/core"
 
-export async function makeCkanApiRequest<T = Descriptor>(props: {
+export async function makeCkanApiRequest<T = Descriptor>(options: {
   ckanUrl: string
   action: string
   payload: Descriptor
@@ -10,22 +10,22 @@ export async function makeCkanApiRequest<T = Descriptor>(props: {
   let body: string | FormData
   const headers: Record<string, any> = {}
 
-  const url = new URL(props.ckanUrl)
-  url.pathname = `/api/3/action/${props.action}`
+  const url = new URL(options.ckanUrl)
+  url.pathname = `/api/3/action/${options.action}`
 
-  if (props.apiKey) {
-    headers.Authorization = props.apiKey
+  if (options.apiKey) {
+    headers.Authorization = options.apiKey
   }
 
-  if (props.upload) {
+  if (options.upload) {
     body = new FormData()
-    body.append("upload", props.upload.data, props.upload.name)
+    body.append("upload", options.upload.data, options.upload.name)
 
-    for (const [key, value] of Object.entries(props.payload)) {
+    for (const [key, value] of Object.entries(options.payload)) {
       body.append(key, value)
     }
   } else {
-    body = JSON.stringify(props.payload)
+    body = JSON.stringify(options.payload)
     headers["Content-Type"] = "application/json"
   }
 

ckan/package/load.spec.ts

@@ -6,11 +6,10 @@ describe("loadPackageFromCkan", () => {
   useRecording()
 
   it("should load a package", async () => {
-    const datapackage = await loadPackageFromCkan({
-      datasetUrl:
-        "https://data.nhm.ac.uk/dataset/join-the-dots-collection-level-descriptions",
-    })
+    const dataPackage = await loadPackageFromCkan(
+      "https://data.nhm.ac.uk/dataset/join-the-dots-collection-level-descriptions",
+    )
 
-    expect(datapackage).toMatchSnapshot()
+    expect(dataPackage).toMatchSnapshot()
   })
 })

ckan/package/load.ts

@@ -8,12 +8,8 @@ import { normalizeCkanPackage } from "./process/normalize.js"
  * @param props Object containing the URL to the CKAN package
  * @returns Package object and cleanup function
  */
-export async function loadPackageFromCkan(props: {
-  datasetUrl: string
-}) {
-  const { datasetUrl } = props
-
-  const packageId = extractPackageId({ datasetUrl })
+export async function loadPackageFromCkan(datasetUrl: string) {
+  const packageId = extractPackageId(datasetUrl)
   if (!packageId) {
     throw new Error(`Failed to extract package ID from URL: ${datasetUrl}`)
   }
@@ -34,7 +30,7 @@ export async function loadPackageFromCkan(props: {
     }
   }
 
-  const systemPackage = normalizeCkanPackage({ ckanPackage })
+  const systemPackage = normalizeCkanPackage(ckanPackage)
   const userPackagePath = systemPackage.resources
     .filter(resource => resource["ckan:key"] === "datapackage.json")
     .map(resource => resource["ckan:url"])
@@ -58,28 +54,26 @@ export async function loadPackageFromCkan(props: {
  * - https://open.africa/dataset/pib-annual-senegal
  * - https://data.nhm.ac.uk/dataset/join-the-dots-collection-level-descriptions
  */
-function extractPackageId(props: { datasetUrl: string }) {
-  const url = new URL(props.datasetUrl)
+function extractPackageId(datasetUrl: string) {
+  const url = new URL(datasetUrl)
   const pathParts = url.pathname.split("/").filter(Boolean)
   return pathParts.at(-1)
 }
 
 /**
  * Fetch resource schema data from CKAN datastore
  */
-async function loadCkanSchema(props: {
+async function loadCkanSchema(options: {
   datasetUrl: string
   resourceId: string
 }) {
-  const { datasetUrl, resourceId } = props
-
   try {
     // For some reason, datastore_info doesn't work
     // So we use data fetching endpoint that also returns the schema
     const result = await makeCkanApiRequest({
-      ckanUrl: datasetUrl,
+      ckanUrl: options.datasetUrl,
       action: "datastore_search",
-      payload: { resource_id: resourceId, limit: 0 },
+      payload: { resource_id: options.resourceId, limit: 0 },
     })
 
     // @ts-ignore

ckan/package/process/denormalize.spec.ts

@@ -10,7 +10,7 @@ import { normalizeCkanPackage } from "./normalize.js"
 describe("denormalizeCkanPackage", () => {
   it("denormalizes a Frictionless Data Package to a CKAN package", () => {
     // Arrange
-    const datapackage: Package = {
+    const dataPackage: Package = {
       name: "test-package",
       title: "Test Package",
       description: "This is a test package",
@@ -50,32 +50,32 @@ describe("denormalizeCkanPackage", () => {
     }
 
     // Act
-    const result = denormalizeCkanPackage({ datapackage })
+    const result = denormalizeCkanPackage(dataPackage)
 
     // Assert
     // Basic metadata
-    expect(result.name).toEqual(datapackage.name)
-    expect(result.title).toEqual(datapackage.title)
-    expect(result.notes).toEqual(datapackage.description)
-    expect(result.version).toEqual(datapackage.version)
-    //expect(result.metadata_created).toEqual(datapackage.created)
+    expect(result.name).toEqual(dataPackage.name)
+    expect(result.title).toEqual(dataPackage.title)
+    expect(result.notes).toEqual(dataPackage.description)
+    expect(result.version).toEqual(dataPackage.version)
+    //expect(result.metadata_created).toEqual(dataPackage.created)
 
     // License
     if (
-      datapackage.licenses &&
-      datapackage.licenses.length > 0 &&
-      datapackage.licenses[0]
+      dataPackage.licenses &&
+      dataPackage.licenses.length > 0 &&
+      dataPackage.licenses[0]
     ) {
-      const license = datapackage.licenses[0]
+      const license = dataPackage.licenses[0]
       if (license.name) expect(result.license_id).toEqual(license.name)
       if (license.title) expect(result.license_title).toEqual(license.title)
       if (license.path) expect(result.license_url).toEqual(license.path)
     }
 
     // Contributors
-    if (datapackage.contributors && datapackage.contributors.length >= 2) {
-      const author = datapackage.contributors.find(c => c.role === "author")
-      const maintainer = datapackage.contributors.find(
+    if (dataPackage.contributors && dataPackage.contributors.length >= 2) {
+      const author = dataPackage.contributors.find(c => c.role === "author")
+      const maintainer = dataPackage.contributors.find(
         c => c.role === "maintainer",
       )
 
@@ -91,9 +91,9 @@ describe("denormalizeCkanPackage", () => {
     }
 
     // Tags
-    if (datapackage.keywords && datapackage.keywords.length > 0) {
-      expect(result.tags).toHaveLength(datapackage.keywords.length)
-      datapackage.keywords.forEach((keyword, index) => {
+    if (dataPackage.keywords && dataPackage.keywords.length > 0) {
+      expect(result.tags).toHaveLength(dataPackage.keywords.length)
+      dataPackage.keywords.forEach((keyword, index) => {
         const tag = result.tags?.[index]
         if (tag && keyword) {
           expect(tag.name).toEqual(keyword)
@@ -103,15 +103,15 @@ describe("denormalizeCkanPackage", () => {
     }
 
     // Resources
-    expect(result.resources).toHaveLength(datapackage.resources.length)
+    expect(result.resources).toHaveLength(dataPackage.resources.length)
 
     // Verify resources exist
-    expect(datapackage.resources.length).toBeGreaterThan(0)
+    expect(dataPackage.resources.length).toBeGreaterThan(0)
     expect(result.resources?.length).toBeGreaterThan(0)
 
-    if (datapackage.resources.length > 0 && result.resources.length > 0) {
+    if (dataPackage.resources.length > 0 && result.resources.length > 0) {
       // Verify first resource
-      const firstResource = datapackage.resources[0]
+      const firstResource = dataPackage.resources[0]
       const firstCkanResource = result.resources[0]
 
       expect(firstCkanResource).toBeDefined()
@@ -135,26 +135,26 @@ describe("denormalizeCkanPackage", () => {
 
   it("handles empty resources array", () => {
     // Arrange
-    const datapackage: Package = {
+    const dataPackage: Package = {
       name: "test-package",
       resources: [],
     }
 
     // Act
-    const result = denormalizeCkanPackage({ datapackage })
+    const result = denormalizeCkanPackage(dataPackage)
 
     // Assert
     expect(result.resources).toEqual([])
   })
 
   it("handles undefined optional properties", () => {
     // Arrange
-    const datapackage: Package = {
+    const dataPackage: Package = {
       resources: [], // Only required property
     }
 
     // Act
-    const result = denormalizeCkanPackage({ datapackage })
+    const result = denormalizeCkanPackage(dataPackage)
 
     // Assert
     expect(result.name).toBeUndefined()
@@ -178,12 +178,10 @@ describe("denormalizeCkanPackage", () => {
     const originalCkanPackage = ckanPackageFixture as CkanPackage
 
     // Act - First normalize to a Frictionless Data Package
-    const datapackage = normalizeCkanPackage({
-      ckanPackage: originalCkanPackage,
-    })
+    const dataPackage = normalizeCkanPackage(originalCkanPackage)
 
     // Then denormalize back to a CKAN package
-    const resultCkanPackage = denormalizeCkanPackage({ datapackage })
+    const resultCkanPackage = denormalizeCkanPackage(dataPackage)
 
     // Assert
     // Basic metadata

ckan/package/process/denormalize.ts

@@ -10,42 +10,38 @@ import type { CkanTag } from "../Tag.js"
  * @param props Object containing the Package to denormalize
  * @returns Denormalized CKAN Package object
  */
-export function denormalizeCkanPackage(props: {
-  datapackage: Package
-}) {
-  const { datapackage } = props
-
+export function denormalizeCkanPackage(dataPackage: Package) {
   const ckanPackage: SetRequired<Partial<CkanPackage>, "resources" | "tags"> = {
     resources: [],
     tags: [],
   }
 
   // Basic metadata
-  if (datapackage.name) ckanPackage.name = datapackage.name
-  if (datapackage.title) ckanPackage.title = datapackage.title
-  if (datapackage.description) ckanPackage.notes = datapackage.description
-  if (datapackage.version) ckanPackage.version = datapackage.version
+  if (dataPackage.name) ckanPackage.name = dataPackage.name
+  if (dataPackage.title) ckanPackage.title = dataPackage.title
+  if (dataPackage.description) ckanPackage.notes = dataPackage.description
+  if (dataPackage.version) ckanPackage.version = dataPackage.version
 
   // Process license information
-  if (datapackage.licenses && datapackage.licenses.length > 0) {
-    const license = datapackage.licenses[0] // Use first license
+  if (dataPackage.licenses && dataPackage.licenses.length > 0) {
+    const license = dataPackage.licenses[0] // Use first license
 
     if (license?.name) ckanPackage.license_id = license.name
     if (license?.title) ckanPackage.license_title = license.title
     if (license?.path) ckanPackage.license_url = license.path
   }
 
   // Process contributors
-  if (datapackage.contributors) {
+  if (dataPackage.contributors) {
     // Find author (contributor with role 'author')
-    const author = datapackage.contributors.find(c => c.role === "author")
+    const author = dataPackage.contributors.find(c => c.role === "author")
     if (author) {
       ckanPackage.author = author.title
       if (author.email) ckanPackage.author_email = author.email
     }
 
     // Find maintainer (contributor with role 'maintainer')
-    const maintainer = datapackage.contributors.find(
+    const maintainer = dataPackage.contributors.find(
       c => c.role === "maintainer",
     )
     if (maintainer) {
@@ -55,19 +51,19 @@ export function denormalizeCkanPackage(props: {
   }
 
   // Process resources
-  if (datapackage.resources && datapackage.resources.length > 0) {
-    ckanPackage.resources = datapackage.resources
-      .map(resource => denormalizeCkanResource({ resource }))
+  if (dataPackage.resources && dataPackage.resources.length > 0) {
+    ckanPackage.resources = dataPackage.resources
+      .map(resource => denormalizeCkanResource(resource))
       .filter((resource): resource is CkanResource => resource !== undefined)
   }
 
   // Process keywords as tags
-  if (datapackage.keywords && datapackage.keywords.length > 0) {
+  if (dataPackage.keywords && dataPackage.keywords.length > 0) {
     // TODO: Rebase on something like CkanPackage / NewCkanPackage
     // with NewCkanTag/Resource etc to separate metadata read from API
     // and metadata that is mapped from Data Package
     // @ts-ignore
-    ckanPackage.tags = datapackage.keywords.map(keyword => {
+    ckanPackage.tags = dataPackage.keywords.map(keyword => {
       const tag: Partial<CkanTag> = {
         name: keyword,
         display_name: keyword,