open-index/open-npm huggingface dataset:
npm package: @kalutheo/uie
Description: uie CLI
Latest version: 0.0.6

# uie CLI

Uie is a cli that will help you to quickly initiate your elm ui explorer project. 

## Publishing to NPM

To package your CLI up for NPM, do this:

```shell
$ npm login
$ npm whoami
$ npm lint
$ npm test
(if typescript, run `npm run build` here)
$ npm publish
```

# License

MIT - see LICENSE
npm package: @kaluza/react-datepicker
Description: React Datepicker loosely based around Material UI design.
Author: Dave Salomon
Latest version: 1.0.2

# React DatePicker

Datepicker component loosely based around Material UI design.

Demo
----

Todo...

Usage
-----

```js
import Calendar from '@kaluza/react-datepicker';

const Page = (props) => (
  <div className="my-page">
    <Calendar />
  </div>
);
```

Props
-----

```js
maxDate  PropTypes.string (ISO Formatted Date)
Default: Today

 

minDate  PropTypes.string (ISO Formatted Date)
Default: 0000-01-01

 

mode     PropTypes.oneOf(['DAY', 'MULTIDAY', 'MONTH', 'YEAR'])
Default: DAY

 

multidayNumberOfSelectedDays   PropTypes.number
Default: 1

 

onCancel  PropTypes.func
Default: () => {}

 

onSelect PropTypes.func
Default: () => {}

 

selectedDate PropTypes.string (ISO Formatted Date)
Default: Today

```
npm package: @kalxjs/compiler-plugin
Description: Webpack and Rollup plugin for KalxJS single-file components
Author: kalxjs Team
Latest version: 1.2.39

# @kalxjs/compiler-plugin

Webpack and Rollup plugin for KalxJS single-file components.

## Installation

```bash
npm install --save-dev @kalxjs/compiler-plugin
```

## Usage with Webpack

```javascript
// webpack.config.js
const { WebpackPlugin } = require('@kalxjs/compiler-plugin');

module.exports = {
  // ...
  module: {
    rules: [
      {
        test: /\.klx$/,
        use: [
          'babel-loader',
          {
            loader: require.resolve('@kalxjs/compiler-plugin/loader'),
            options: {
              // compiler options
            }
          }
        ]
      }
    ]
  },
  plugins: [
    new WebpackPlugin({
      // plugin options
    })
  ]
};
```

## Usage with Rollup

```javascript
// rollup.config.js
import { rollupPlugin } from '@kalxjs/compiler-plugin';

export default {
  // ...
  plugins: [
    rollupPlugin({
      // plugin options
    })
  ]
};
```

## Options

- `sourceMap` - Generate source maps (default: `false`)
- `hot` - Enable hot module replacement (default: `false`)
- `optimize` - Enable optimizations (default: `process.env.NODE_ENV === 'production'`)

## Features

- Compiles KalxJS single-file components (`.klx` files)
- Supports both Webpack and Rollup
- Integrates with Babel for transpilation
- Supports source maps
- Supports hot module replacement

## License

MIT
npm package: @kalxjs/performance
Description: Performance optimization utilities for KalxJs framework
Author: kalxjs Team
Latest version: 1.2.17

# @kalxjs/performance

Performance optimization utilities for KalxJs framework.

## Installation

```bash
npm install @kalxjs/performance
```

## Usage

```javascript
import { 
  lazyLoad, 
  debounce, 
  throttle, 
  memoize, 
  virtualList, 
  withPerformanceTracking 
} from '@kalxjs/performance';

// Lazy load a component
const LazyComponent = lazyLoad(() => import('./HeavyComponent.js'), {
  loading: LoadingSpinner,
  error: ErrorComponent,
  delay: 200,
  timeout: 10000
});

// Debounce a function
const debouncedSearch = debounce((query) => {
  // Search logic here
  fetchSearchResults(query);
}, 300);

// Throttle a function
const throttledScroll = throttle(() => {
  // Scroll handler logic
  updateScrollPosition();
}, 100);

// Memoize a function
const expensiveCalculation = memoize((a, b) => {
  // Complex calculation
  return a * b * Math.sqrt(a + b);
});

// Create a virtualized list
const VirtualizedList = virtualList({
  itemHeight: 50,
  overscan: 5,
  getKey: (item) => item.id
});

// Use the virtualized list
const MyList = {
  setup() {
    const items = ref([/* many items */]);
    
    return () => h(VirtualizedList, {
      items: items.value,
      renderItem: (item) => h('div', {}, item.name)
    });
  }
};

// Track component performance
const TrackedComponent = withPerformanceTracking(MyComponent, {
  name: 'MyComponent',
  logToConsole: true,
  onMeasure: (stats) => {
    // Send performance data to analytics
    analytics.trackPerformance(stats);
  }
});
```

## Features

### Lazy Loading

Load components only when they're needed to reduce initial bundle size.

### Debounce & Throttle

Limit the rate at which functions are called to improve performance.

### Memoization

Cache function results to avoid redundant calculations.

### Virtual List

Efficiently render large lists by only rendering items in the viewport.

### Performance Tracking

Measure and monitor component render performance.

## API Reference

### lazyLoad(factory, options)

Lazy load a component with loading and error states.

### debounce(fn, wait, immediate)

Create a debounced function that delays invoking the function until after `wait` milliseconds.

### throttle(fn, limit)

Create a throttled function that only invokes the function at most once per `limit` milliseconds.

### memoize(fn, keyResolver)

Create a memoized function that caches results based on input arguments.

### virtualList(options)

Create a virtualized list component for efficient rendering of large lists.

### withPerformanceTracking(component, options)

Wrap a component with performance measurement.

## License

MIT
npm package: @kalxjs/state
Description: Component state management for KalxJS framework
Author: kalxjs Team
Latest version: 1.2.59

# kalxjs State

Next-generation state management for kalxjs applications with composables, TypeScript, and optimized performance.

## Features

- **Composable State**: State composition with hooks
- **Atomic Updates**: Fine-grained reactivity
- **TypeScript Support**: Full type inference
- **State Time Travel**: Undo/redo capabilities
- **State Persistence**: Built-in storage adapters
- **State Sync**: Real-time state synchronization
- **DevTools Integration**: Advanced debugging
- **Performance Optimizations**: Automatic batching

## Installation

```bash
npm install @kalxjs-framework/state
```

## Modern Usage

```typescript
import { defineStore } from '@kalxjs-framework/state'
import type { State, Actions, Getters } from '@kalxjs-framework/state'

// Define store types
interface TodoState {
  items: Todo[]
  filter: 'all' | 'active' | 'completed'
}

// Create type-safe store
const useTodoStore = defineStore<TodoState>({
  id: 'todos',
  
  state: () => ({
    items: [],
    filter: 'all'
  }),

  actions: {
    async addTodo(text: string) {
      const todo = await api.createTodo({ text })
      this.items.push(todo)
    }
  },

  getters: {
    filtered(): Todo[] {
      return this.items.filter(todo => 
        this.filter === 'all' || 
        todo.completed === (this.filter === 'completed')
      )
    }
  }
})

// Use in components
const TodoList = defineComponent({
  setup() {
    const store = useTodoStore()
    const todos = computed(() => store.filtered)
    
    return { todos }
  }
})
```

## Advanced Features

### State Composition

```typescript
// Composable state logic
function useAuth() {
  const user = signal<User | null>(null)
  const isLoggedIn = computed(() => !!user())
  
  async function login(credentials: Credentials) {
    user.value = await api.login(credentials)
  }
  
  return {
    user,
    isLoggedIn,
    login
  }
}

// Use in store
const useAppStore = defineStore({
  compose: () => {
    const auth = useAuth()
    const todos = useTodoStore()
    
    return {
      auth,
      todos
    }
  }
})
```

### State Persistence

```typescript
import { persistence } from '@kalxjs-framework/state'

const store = defineStore({
  persist: {
    storage: localStorage,
    paths: ['user', 'settings'],
    serializer: {
      serialize: JSON.stringify,
      deserialize: JSON.parse
    }
  }
})
```

### Performance

```typescript
import { batch, transaction } from '@kalxjs-framework/state'

// Batch multiple commits
batch(() => {
  store.commit('updateMany', items)
  store.commit('updateStatus', 'done')
})

// Transactional updates
transaction(async () => {
  await store.dispatch('transferFunds')
  await store.dispatch('updateBalance')
})
```

## License

MIT
npm package: @kalxjs/store
Description: Global state management for KalxJS framework
Author: kalxjs Team
Latest version: 1.0.14

# @kalxjs/store

> Global state management for KalxJS applications

This package provides a state management solution for KalxJS applications.

## Installation

```bash
npm install @kalxjs/store
```

## Usage

```js
import { createApp } from '@kalxjs/core';
import { createStore } from '@kalxjs/store';
import App from './App.js';

// Create a store
const store = createStore({
  state: {
    count: 0
  },
  mutations: {
    increment(state) {
      state.count++;
    },
    decrement(state) {
      state.count--;
    }
  },
  actions: {
    incrementAsync({ commit }) {
      setTimeout(() => {
        commit('increment');
      }, 1000);
    }
  }
});

// Create app and use store
const app = createApp(App);
app.use(store);
app.mount('#app');
```

In your components:

```js
import { mapState } from '@kalxjs/store';

export default {
  computed: {
    ...mapState(['count'])
  },
  methods: {
    increment() {
      this.$store.commit('increment');
    },
    decrement() {
      this.$store.commit('decrement');
    },
    incrementAsync() {
      this.$store.dispatch('incrementAsync');
    }
  }
};
```

## API

### `createStore(options)`

Creates a new store instance.

Options:
- `state`: The root state object
- `mutations`: Methods to mutate the state
- `actions`: Methods to perform async operations and commit mutations
- `getters`: Computed properties for the store

### `mapState(namespace?, map)`

Maps store state to component computed properties.

### `mapGetters(namespace?, map)`

Maps store getters to component computed properties.

### `mapMutations(namespace?, map)`

Maps store mutations to component methods.

### `mapActions(namespace?, map)`

Maps store actions to component methods.

## License

MIT